数据类型

数值

• rune是int32的别名（一般用来表示字符类型，其范围可以表示所有的Unicode编码，需要打印字符时要用%c作为占位符），byte是uint8的别名（存储的是字节值，可以用来存储和表示ASCII字符和处理二进制数据，如文件读写、网络通信等）。
• 当将一个整数转换为 byte 时，Go 会截取其低 8 位，并将其解释为无符号整数。（其它整数类型发生溢出时，行为也是相似的）

简便计算：byte类型的值，前面加负号，如var a byte = 5，然后执行a = -a相当于a = byte(256 - int(a))的值，这样a的最终值为251。（底层原因是Go语言会将-5的补码 11111011 直接解释为无符号整数 251）

例如:var b int8 = -128，然后执行fmt.Println(b==-b)，结果为true，因为int8的范围是[-128,127]，128会溢出。128 的二进制表示是 10000000 ，等于 -128的补码，所以会被直接解释为-128。

• 有符号整数，其原码二进制最高位（最左边的位）通常用作符号位，0为正，1为负。

• 有符号整数，在现代计算机中通常用补码（最高位仍是符号位）表示（便于计算，可以直接通过加法实现减法运算，不存在双0问题），正整数的补码和原码一样，负整数的补码是其绝对值的原码各个位（包括符号位）取反后加1。

• Go语言里面，八进制数以 0 开头，十六进制数以 0x 开头。

• ^在Go语言里面表示异或运算（相同为0，不同为1）

切片

切片的底层引用了数组，当切片截取了某个数组（也包括[0:0]），底层就会指向这个数组，除非append操作之后，超出原数组的容量范围，才会分配一个新的数组给切片作为底层。

数组和切片截取a[3:4:4],第一个为起始位置，第二个是截取结束位置，第三个是容量位置。

截取开始和截取结束位置可以大于长度位置，但必须小于等于容量位置。

容量位置必须大于或等于截取结束位置。如果省略第二个参数，则默认第二个参数为len(a)，如果省略第三个参数，则默认第三个参数为cap(a)。

如果仅仅是通过下标取值，而不是截取，注意下标位置必须小于切片长度

计算切片长度，可以直接用第二个位置的值，减去第一个位置的值；计算切片容量，可以直接用第三个位置的值，减去第一个位置的值。

切片只能和nil进行比较（即使是未赋值的空接口也不能比较）。

所有不可比较类型都是只能和nil比较

对于切片（包括空切片和nil切片），可以在其容量范围内进行截取，其中没有元素的地方会用零值填充。省略截取结束位置参数时，默认为切片长度值。

nil切片截取之后仍是nil

s=[]int{}与s=make([]int,0)得到是空切片，var s []int得到的是一个nil切片。空切片底层指向同一个全局的空数组，nil切片底层是一个空指针。

数组和切片中可以指定下标[]int{5:1, 2, 3, 1:9, 10}，未指定下标的，下标为前一个指定下标的位置加一，即为[]int{5:1, 6:2, 7:3, 1:9, 2:10},剩余的位置补0

当切片作为函数形参的时候，传递参数的时候，是引用传递，实际上传递的是一个包含底层数组指针、切片长度、切片容量的结构体。这个结构体本身是按照值传递的。所以函数内部接收的是一个副本，只不过这个副本指向通用的底层数组，长度和容量字段都是副本自己的。所以当函数内部执行append函数时，实际是改变了函数内部副本变量的长度和容量。

切片为nil时，也可以进行截取操作，如[:]，截取后也等于nil，也可以进行len()、cap()操作

不允许对切片指针进行索引，但是数组指针可以

copy(dst,src)函数会复制切片内容，但是不会改变切片地址和大小，返回值是len(dst)、len(src)中的最小值。

直接使用fmt.Printf("%p",s)，打印的是切片s的地址，获取底层数组地址需要通过
&s[0]获取，如果切片指向一个空数组，则无法获取数组的地址。

数组

数组各元素未赋值时，各元素默认为元素类型的零值。

数组指针为nil时，不能用来进行任何截取操作，但可以进行len()、cap()操作

