Golang学习笔记

最新推荐文章于 2024-09-20 13:39:31 发布
最新推荐文章于 2024-09-20 13:39:31 发布
阅读量699 收藏 1
点赞数
文章标签： 学习 Golang 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19903753/article/details/100671179
版权

Golang学习笔记

文章目录

Go是啥？

Golang 简称 Go，是一个开源的编程语言。

Go语言的用途

Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。
Go 语言在用于高性能分布式系统开发中，无疑比大多数其它语言有着更高的开发效率。此外，它提供了海量并行的支持，这对于游戏服务端的开发而言也是不错的选择。

Go语言的特点

  • 优点
    • 简洁、快速、安全
    • 支持并发编程
    • 自动垃圾回收
    • 编译迅速
    • 开源
    • 便捷部署：：go最终生成的是一个 可执行文件，不管你的程序依赖多少库，都会被打包进行，生成一个可执行文件，所以相比java庞大的jar库来说，他的部署非常方便，执行运行这个可执行文件就好了。
  • 缺点
    • 错误处理比较繁琐，需要写很多 err 判断

Go基本语法

基本数据类型

bool

String

整数：

int8（-128 -> 127） int16（-32768 -> 32767） int32（-2,147,483,648 -> 2,147,483,647） int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

无符号整数：

uint8（0 -> 255） uint16（0 -> 65,535） uint32（0 -> 4,294,967,295） uint64（0 -> 18,446,744,073,709,551,615）

浮点型（IEEE-754 标准）：

float32（± 1e-45 -> ± 3.4 * 1e38） float64（± 5 * 1e-324 -> 107 * 1e308）

uintptr 同指针,32位平台为4字节,64位八字节

byte 等价于uint8

rune 等价于uint32，单个unicode字符

复数类型：complex64,complex128

int 型是计算最快的一种类型。

整型的零值为 0，浮点型的零值为 0.0

结构化的（复合的），如：struct、array、slice、map、channel；

只描述类型的行为的，如：interface

Go变量的定义

package main
import(
	"fmt"
)
func main() {
	//1.指定变量类型,若不赋值,使用默认值
	var num int
	var num1 int = 1
	fmt.Println(num,num1)
	//2.根据值自行判定变量类型(类型推导),其实就是不写类型,根据你赋的值判断
	var num2  = 2
	fmt.Println(num2)
	//3.省略 var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误
	num3 := 3
	fmt.Println(num3)
	//4.批量定义
	var n1, n2, n3 int
	fmt.Println(n1,n2,n3)
	fmt.Println("=======")
	var n4, name, n5 = 100, "tom",888
	fmt.Println("n4=",n4,"name=",name,"n5=",n5)
	fmt.Println("======")
	n6, name1, n7 := 6, "name1",7
	fmt.Println("n6=",n6,"name1=",name1,"n7=", n7)

}

查看数据类型

package main
import(
	"fmt"
	"unsafe"
)
func main() {
	//如何在程序查看某个变量的字节大小和数据类型 （使用较多）
	var i uint16 = 100
	fmt.Printf("i 的类型%T,占用的字节数:%d\n",i,unsafe.Sizeof(i))
	var i1 uint = 100
	fmt.Printf("i 的类型%T,占用的字节数:%d",i1,unsafe.Sizeof(i1))
}

i 的类型uint16,占用的字节数:2
i 的类型uint,占用的字节数:8

查看字符的码值

package main
import(
	"fmt"
)
func main() {
	var i byte = 'a'
	fmt.Printf("i对应的类型：%T,对应的字符：%c,对应的码值：%d\n", i, i, i)
	var i1= ','
	fmt.Printf("i对应的类型：%T,对应的字符：%c,对应的码值：%d\n", i1, i1, i1)
	var i2= '南'
	fmt.Printf("i对应的类型：%T,对应的字符：%c,对应的码值：%d\n", i2, i2, i2)
	//var i3 byte= '经' //报错：constant 32463 overflows byte
}

i对应的类型：uint8,对应的字符：a,对应的码值：97
i对应的类型：int32,对应的字符：,,对应的码值：44
i对应的类型：int32,对应的字符：南,对应的码值：21335

字符串

package main

import "fmt"

func main() {
	//字符串golang
	//双引号
	var str1  = "hello"
	//单引号将字符串完整格式都打出
	str2 := `
		pachage
		it is time;
		lets go;
	`
	fmt.Println(str1)
	fmt.Println(str2)
}

