类型系统
Go 语言是更好的 C 语言，很多思想来源于 C 语言，毕竟 Go 的设计者就是 C 的设计者在几十年之后再创新高。
变量的声明引入和 JavaScript 一样的关键字 var，不一样的机制，JavaScript 中声明变量时没有类型，Go 语言声明的变量在后面要带上类型。
变量
var v int // 声明变量 v，自动初始化值为零值(int 类型为 0)
v = 1 // 给变量 v 赋值
v := 1 // 声明变量 v，并初始化值为 1，编译器自动推导类型为 int
上面两种方式完全等价，:= 的写法更简洁，也是官方推荐的写法，编译器可以自动从右值推导出声明的变量是哪种类型，v 必须是没被声明过的变量。
多重赋值
基本的赋值方法都是类似的，但 Go 提供了动态语言中才有的多重赋值功能。
i, j = j, i 交换变量如此简单，不需要引入中间变量。
匿名变量
函数的返回值中可能只有一个感兴趣的，别的值都不需要，是否还需要定义变量去接收这几个返回值？使用匿名变量！
func GetName() (firstName, lastName, nickName string) {
return "May", "Chan", "Chibi"
}
_, _, nickName := GetName()
常量
常量值必须是编译期可确定的数字、字符串、布尔值。即常说的字符字面量(literal)，根据字面量可以推测出常量的类型。
const x,y int = 1, 2 // 多常量初始化
const Pi float64 = 3.1415926
const zero = 0.0 // 类型推断
const ( // 常量组
size int64 = 1024
eof = -1 // 类型推断
Eof // 在常量组中，如果不提供类型和初始化值，那么视作与上⼀常量相同。
)
iota
iota 比较特殊，可以认为是编译器内置的一个寄存器，在每一个 const 关键字出现时被重置为 0，然后在下一个 const 出现时，每出现一次 iota，其所代表的数字就会增 1。
const (
Sunday = iota // 0
Monday // 1
Tuesday // 2
)
枚举
Go 语言中不存在枚举类型，可以通过自定义类型的方式构造。
type Color int // 定义类型 Color，传递 Color 的地发不能传递 int
const (
Black Color = iota // 定义常量 Black = 0
Red
Blue
)
func test(c Color) {}
func main() {
c := Black
test(c)
x := 1
test(x) // Error: cannot use x (type int) as type Color in function argument
test(1) // 常量会被编译器自动转换
基本类型
| 类型 | ⻓度 | 默认值（零值） | 说明 |
|---|---|---|---|
| bool | 1 | false | |
| byte | 1 | 0 | uint8 |
| rune | 4 | 0 | Unicode Code Point, int32 |
| int, uint | 4 或 8 | 0 | 32 或 64 位 |
| int8, uint8 | 1 | 0 | -128 ~ 127, 0 ~ 255 |
| int16, uint16 | 2 | 0 | -32768 ~ 32767, 0 ~ 65535 |
| int32, uint32 | 4 | 0 | -21亿 ~ 21 亿, 0 ~ 42 亿 |
| int64, uint64 | 8 | 0 | |
| float32 | 4 | 0.0 | |
| float64 | 8 | 0.0 | |
| complex64 | 8 | ||
| complex128 | 16 | ||
| uintptr | 4 或 8 | ⾜以存储指针的 uint32 或 uint64 整数 | |
| array | 值类型 | ||
| struct | 值类型 | ||
| string | "" | UTF-8 字符串 | |
| slice | nil | 引⽤类型 | |
| map | nil | 引⽤类型 | |
| channel | nil | 引⽤类型 | |
| interface | nil | 接⼝ | |
| function | nil | 函数 |
int、uint、uintpter 类型在 32 位系统上一般是 32 位，在 64 位系统上是 64 位。
格式化打印类型信息和类型的技巧。
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
)
func main() {
const f = "%T(%v)\n"
fmt.Printf(f, ToBe, ToBe)
fmt.Printf(f, MaxInt, MaxInt)
}
引用类型
引用类型包括 slice、map 和 channel。它们有复杂的内部结构，除了申请内存外，还需要初始化相关的属性。
内置函数 new ，计算类型大小，为其分配零值内存，并返回指向内存的指针。
内置函数 make，会被编译器翻译成具体的创建函数，由其分配内存和初始化成员结构，返回对象而非指针。
a := []int{0, 0, 0} // 提供初始化表达式。
a[1] = 10
b := make([]int, 3) // 初始化长度为 3 的 slice
b[1] = 10
c := new([]int)
c[1] = 10 // Error: invalid operation: c[1] (index of type *[]int)
类型转换
不支持隐式类型转化，即便是从窄向宽转换也不行。
表达式 T(v) 将值 v 转换为类型 T。
Bool
Bool 类型不接受其他类型的值，不支持强制类型转换，其他类型不能当 Bool 值使用。
Float
浮点数比较不建议使用 ==，可以使用函数判断精度。
import "math"
// p 为自定义精度
func IsEqual(f1, f2, p float64) bool {
return math.Fdim(f1, f2) < p
}
字符串
字符串内容在初始化后不可变！
- 默认值是空字符串
"" - 使用索引号访问的是某个字节
s[i] - 不能用序号获取字节元素指针，
&s[i]非法 - 不可变类型，无法修改字节数组
- 字节数组尾部不包含 NULL
struct String {
byte* str; // 指向字节数组的指针
intgo len; // 长度
}
⽀持⽤两个索引号返回⼦串。⼦串依然指向原字节数组，仅修改了指针和⻓度属性。
s := "Hello, World!"
s1 := s[:5] // Hello
s2 := s[7:] // World!
s3 := s[1:5] // ello
字符串遍历
// 以字节数组遍历
str := "Hello，世界"
n := len(str)
for i := 0; i < n; i++ {
ch := str[i] // 取出下标上的字符，类型为 byte
}
// 每个中文字符在 UTF-8 占 3 个字节
// 以 Unicode 字符遍历
for i, ch := range str {
fmt.Println(i, ch) // ch 的类型为 rune
}
修改字符串
单引号字符常量表⽰ Unicode Code Point，⽀持 \uFFFF、\U7FFFFFFF、\xFF 格式。
对应 rune 类型（int32 的别名，4 字节表示），UCS-4。
func main() {
fmt.Printf("%T\n", 'a')
var c1, c2 rune = '\u6211', '们'
println(c1 == '我', string(c2) == "\xe4\xbb\xac")
}
输出
int32 // rune 是 int32 的别名
true true
要修改字符串，可先将其转换成 []rune 或 []byte，完成后再转换为 string。⽆论哪种转
换，都会重新分配内存，并复制字节数组。
func main() {
s := "abcd"
bs := []byte(s)
bs[1] = 'B'
println(string(bs)) // aBcd
u := "电脑"
us := []rune(u)
us[1] = '话'
println(string(us)) // 电话
}
指针
指针类型 *T 是指向类型 T 的指针，零值为 nil。
& 取址运算符。
* 间接引用，访问对象。
指针和 C 都是一样的，不同的是 Go 没有指针运算。
可以通过 unsafe.Pointer 和任意类型指针间进⾏转换。
func main() {
x := 0x12345678
p := unsafe.Pointer(&x) // *int -> Pointer
n := (*[4]byte)(p) // Pointer -> *[4]byte 转换成数组指针
// 78 45 34 12
for i := 0; i < len(n); i++ {
fmt.Printf("%X ", n[i])
}
}
局部变量的指针
返回局部变量的指针是安全的，编译器会根据需要将其分配在 GC Heap 上。
func test() *int {
x := 100
return &x // 在堆上分配 x 内存。但在内联时，也可能直接分配在⺫标栈。
}
变相实现指针运算
将 Pointer 转换成 uintptr，可变相实现指针运算。
func main() {
d := struct {
s string
x int
}{"abc", 100}
p := uintptr(unsafe.Pointer(&d)) // *struct -> Pointer -> uintptr
p += unsafe.Offsetof(d.x) // uintptr + offset
p2 := unsafe.Pointer(p) // uintptr -> Pointer
px := (*int)(p2) // Pointer -> *int
*px = 200 // d.x = 200
fmt.Printf("%#v\n", d)
}
输出
struct { s string; x int }{s:"abc", x:200}
注意：GC 把 uintptr 当成普通整数对象，它⽆法阻⽌ "关联" 对象被回收。
自定义类型
可将类型分为命名和非命名两大类。
命名类型包括 bool、int、string 等。
非命令类型则是 array、slice、map 等和具体元素类型、长度等有关。
具有相同声明的未命名类型被视为同一类型
- 具有相同基类型指针
- 具有相同元素类型和长度的
array - 具有相同元素类型的
slice - 具有相同键值类型的
map - 具有相同元素类型和传送方向的
channel - 具体相同字段序列（字段名、类型、标签、顺序）的匿名
struct - 签名相同的（参数和返回值，不包括参数名称）
function - 方法集相同的（方法名、方法签名相同，和次序无关）
interface
var a struct { x int `a` }
var b struct { x int `ab` }
// cannot use a (type struct { x int "a" }) as type struct { x int "ab" } in assignment
// 结构体标签不同
b = a
Type
可以使用 type 在全局或函数内定义新类型。
func main() {
type bigint int64
var x bigint = 100
println(x)
}
新类型不是原类型的别名，除拥有相同数据存储结构外，它们之间没有任何关系，不会持有原类型任何信息。
除⾮目标类型是未命名类型，否则必须显式转换。
x := 1234
var b bigint = bigint(x) // 必须显式转换，除⾮是常量。
var b2 int64 = int64(b)
// slice 只要存储相同类型的值
var s myslice = []int{1, 2, 3} // 未命名类型，隐式转换。
var s2 []int = s
网友评论