interface

interface包含了动态类型和动态值，判断是否等于另外一个interface，需要比较动态类型和动态值，先比较动态类型，如果动态类型不同，则直接返回结果。如果同态类型相同，则继续比较动态值。

如果动态类型相同，但却是不可比较类型，比如都是[]string这种类型，会发生panic（因为动态类型相同后，会比较动态值，但是动态值是不可比较类型的值）。

判断interface是否等于另外一个可比较类型（如Int、String）值，先比较interface的动态类型和后者类型，如果类型相同，然后再比较interface和后者的值

判断是否为nil时，需要动态类型和动态值都为nil,才相等。空interface与其他类型比较的时候（包括非interface类型），也是判断动态类型和动态值。

一个有方法的interface{}，只能和 至少包含有这个接口的所有方法的interface{}，空interface，nil 这三种比较。否则会编译不通过。

比如接口A只有方法hello()、Hi()，接口B也含有方法hello()、Hi()，另外B可能还含有其他方法，那么这两个接口是可以比较的

不可比较类型有map、slice、function、包含不可比较类型的结构体。

任何interface都可以类型断言为空interface，即x.(interface{})（如果x的动态类型实现了空interface{}类型对应的方法集合，就会成功，因为空interface{}本身已经是所有类型的实现了，所以除了动态类型为nil，必然成功），当动态类型为nil时，会断言失败（这么做一般没啥意义，实际开发中都是断言它的动态类型）。

结构体

结构体嵌套：某属性包含另一个结构体

结构体继承：直接包含另一个结构体，自动创建一个默认的同名字段，并且会继承父结构体的方法，子结构体可以直接调用父结构体的方法，子结构体也可以通过定义一个同样的方法来重写继承而来的方法（遵循就近原则）。

不同的结构体之间不可直接比较，即使字段相同，顺序相同，也不能直接比较。（直接比较会编译不通过）

结构体方法，可以通过结构体实例、结构体指针来调用（编译器会自动解引用，需注意空指针问题）

结构体指针方法，也可以通过结构体指针、结构体实例来调用（编译器会自动取地址，需注意是否可取地址）

结构体和结构体指针可以互相调用彼此的方法，这种灵活性是 Go 语言的设计特性，编译器会自动处理解引用和取地址。但是需要自己注意空指针问题、是否可取地址等。

多级指针不会进行自动解引用（如不支持**T自动解引用到*T），仅支持单级指针（*T）自动解引用到结构体。同样也不支持对结构体多层自动取地址（如不支持T自动取地址到&&T），仅支持对结构体单层取地址。（为了保持代码的清晰和安全性）

在接口赋值时，如果只有结构体方法实现了接口所有方法，结构体实例和结构体指针都可以赋值给接口（编译器会自动对结构体指针进行解引用）。但是如果只有结构体指针方法实现了接口所有方法，则只有结构体指针可以赋值给接口（编译器不会自动取地址）。

不允许在同一个类型上同时定义值接收者和指针接收者的同名方法（无论方法参数是否相同），否则编译不通过，这是GO的语言规范明确禁止。

如果值方法和指针方法加起来才满足实现接口，则可以把指针赋值给这个接口，而不可把值赋值给这个接口。

不能对不可寻址的结构体直接修改其属性，如Student{}.age=18无法通过编译。但是可以显式地创建一个指向结构体值的指针，如(&Student{}).age=18可以正常编译。（本质就是，结构体属性赋值，必须要能取地址，然后通过地址找到其属性的存储位置，然后赋值）

iota

iota是常量计数器，只能在常量表达式中使用

iota在const关键字出现时，将重置为0，const中每新增一行常量声明将使iota计数一次。
如果在同一个const里面遇到新的iota，则恢复为常量计数器。不复制上一个值，也不是在上一个值的基础上加。

字符串

Go里面的字符串，是只读的，本质是一个只读的字节切片（由指针和长度组成），指向一段不可变的内存区域。有len()方法，可以进行s[0:3]截取，但是没有cap()方法，截取时也不能指定容量位置。

定义了一个字符串，不能直接通过下标去修改，否则会编译不通过。