hello

		pachage
		it is time;
		lets go;

数值类型转换

表达式 T(v) 将值 v 转换为类型 T
T: 就是数据类型，比如 int32，int64，float32 等等
v: 就是需要转换的变量

注意事项
  1. Go 中，数据类型的转换可以是从 表示范围小–>表示范围大，也可以 范围大—>范围小
  2. 被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！

在转换中，比如将 int64 转成 int8 【-128—127】 ，编译时不会报错，只是转换的结果是按
溢出处理，和我们希望的结果不一样。 因此在转换时，需要考虑范围

基本类型转 string 类型

方式一:fmt.Sprintf("%参数", 表达式)

package main

import "fmt"

func main() {
	var i  = true
	var i1  = 1
	var i2  = 1.3
	var s1 = fmt.Sprintf("%v",i)
	fmt.Printf("i对应的类型：%T,对应的值%v\n",s1,s1)
	var s2 = fmt.Sprintf("%v",i1)
	fmt.Printf("i对应的类型：%T,对应的值%v\n",s2,s2)
	var s3 = fmt.Sprintf("%v",i2)
	fmt.Printf("i对应的类型：%T,对应的值%v\n",s3,s3)
	fmt.Println(s1+s2+s3)
}

i对应的类型：string,对应的值true
i对应的类型：string,对应的值1
i对应的类型：string,对应的值1.3
true11.3

方式二：使用 strconv 包的函数

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var i  = true
	var i1  = 10
	var i2  = 1.3
	var s1 = strconv.FormatBool(i)
	fmt.Printf("i对应的类型：%T,对应的值%v\n",s1,s1)
	//整型需要转换成int64,还需指定对应的进制
	var s2 = strconv.FormatInt(int64(i1),10)
	fmt.Printf("i对应的类型：%T,对应的值%v\n",s2,s2)
	//f表示格式；　10表示小数位保留10位; 64表示float64
	var s3 = strconv.FormatFloat(i2,'f',10,64)
	fmt.Printf("i对应的类型：%T,对应的值%v\n",s3,s3)
	fmt.Println(s1+s2+s3)
}


i对应的类型：string,对应的值true
i对应的类型：string,对应的值10
i对应的类型：string,对应的值1.3000000000
true101.3000000000
string 类型转基本数据类型

使用时 strconv 包的函数

img

注：返回的都是int64和float64，如不满足需求需要自己转换

注意事项

在将 String 类型转成 基本数据类型时，要确保 String 类型能够转成有效的数据，比如 我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数，如果这样做，Golang 直接将其转成 0 ，其它类型也是一样的道理. float => 0 bool => false

指针

在这里插å¥å›¾ç‰‡æè¿°

  1. 基本数据类型，变量存的就是值，也叫值类型；
  2. 获取变量的地址，用&，比如： var num int, 获取 num 的地址：&num；
  3. 指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值
    比如：var ptr *int = &num；
  4. 获取指针类型所指向的值，使用：*，比如：var ptr int, 使用ptr 获取 ptr 指向的值；

数组

数组可以存放多个同一类型数据。数组也是一种数据类型，在 Go 中，数组是值类型。

数组的定义

var 数组名 [数组大小]数据类型
var a [5]int
赋初值 a[0] = 1 a[1] = 30 …

数组在内存布局

img

对上图的总结:

  1. 数组的地址可以通过数组名来获取 &intArr；
  2. 数组的第一个元素的地址，就是数组的首地址；
  3. 数组的各个元素的地址间隔是依据数组的类型决定，比如 int64 -> 8 int32->4…。
四种初始化数组的方式
func main() {
	var arr [2]int = [2]int{1,2}
	fmt.Println(arr)
	
	//这里[...]是固定写法，省去了指定数组长度
	var arr1 [2]int = [...]int{1,2}
	fmt.Println(arr1)
	var arr2  = [...]int{1,2}
	fmt.Println(arr2)
	
	//指定数组元素的顺序
	var arr3  = [...]int{1:1,0:2}
	fmt.Println(arr3)
	
	//通过类型推导
	 arr4  := [...]string{1:"tom",0:"susan"}
	fmt.Println(arr4)
}

切片

切片是什么?
  1. 切片是可变数组
  2. 切片的英文是 slice
  3. 切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。
  4. 切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度 len(slice)都一样。
  5. 切片的长度是可以变化的，因此切片是一个可以动态变化数组。
切片的定义方式

方式一:

定义一个切片，然后让切片去引用一个已经创建好的数组。

slice :=arr[a:b:c]

a:起始位置
b:截取数据的结束位置 默认到末端）
c:截取后的容量位置 默认到末端）
slice的len = b - a
slice的cap = c - a
底层数组： 为原数组的下标a到下标b(不包括)的所有元素

func main() {
    //定义一个数组
	var arr = [...]string{"张学友","刘德华","黎明","郭富城","成龙","周星驰"}
    //定义切片,参数分别为:起始位置,终止位置,切片的容量
	slice :=arr[1:3:5]
	fmt.Printf("slice容量:%d,长度:%d,值:%v\n",cap(slice),len(slice),slice)
	fmt.Printf("slice地址:%p",slice)
}


slice容量:4,长度:2,值:[刘德华 黎明]
slice地址:0xc000084130

方式二:

通过 make 来创建切片
基本语法：var 切片名 []type = make([]type, len, [cap])

参数说明:
type: 就是数据类型
len : 大小
cap ：指定切片容量，可选， 如果你分配了 cap,则要求 cap>=len.

func main() {
	slice :=make([]int,3,5)
	slice[0] = 100
	slice[1] = 200
	slice[2] = 300
	fmt.Printf("slice容量:%d,长度:%d,值:%v\n",cap(slice),len(slice),slice)
	fmt.Printf("slice地址:%p\n",slice)
	//slice[3] = 400 //runtime error: index out of range 报错
	slice = append(slice, 400)
	slice = append(slice, 500)
	fmt.Printf("slice容量:%d,长度:%d,值:%v\n",cap(slice),len(slice),slice)
	fmt.Printf("slice地址:%p\n",slice)
	slice = append(slice, 600)
	fmt.Printf("slice容量:%d,长度:%d,值:%v\n",cap(slice),len(slice),slice)
	fmt.Printf("slice地址:%p",slice)
}



slice容量:5,长度:3,值:[100 200 300]
slice地址:0xc000016120
slice容量:5,长度:5,值:[100 200 300 400 500]
slice地址:0xc000016120
slice容量:10,长度:6,值:[100 200 300 400 500 600]
slice地址:0xc000074000

与第一种方式的区别:

在这里插å¥å›¾ç‰‡æè¿°

方式三:

定义一个切片，直接指定具体数组，相当于直接把切片当数组用。

func main() {
	slice :=[]string{"张学友","刘德华","黎明","郭富城","成龙","周星驰"}
	fmt.Printf("slice容量:%d,长度:%d,值:%v\n",cap(slice),len(slice),slice)
	fmt.Printf("slice地址:%p",slice)
}


slice容量:6,长度:6,值:[张学友 刘德华 黎明 郭富城 成龙 周星驰]
slice地址:0xc000052180
切片在内存中形式

在这里插å¥å›¾ç‰‡æè¿°

切片的遍历
  • for 循环常规方式
  • 遍历for-range 结构遍历
func main() {
	slice :=[]string{"张学友","刘德华","黎明","郭富城","成龙","周星驰"}
	fmt.Println("常规方式")
	for i:=0; i<len(slice) ; i++  {
		fmt.Printf("%d ===> %v\n",i,slice[i])
	}
	fmt.Println("结构遍历")
	for index,value := range slice{
		fmt.Printf("%d ===> %v\n",index,value)
	}
}

Map

Go语言中的Map集合几乎和Java里面的差不多，但是Go语言里面，定义Map集合是不能使用的，需要手动用make方法分配内存。

Map集合定义

var a map[string]string
var a map[string]int
var a map[int]string
var a map[string]map[string]string

分配空间

func main() {
	var m = make(map[int]interface{},1)
	m[1]="A"
	m[2]="B"
	fmt.Printf("m地址:%p;m的值:%v",m,m)
}
Map集合的使用

方式一:

用make函数分配内存，并且指定长度。

func main() {
	var m = make(map[int]interface{},1)
	m[1]="A"
	m[2]="B"
	fmt.Printf("m地址:%p;m的值:%v",m,m)
}


m地址:0xc00005c150;m的值:map[1:A 2:B]

方式二：

不指定长度。