任何修改操作（如拼接、替换）都会创建新的字符串，而非修改原字符串。

多个字符串可共享同一段底层数据（如子串操作 s[:3]不复制数据）

若需要修改字符串内容，可以转换为[]byte或 []rune后进行修改（每次转换都触发内存分配）

strings.Trim、strings.TrimLeft、strings.TrimRight都是从字符串，连续删除第二个参数中含有的任意字符。

map

Go里面map的值是通过键来访问的，不可以直接获取map中单个元素的地址，因为map中的值是不可寻址的，也就是说它们不能直接被取地址（不能对map的属性进行取地址，map底层是一个哈希表，当map重新哈希时，元素的存储位置可能会发生变化）。

可以直接对map取地址，但是不能直接用map的指针来操作其属性，也就是说不能直接对map指针进行索引。

如果需要通过地址来访问map中的值，可以考虑使用类似这种格式map[int]*int,在map的value中保存真实的值地址，来达到类似的效果。

map没有cap方法，cap函数适用于数组、数组指针、slice、channel。

使用make初始化时，最多可以指定两个参数，如果指定了第二个参数，也没有实际意义，make(map[int]int, 2)后面的参数2没有意义。

map为nil也可以进行len()操作，也可以进行取值操作，但是取出的该类型的零值

Go语言中的map在并发读写时是线程不安全的，但并发读是可以安全的，前提是没有写操作在进行。

如果map属性值为结构体

当使用 . 操作符来访问或修改结构体值的字段时，Go编译器会自动进行指针解引用。（编译期）

因此当map的属性值为结构体时，无法通过map[key].A的形式来修改，因为会解引用失败，编译会失败。

而当map的属性值为结构体的指针时，可以通过map[key].A的形式来修改，因为这个过程不会进行解引用，而是直接使用指针修改结构体的属性值。

但是可以通过map[key].A的形式来读取，因为Go程序运行时，会对不可寻址的结构体进行值拷贝，然后对拷贝的值进行指针解引用。

函数

函数只能与nil进行比较。函数、map、切片、channel都只能与nil比较
当函数使用命名返回值变量时，要注意不能在隐式return时（也就是return后面不接变量名）被同名的局部变量遮蔽，否则会编译失败。解决的方式是在同名局部变量的作用域之外进行return，或者在同名局部变量的作用域内进行显式的return（也就是return后面接同名的变量名）

闭包：在定义一个函数时，函数捕获外层函数的局部变量，并且这些变量的生命周期被延长（从栈逃逸到堆，生命周期与闭包函数共存）

方法

值方法，可以通过指针来调用；指针方法，也可以通过值调用；这是因为编译器会自动进行转换

指针调用值方法时，自动解引用；值调用指针方法时，自动取地址。

空指针可以调用指针方法。

方法值

将方法赋值给一个变量时（或者作为函数参数传递时），实际上是将方法本身与它的接收者（值或指针）的副本绑定在一起，相当于拷贝了一份接收者的值，可以理解为快照，当方法被调用时，会使用这个副本值作为方法接收者，不会随原始变量改变。

如果方法的接收者需要解引用操作（比如使用指针调用值方法），那么在方法赋值给变量的时候，就会立即完成解引用。然后拷贝一份解引用后的值作为接收者值。

channel

不能关闭一个只能接受数据的单向channel，编译不通过。但是可以关闭一个只能发送数据的单向channel。（close()就是用来关闭发送的）

向一个nil的channel发生数据会导致goroutine阻塞，从一个nil的channel接收数据也会导致goroutine阻塞。

给一个已关闭的channel发送数据会导致panic，从一个已关闭的channel接收数据，会先收到缓冲区数据，然后收到零值。

双向通道可以转为单向通道，但是单向通道不能转为双向通道。比如a:=make(chan int)，可以通过chan<- int(a)来转换。

<-符号前后可以留空格，也可以不留空格，都可以通过编译。

channel的底层实现