func main() {
	var m = make(map[int]interface{})
	m[1]="A"
	m[2]="B"
	fmt.Printf("m地址:%p;m的值:%v",m,m)
}


m地址:0xc00005c150;m的值:map[1:A 2:B]

方式三：

直接声明并赋值，注意最后要加上,(逗号)。

func main() {
	var m = map[int]interface{}{
		1:"A",
		2:"B",
	}
	fmt.Printf("m地址:%p;m的值:%v",m,m)
}


m地址:0xc000070150;m的值:map[2:B 1:A]
Map操作
map 增加和更新

map[“key”] = value //如果 key 还没有，就是增加，如果 key 存在就是修改。

map 删除：

delete(map，“key”) ，delete 是一个内置函数，如果 key 存在，就删除该 key-value,如果 key 不存在，
不操作，但是也不会报错。

如果我们要删除 map 的所有 key ,没有一个专门的方法一次删除，可以遍历一下 key, 逐个删除
或者 map = make(…)，make 一个新的，让原来的成为垃圾，被 gc 回收

map 查找

value := m[key]

如果 m这个 map 中存在 key ， 那么 返回 对应的value,否则返回 对应value类型的默认值

map 遍历
func main() {
	var m = map[int]interface{}{
		1:"A",
		2:"B",
	}

	fmt.Printf("m地址:%p;m的值:%v\n",m,m)
	//添加
	m[3]="C"
	fmt.Printf("m地址:%p;m的值:%v\n",m,m)
	//更新
	m[2]= "H"
	//删除
	delete(m,3)
	//遍历
	for key,value:= range m{
		fmt.Printf("key:%v ; value:%v\n",key,value)
	}
	fmt.Printf("m地址:%p;m的值:%v\n",m,m)
}


m地址:0xc00005c150;m的值:map[1:A 2:B]
m地址:0xc00005c150;m的值:map[1:A 2:B 3:C]
key:1 ; value:A
key:2 ; value:H
m地址:0xc00005c150;m的值:map[2:H 1:A]
总结

  1. map 在使用前一定要 make；

  2. map 的 key 是不能重复，如果重复了，则以最后这个 key-value 为准；

  3. map 的 value 是可以相同的， map 的 key-value 是无序；

  4. map 是引用类型，遵守引用类型传递的机制，在一个函数接收 map，修改后，会直接修改原来
    的 map；

  5. map 的容量达到后，再想 map 增加元素，会自动扩容，并不会发生 panic，也就是说 map 能动

    态的增长 键值对(key-value)；

  6. map 的 value 也经常使用 struct 类型，更适合管理复杂的数据(比前面 value 是一个 map 更好)，比如 value 为 Student 结构体。

结构体

Golang语言面向对象编程的说明：

  1. Golang支持面向对象编程，但是不是纯粹面向对象编程；
  2. Golang 没有类(class)，Go 语言的==结构体(struct)==和其它编程语言的类(class)有同等的地位，你可
    以理解 Golang 是基于 struct 来实现 OOP 特性的；
  3. Golang 面向对象编程非常简洁，去掉了传统 OOP 语言的继承、方法重载、构造函数和析构函
    数、隐藏的 this 指针等等；
  4. Golang 仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其它 OOP 语言不
    一样，比如继承 ：Golang 没有 extends 关键字，继承是通过匿名字段来实现；
  5. Golang也是面向接口编程的。
结构体定义
type 结构体名称 struct {
field1 type
field2 type
}

示例：

type Student struct {
Name string //字段
Age int //字段
Score float32
}

在创建一个结构体变量后，如果没有给字段赋值，都对应一个零值(默认值)，规则同前面讲的
一样:

  1. 布尔类型是 false ，数值是 0 ，字符串是 “”；
  2. 数组类型的默认值和它的元素类型相关，比如 score [3]int 则为[0, 0, 0]；
  3. 指针，slice，和 map 的零值都是 nil ，即还没有分配空间。
创建结构体变量

方式一

var person Person

方式二

var person Person = Person{}

方式三

var person *Person = new (Person)

方式四

var person *Person = &Person{}

示例:

type Person struct {
	Name string
	Age int
}
func main() {
	var p1 Person
	p1.Name="jerry"
	p1.Age=55
	fmt.Printf("p1的值:%v\n",p1)
	var p2 Person= Person{Name:"susan",Age:10}
	fmt.Printf("p2的值:%v\n",p2)
	var p3 *Person = new(Person)
	p3.Name="jeck"
	p3.Age=66
	fmt.Printf("p3的值:%v\n",p3)
	var p4 *Person= &Person{Name:"john",Age:88}
	fmt.Printf("p4的值:%v\n",p4)
}


p1的值:{jerry 55}
p2的值:{susan 10}
p3的值:&{jeck 66}
p4的值:&{john 88}

总结:

  1. 第 3 种和第 4 种方式返回的是 结构体指针。

  2. 结构体指针访问字段的标准方式应该是：(*结构体指针).字段名 ，比如 (*person).Name = “tom” 3) 但 go 做了一个简化，也支持 结构体指针.字段名, 比如 person.Name = “tom”。更加符合程序员使用的习惯，go 编译器底层 对 person.Name 做了转化 (*person).Name。

  3. 结构体的所有字段在内存中是连续的

  4. 结构体是用户单独定义的类型，和其它类型进行转换时需要有完全相同的字段(名字、个数和类
    型)

  5. 结构体进行 type 重新定义(相当于取别名)，Golang 认为是新的数据类型，但是相互间可以强转

    type Person struct {
	Name string
	Age int
}
type ps Person
func main() {
	var p1 ps
	p1.Name="jerry"
	p1.Age=55
	fmt.Printf("p1的值:%v\n",p1)
	var p2 Person= Person(p1)
	fmt.Printf("p2的值:%v\n",p2)
}

  6. struct 的每个字段上，可以写上一个 tag, 该 tag 可以通过反射机制获取，常见的使用场景就是序
    列化和反序列化。

方法

Go语言里面也和java一样，对应的结构体可以有自己的方法。

方法的声明和调用
type Person struct {
	Name string
	Age int
}

func (p Person) hello() {
	fmt.Printf("hello ! my name is %v",p.Name)
}
func main() {
	var p Person
	p.Name="jerry"
	p.Age=55
	p.hello()
}
  1. func (p Person) hello() {} 表示 Person 结构体有一方法，方法名为 hello；
  2. (p Person) 体现 hello方法是和 Person 类型绑定的；
  3. hello方法和 Person 类型绑定；
  4. hello方法只能通过 Person 类型的变量来调用，而不能直接调用，也不能使用其它类型变量来调
    用；
  5. func (p Person) hello() {}… p 表示哪个 Person 变量调用，这个 p 就是它的副本, 这点和函数传参非
    常相似；
  6. p 这个名字，有程序员指定，不是固定, 比如修改成 person 也是可以。

方法是可以有参数、返回值，比如：

func (p Person) getSum(a int, b int) (c int) {
	c = a + b
	return 
}

也可以写成:

func (p Person) getSum(a int, b int) int {
	return a + b
}

注意 不能返回==局部变量的地址值;因为函数调用结束，栈帧释放，局部变量的地址，不再受系统保护，随时可能分配给其他程序，可以返回局部变量的值==。

方法与函数的区别
type Circle struct {
	R float64
}

func (c Circle)getArea() float64 {
	return math.Pi * math.Pow(c.R,2)
}
func main() {
	var c = Circle{R: 2}
	area := c.getArea()
	fmt.Printf("面积:%v",area)
}
  1. 调用方式不一样
    函数的调用方式: 函数名(实参列表)
    方法的调用方式: 变量.方法名(实参列表)
  2. 对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然；
  3. 对于方法（如 struct 的方法），接收者为值类型时，可以直接用指针类型的变量调用方法，反
    过来同样也可以。

继承

属性继承

在Go中使用的是匿名属性，来实现继承的；即将父类作为子类的匿名属性。

package main

import "fmt"

type Person struct {
	id int
	name string
	age  int
}

type Student struct {
	Person
	id int
	score     int
	className string
}

func main() {
	var (
		s Student
	)
	s = Student{
		Person{name: "susan", age: 23,id:123},
		456,
		58,
		"302班"}

	fmt.Printf("ID：%d\n姓名：%s\n年龄：%d\n班级：%s\n分数：%d",
		s.id,s.name,s.age,s.className,s.score)
}

注意：在Student对象中可以直接使用父类Person的属性，如果父类和子类中有重复字段，则优先使用子类自身的属性。

方法继承和重写