channel的底层是runtime包里面一个hchan结构体，这个结构体里面包含了互斥锁、缓存容量、当前元素数量、环形队列指针、环形队列的发送索引、环形队列的接收索引、待发送数据的goroutine队列、待接收数据的goroutine队列、是否已关闭等等。

golang
type hchan struct {
    qcount   uint             // 当前队列中的元素数量（缓冲区已存在的数据量）
    dataqsiz uint             // 环形队列的大小（缓冲区大小）
    buf      unsafe.Pointer   // 指向缓冲区的指针
    elemsize uint16           // 单个元素的大小
    closed   uint32           // channel 是否已经关闭
    sendx    uint             // 环形队列中的发送索引（向channel发送数据时，元素存放的缓冲区位置索引）
    recvx    uint             // 环形队列中的接收索引（从channel接收数据时，读取的缓冲区位置索引）
    recvq    waitq            // 等待接收数据的goroutine队列
    sendq    waitq            // 等待发生数据的goroutine队列
    lock     mutex            // 保护channel数据结构的互斥锁
    ...
}

flowchart LR
id1["goroutine A"] --发送数据--> ide1
subgraph ide1 [channel内部]
direction TB
id(channel)-->加锁
加锁 --是否已关闭--> C{closed}
C--已关闭-->unlock["解锁"]-->panic(panic)
C--未关闭-->D{是否有待接收数据的goroutine队列}
D--有等待接收的goroutine-->将数据交给最早挂起的接收者-->解锁-->id2("唤醒该goroutine")
D--无等待接收的goroutine-->E{是否有可用的缓冲区}
E--有可用的缓冲区-->id3["将数据放入缓冲区sendx位置"]
id3-->id6(调整sendx和qcount的值)-->unlock2["解锁"]
E--无可用的缓冲区-->id5("发送者goroutine A加入待发送数据的goroutine队列")-->unlock3["解锁"]-->id4["发送者goroutine A被阻塞"]
end

语法

defer

defer执行时机，return第一阶段（赋值，把将要返回的值赋值给变量进行存储，这个变量可能是具名变量或匿名变量）、执行defer进行收尾、return第二阶段（携带最终值退出）

defer在注册的时候（也就是入栈的时候），就已经确定了传入的参数值，也确定了函数体。如果参数值是函数调用，则在注册的时候，就会从左到右，立即依次计算出真正的参数值。如果是链式调用，defer注册时，就会先计算前面所有的函数，并把结果作为方法参数，只有最后一个函数会延迟执行。（闭包除外，闭包会等defer真正执行时，才会确定变量的值）

当函数内部发生panic时，该函数中所有的defer语句都仍然会被执行，当defer中发生panic时，会中止当前 defer 的执行，但会继续执行后续的 defer。

recover

recover的作用是捕获异常，recover()会使程序从panic中恢复，返回panic信息。

recover必须与defer一起使用，并且必须直接包含在defer注册函数的函数体中（在这个注册函数体中调用recover()时，可以defer cover()），可以是匿名函数中。不能进行多次封装或者嵌套。

for range

• for range 在循环之前，就已经确定了循环的次数。
  
• for range 前面的临时变量，只会创建一次，然后每次重新赋值，即始终为同一个变量。
  
• 仅仅遍历切片，忽略具体业务时，普通的for语句的性能稍微更好一点，但是可以忽略，相差很小。主要是for range需要同时管理索引和值的获取。
  
• for range开始迭代时就浅拷贝了一个副本，对数组来说，相当于拷贝了一个新的数组进行迭代，修改原数组不会影响被迭代数组。而对于切片来说，range拷贝出来的切片与原切片底层是同一个数组，因此对原切片的修改也会影响到被迭代切片。
• for range 遍历的切片、map为nil，或者遍历的数组指针为nil时，不会报错。
• for range 前面可以不写变量，如for range []int{1,2}也可以，只是无法获取元素值。
• for range 与 for k,v:=range 与 for k,_:=range 在内部实现上是由差异的。具体例子可以查看数组小节的特别注意

• for range也可以遍历一个数组指针，实际上是将数组的指针传递给被迭代的变量。这样，在被迭代的是数组引用的拷贝。另外即使被迭代的是数组指针，迭代出来的元素仍然是数组元素的副本，而不是指针（类似于切片引用传递）

for range 遍历数组指针比遍历数组更高效（避免整个数组拷贝，而是仅拷贝数组指针）

select case

对于case后面的表达式或语句，除了每个case的最后一步<-或->操作以外，其他操作的是根据case的顺序从上到下的执行，直到每个case都只剩下最后的<-或->操作。

select {
    case a<-A():
        ...
    case b<-B():
        ...
    default:
        ...
}

对于包含通道通信操作的 select 语句，如果有多个 case 准备好的话（只剩下最后的<-或->操作，并且具备完成<-或->操作的条件），会进行随机选择。

所有的case都不满足时（都只剩下最后的<-或->操作，并且都不具备完成<-或->操作的条件），才会走default

for 与 select 的组合中，break只会跳出select块，然后从select块结束的地方继续执行，不会跳出for循环

for 与 select 的组合中，continue会从当前位置开始for的下一次循环，与直接在for循环中使用continue没有区别

switch case

switch后面没有条件时，默认为true。（如switch {等于switch true {）

switch后面的条件必须要和{在同一行，否则由于golang会自动在switch行尾补充;进行断句。从而使是switch a() 变为switch a();true {，switch条件由a()变为了true。

默认自带break，可以写fallthrough来贯穿case

所有的case都不满足时，才会走default

break label

单独的break表示退出当前循环
break label中label是放在循环之前的一个标识，可以明确的指出要退出哪个循环

init

同一个go文件里面，init执行顺序是从上到下。同一个package里面不同的go文件里的init执行是按照编译时读取文件的顺序。不同的package里面的init执行，是根据包名的英文字母排序执行（import后面的所有字母以/分隔对比每一项），如果有嵌套的，需要等到嵌套的init先执行，嵌套里的init也要根据字母顺序排队。golang中包的初始化，是串行执行的。如果有嵌套则按照如下图的顺序执行。

init函数不能被其他函数调用，包括main函数。

goto

goto跳转的目标标签，需要跟goto在同一级别或者更外层代码块。也就是说只能直接跳入同级和或者更外层代码块，不能跳入内层的代码块，也不能跳转到其他函数。

操作符

操作符优先级

.(成员访问操作符) 大于 [](索引操作符) 大于 *(解引用操作符) 等于 &(取地址操作符) 大于 ++或--(自增或自减操作符)

如对结构体t的某个属性取地址可以直接&t.n，等价于&(t.n)

&和*都是右结合的，比如**p会先计算右边的*p，相当于*(*p)。
运算符优先级：一元运算符在一般的运算符中有最高的优先级。一元运算符包含"+"、"-"、"!"、"^"、"*"、"&"、"<-"。比如：5/+-*v 相当于5/(0+(0-(*v)))

赋值

不能使用短变量声明:=来设置字段值，无论是结构体、数组、切片、map等，如user.Age := 12会编译失败。

对于使用:=定义的变量，如果新变量与同名，已定义的变量不在同一个作用域中，那么 Go 会新定义这个变量

对于多值赋值语句，类似于a,b=1,2+a或者a,b:=1,2+a，执行顺序是从左到右，但是左边的运算结果不会影响右边的运算结果，他们都是独立的操作，表达式里面引用的都是这条语句之前的变量值。如果等号前面的不是变量，而是索引表达式（如s[i]），也同样是引用的是这条语句之前的s（包括所有属性，如len、cap等）

i++ 和 i–- 在 Go 语⾔中是语句，不是表达式，只能做为独立语句，不能赋值给另外的变量，这点与其他语言不一样。

常量与变量

变量

函数中声明的变量必须要使用，但是可以有未使用的全局变量。函数参数未使用也是可以的。

不使用显式类型，无法用nil来初始化变量，如a:=nil会编译失败，因为编译器无法确定类型

使用字面量定义数组、切片、结构体、map等多元素类型时，如果最后一个元素跟}不在同一行，结尾也需要加逗号。

匿名变量

匿名变量是指在程序运行过程中产生的、没有显示绑定到变量名的中间值（临时值），如函数返回值、表达式计算结果。

在Go中不能对匿名变量取地址，因为匿名变量通常是临时存储在栈上，生命周期很短，如果允许取地址，可能导致悬挂指针（即指针指向已被释放的内存），破坏Go的内存安全保证。

常量

• 在Go语言中，常量是一个简单的标识符，不会被修改，常量未使用时能编译通过。
• 在Go语言中，常量是在编译时期就固定的值，是硬编码在程序中的值，并没有内存地址，所以是不可寻址的，因此不能取其地址。如果你尝试取一个常量的地址，就会报错，编译不通过。
  
• 无类型常量可以根据需要自动适配到其他类型，字面量是也是无类型常量，如const a=1就是无类型常量，可以根据需要自动适配int、uint、int64、int32等类型
  
• const关键字只能用于定义基本类型的常量（即常量只能是基本类型），包括布尔值、数值（整数、浮点数和复数）、字符串，以及基础类型为这些类型的自定义类型，如type A int
• 不赋值的常量会在编译时，被赋值为上一个常量的值或者占位符常量的值，如果前面没有常量或者没有类似_ int = 123这样的占位符定义，会编译不通过。

字面量

直接写在代码中的固定值，既可以是基本类型（如int,string），也可以是复合类型（如slice,struct）

小字面量（如基本类型）,若字面量未逃逸且无需地址化，可能直接被编译为指令数据。若绑定到局部变量且未逃逸，分配在栈上。若字面量的地址逃逸（如返回指针或被闭包捕获），分配到堆上。

大字面量（如大数组或结构体），即使未逃逸，也可能直接在堆上分配（因栈空间有限）。

引用类型字面量，引用类型的字面量（如 slice、map、chan 的复合字面量）底层数据必定在堆上

普通指针的字面量，逃逸则堆，未逃逸则栈。

字符串字面量（如 "hello"），通常是只读的全局数据，在编译期存入程序的静态区（非堆非栈）。

字符串字面量赋值给变量时（如s:="hello"），的string头部结构可能分配在栈或堆，但数据始终指向静态区。而动态生成的字符串（如拼接、转换）会按逃逸分析规则分配内存。

基础类型的字面量（如 42, 3.14, "hello"）是不能直接取地址的，但对于复合字面量（结构体、数组、切片、map），Go允许直接取地址（如p := &[]int{1, 2, 3}）。当对复合字面量取地址时,编译器会先在栈或堆上分配内存（由逃逸分析决定）,然后返回该内存的地址。

要注意字面量和匿名变量的区别：不能对匿名变量取地址，无论什么类型。

类型别名与类型定义

类型别名带有本身类型的所有方法

但是类型定义不具有原类型的方法

值类型与引用类型

• 值类型内存通常直接在栈中分配，
• 引用类型内存通常在堆上分配，变量本身仍然是在栈上存储其指针或引用的

关键字与预定义标识符

关键字

用于语法结构和流程控制，具有特点的语法功能和含义，不能用作变量名和函数名，Go语言中有25个关键字，如break、const、var、func、struct等等

预定义标识符

预先定义的标识符，包括基本类型、常量、nil、内建函数等，可以在代码中重新定义或作为变量名被赋值，Go语言中有37个预定义标识符，如int、string、bool、true、false、iota、nil、len、cap、append、make、new等等

同步

互斥锁

sync.Mutex是值类型。当互斥锁作为方法的接收者或者参数时，要注意避免值复制，否则会导致互斥锁不生效（因为是两个不同的锁）。Lock()与Unlock()方法的接收者为指针类型*sync.Mutex，所以当需要把sync.Mutex进行函数传参时，一般传入同一个sync.Mutex变量的指针，这样可以保证加锁和解锁作用于同一个sync.Mutex变量。

运行时

GC

垃圾回收器（GC）负责管理内存，它会识别和回收不再被引用的数据空间，无论它们是在堆上分配还是在栈上分配的。

调度

goroutine进入“就绪”状态后才会被放入调度队列，等待调度器为其分配CPU时间片后进行执行。