方法的继承和属性的继承是类似的，当一个类是另一个类的匿名属性时即可直接使用该类的方法

package main

import "fmt"

type Person struct {
	id int
	name string
	age  int
}
//父类say方法
func (p Person)say(msg string)  {
	fmt.Printf("[person] %s say: '%s'",p.name,msg)
}
//student子类say方法
func (s Student)say(msg string){
	fmt.Printf("[student] %s say: '%s'",s.name,msg)
}

type Student struct {
	Person
	id int
	score     int
	className string
}

func main() {
	var (
		s Student
	)
	s = Student{
		Person{name: "susan", age: 23,id:123},
		456,
		58,
		"302班"}

	fmt.Printf("ID：%d\n姓名：%s\n年龄：%d\n班级：%s\n分数：%d\n",
		s.id,s.name,s.age,s.className,s.score)
	s.say("hello world")
}


ID：456
姓名：susan
年龄：23
班级：302班
分数：58
[student] susan say: 'hello world'

方法的重写，在语法格式上有一定的要求，即方法名，参数，返回值类型都必须一样，但绑定的对象不再是父类而是子类本身。

接口、多态

接口的定义
type annimal interface {
	eat()
	sleep()
	run()
}
接口的继承与实现

接口的继承与实现也是将被继承和实现的接口以匿名属性传入即可。

package main

import "fmt"

type annimal interface {
	eat()
	sleep()
	run()
}

type cat interface {
	annimal
	Climb()
}

type HelloKitty struct {
	cat
}

func (h HelloKitty)eat(){
	fmt.Println("eat cake!!")
}

func main() {
	var a annimal
	a = HelloKitty{}
	a.eat()
}
多态
package main

import "fmt"

type annimal interface {
	eat()
	sleep()
	run()
}

type cat interface {
	annimal
	Climb()
}
type dog interface {
	annimal
}

type HelloKitty struct {
	cat
}
type husky struct {
	dog
}

func (h HelloKitty)eat(){
	fmt.Println("eat cake!!")
}

func (h husky)eat(){
	fmt.Println("eat bone!!")
}

func test(a annimal){
	a.eat()
}

func main() {
	var a annimal
	a = HelloKitty{}
	test(a)
	a = husky{}
	test(a)
}

test方法中传入了一个animal对象，在实际调用时会因传入对象的不同而得到不同的效果
结果：

eat cake!!
eat bone!!
类型断言

判断具体的类型，在go中可以使用 对象.(指定的类型) 判断改对象是否时指定的类型。

func main() {
	var a annimal
	a = HelloKitty{}
	var b annimal
	b = husky{}

	var animals [2]annimal =[...]annimal{a,b}

	for _,v :=range animals{
        //注意这里!================================================
		if data,ok :=v.(husky);ok{
			data.eat()
			fmt.Println("this is wangcai : ")
		}
		if data,ok :=v.(HelloKitty);ok{
			data.eat()
			fmt.Println("this is HelloKitty : ")
		}
	}

}

==注意：==if条件中的data,ok :=v.(husky);ok，v.(husky)返回了两个值——v和bool类型，如果v是husky类型，那么将v的对象传递给data，true传递给ok，这样弥补了一个问题：问题的链接。

异常

异常分为：

  1. 编译时异常：在编译时抛出的异常，编译不通过，语法使用错误，符号填写错误等等。。。
  2. 运行时异常：在程序运行时抛出的异常，这个才是我们将要说的，程序运行时，有很多状况发生，例如：让用户输入一个数字，可用户偏偏输入一个字符串，导致的异常，数组的下标越界，空指针等等。。。。
处理异常的方法

方法一：添加判断

这种是比较常见的作法，将每种异常都考虑到，然后做出响应的处理

package main

import (
	"errors"
	"fmt"
)

func test(a int,b int) (int,error){
	var err error
	if a == 0{
		return 0,errors.New("a 不可以为0！！")
	}
	a = b / a
	return a,err
}

func main() {
	i,err := test(0, 1)
	if err ==nil{
		fmt.Println("====main方法正常结束！！====",i)
	}else{
		fmt.Println(err)
	}
}

方法二：捕捉异常

异常的场景会有很多，会很难统计出来，或统计出来后出来很麻烦；此时我们就要对异常进行捕捉
这里将用到defer和recover
defer：延时执行，即在方法执行结束（出现异常而结束或正常结束）时执行
recover：恢复的意思，如果是异常结束程序不会中断，返回异常信息，可以根据异常来做出相应的处理
recover必须放在defer的函数中才能生效

package main

import (
	"errors"
	"fmt"
)

func test(a int,b int) (int,error){
	var err error
	if a == 0{
		return 0,errors.New("a 不可以为0！！")
	}
	a = b / a
	return a,err
}

func main() {
	i,err := test(0, 1)
	if err ==nil{
		fmt.Println("====main方法正常结束！！====",i)
	}else{
		fmt.Println(err)
	}
}

方法三：手动抛出异常

看到异常总觉得很讨厌，但有的时候它能帮助我们解决很多麻烦事，比如用户输入错误，就应该抛出异常，可以让这个异常一层层的返回给调用方的程序，使其不能继续执行，从而起到保护后面业务的目的，也简化了错误信息的传递，例如：

一个人取钱,账户只有100元，他输入了200元，从输入到账户扣款经过了20个方法调用，那总不能将这个err传递这么多次，传到起始的调用处吧？，后面的扣款业务也不能执行的

package main

import (
	"errors"
	"fmt"
)

func test(a int) int {
	i:=100 - a
	if i<0{
		panic(errors.New("账户金额不足！！！！"))
	}
	fmt.Println("=======账户扣款=====")
	return i
}

func main() {
	i := test(101)
	fmt.Println("====main方法正常结束！！====余额：",i)
}


panic: 账户金额不足！！！！

goroutine 1 [running]:
雨声残响丶
关注
Golang 挖坑之旅——常量转换问题
Stay Sharp
04-02 652
Golang 挖坑之旅——常量转换问题 0. 问题描述 参考如下代码： package main import ( "fmt" ) // 这段代码简单进行一个实验，将尝试使用byte对123123进行截断 func main() { var x = 123123 fmt.Printf("%b\n", byte(x)) fmt.Printf("%b\n", byte(123123)) } ...
Golang学习笔记：语言规范二
Schelor的专栏
10-17 1696
类型转换形式为 T(x), T是一种类型，x是目标类型表达式。示例*Point(p) // same as *(Point(p)) (*Point)(p) // p is converted to *Point <-chan int(c) // same as <-(chan int(c)) (<-chan int)(c) // c is converted to
Golang系列之整数类型基本介绍
Nicky's blog
01-21 1919
Golang系列之整数类型基本介绍，整数类型，简单来说，就是用于存放整数值的类型，也可以简称为整型。每门编程语言都有对应的数据类型，在golang中的整数类型要怎么使用？请看本博客
Go语言学习(4) - 基本数据类型
weixin_34019144的博客
11-26 199
Go语言中的数据类型包含两种： 基本数据类型（原生数据类型）：整型、浮点型、布尔型、字符串、字符（byte、rune） 复合数据类型（派生数据类型）：指针（pointer）、数组（array）、切片（slice）、映射（map）、函数（function）、结构体（struct）、通道（channel） 整型 整型分为两大类 按长度分：int8、int16、int32、int64、int 无符...
go语言的变量的使用篇二
菩提本无树明镜亦非台的博客
02-21 473
一、整数类型基本使用 简单的说，整数类型就是用于存放整数值的。在go语言中，整数类型分为有符号数和无符号数（和C语言类似），表示有符号数和无符号数的方式也和C语言类似，例如使用u前缀表示无符号数。 与C语言不同的是，go语言采用了更为简单明了的表示方法，将整数占用的最大的位的长度直接反映在类型之中，例如int16标识使用的十六位存储的有符号数等。 类型 有无符号数 占用存储空间 ...
golang学习笔记
逸琅的博客
03-05 256
golang学习笔记 第一章 hello wold package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。如果只有一个.go文件，则该文件开头必须为main 使用goland编程时，可以直接使用函数，然后自动import包 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。 /。。。/为注释 当标识符（包括常量、变量、类型、函数名、结
GOlang 学习笔记
u014519674的博客
06-30 148
学习go语言笔记
GoLang学习笔记1
08-03
在本篇GoLang学习笔记中，我们将探讨Go语言的基础知识，包括类型、变量、常量、自定义类型、基本类型以及复合类型。 1. 类型与变量 在Go语言中，使用`var`关键字来定义变量，并为其分配零值。例如： ```go var x ...
雨痕golang学习笔记第四版 加上书签版
08-05
《雨痕golang学习笔记第四版 加上书签版》是针对Go语言学习者的参考资料，作者雨痕在书中详细记录了从2012年开始学习Go语言至今的经验与成果。本书内容全面，涵盖了Go语言的基础知识、数据结构、函数特性、并发编程...
Golang学习笔记（一）：简介
01-21
安装说明 地址 http://golang.org/doc/install 包下载 地址 https://code.google.com/p/go/downloads/list 确认是否安装成功 代码如下: go version //查看版本 环境变量设置 整体目录结构 通过package组织，只有...
golang 学习笔记
10-18
golang学习笔记，需使用mybase打开 截图，https://img-bbs.csdn.net/upload/201810/18/1539860619_543624.png
深入浅出Go常量
hiro的博客
12-03 4223
欢迎转载,请保留转载来源: 摘要 问题背景 问题原因扼要 官方blog翻译 介绍 背景C 术语定义 字符串常量 默认类型 由语法决定的默认类型 布尔值 浮点数 复数 整型 练习最大的unsigned int值 数值 一些补充 编译器在实现常量的时候必须遵循如下规则 go的类型转换规则摘要:本文尝试对GO当中的常量的使用细节展开探讨,结合本人最近遇到的实际问题,通过翻译官方在2014/08/25发的关
探索《越南语翻译通》App：高效语言学习的利器
最新发布
工作姬
09-20 319
无论您是语言学习新手还是希望提高语言技能的专业人士，这款App都能为您提供帮助。它的学习材料覆盖了语言学习的各个方面，帮助用户全面掌握新语言。随着科技的发展，我们有了更多便捷的工具来帮助我们学习新的语言。今天，我们来探索一款名为《越南语翻译通》的App，它正逐渐成为语言学习者的新宠。《越南语翻译通》App采用了先进的AI技术，能够根据用户的学习进度和习惯，提供个性化的学习建议。它不仅提供了丰富的语言学习资源，还具备实时翻译功能，帮助用户在实际对话中快速理解和使用新语言。
source insight学习笔记
aa98865646的博客
09-18 416
比如常见好用的基础配置，常用的基础操作等。有时一些中文注释是 GB2312 的，使用默认的 UTF-8 编码打开就会编程乱码，可以依次点击菜单栏。比如下面我需要在当前文件中寻找extension这个符号的所有内容。这个一般是在当前文件中搜索，如果需要在整个项目搜索需要别的方式。代码出错用来定位的，也是很常用。看代码的时候经常需要查找某个字符，所以这个是必须要会的。选好颜色为RGB分别为200，240，200就可以了。PS：可以通过f3和f4上下切换搜寻到的结果。经常需要将查找到的字符进行替换。
哪些人适合学习人工智能?
weixin_44059661的博客
09-18 296
前端工程师、Java 工程师、大数据工程师等开发类工程师，学习人工智能具有很大的优势，他们普遍具备扎实的编程基础和丰富的企业项目开发经验，相对而言，这类人比理工科学生学习人工智能更容易。就计算机类专业的学生而言，他们所具备的优势在于出色的逻辑思维和强大的编程能力，这是掌握AI技术的关键。人工智能是一个多学科交叉、应用广泛的领域，它为不同背景的人提供了学习和发展的机会，无论是理工科学生、技术开发人员，还是来自其他行业的专业人士，只要对AI充满兴趣并愿意投入时间和精力，都有机会在AI领域取得成就。
关于HarmonyOS的学习
m0_72035166的博客
09-16 1246
1.node模块化​​​​// tab()2.path模块// path内置模块，专门用来处理路径​// 获取路径最后一部内容，一般用它来获取文件名称​// 给定的路径连接在一起，可以把路径片段拼成完整路径// const result = path.join('day13', 'code', '03_path模块.js')// const result = path.join('day13', 'code', '../','03_path模块.js')​。
ODrive学习——添加485编码器支持
lunzilx的博客
09-18 918
尝试在ODrive中添加485型的编码器的支持。
GoLang学习笔记
08-18
GoLang学习笔记主要包括以下几个方面： 1. 语法规则：Go语言要求按照语法规则编写代码，例如变量声明、函数定义、控制结构等。如果程序中违反了语法规则，编译器会报错。 2. 注释：Go语言中的注释有两种形式，分别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值