基本类型

Go 语言是静态类型的编程语言，意味着编译器需要在编译时确定每个值的类型。

类型提供两个信息：

需要分配多少内存给这个值
这段内存中的 0 和 1 如何解释

内置类型

Go 语言设计简练只有 30 多个内置类型、常量、函数。

内建类型：

int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error

内建常量：

true false iota nil

内建函数：

make len cap new append copy close delete
complex real imag
panic recover

25 个关键字：

break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

Go 语言中的函数名、变量名、常量名、类型名、语句标号和包名等命名，都遵循一个简单的命名规则：

一个名字必须以一个字母或下划线开头，后面可以跟任意数量的字母、数字或下划线
大写字母和小写字母是不同的命名
不能与关键字重名
最好不要与内置类型、内置常量、内置函数重名，虽然可以重新定义

类型	⻓度	默认值（零值）	说明
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	函数

更详细的类型信息可以参考 Go语言规范-Type

int、uint、uintpter 类型在 32 位系统上一般是 32 位，在 64 位系统上是 64 位。

bool

Bool 类型不接受其他类型的值，不支持强制类型转换，其他类型不能当 Bool 值使用。

float

浮点数比较不建议使用 ==，可以使用函数判断精度。

import "math"

// p 为自定义精度
func IsEqual(f1, f2, p float64) bool {
    return math.Fdim(f1, f2) < p
}

string

字符串内容在初始化后不可变！

默认值是空字符串 ""
使用索引号访问的是某个字节 s[i]
不能用序号获取字节元素指针，&s[i] 非法
不可变类型，无法修改字节数组（只能复制一份 []byte 修改后转回来）
字节数组尾部不包含 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
}

修改字符串

修改字符串需要先将其转换成 []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)) // 电话
}

单引号字符常量表⽰的 Unicode Code Point，如 \uFFFF、\U7FFFFFFF、\xFF 对应 rune 类型（int32 的别名，4 字节表示）。

func main() {
    fmt.Printf("%T\n", 'a') // int32 (rune 是 int32 的别名)
    
    var c1, c2 rune = '\u6211', '们'
    println(c1 == '我', string(c2) == "\xe4\xbb\xac") // true true
}

指针

指针类型 *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 当成普通整数对象，它⽆法阻⽌ "关联" 对象被回收。

类型区分

Go 语言中每个值的类型都是确定的，array、slice、map、interface、struct 的类型如何确定呢？

我们可以很简单的想到，存储 int 和 string 的数组肯定不是同一个类型，不同的结构体也肯定不是同一个类型。

因此，我们可以将类型分为两大类：

命名类型：bool、int、string 等有明确标识符的类型
未命令类型：array、slice、map、channel 等和具体元素类型、长度等有关

具有相同声明的未命名类型被视为同一类型

具有相同基础类型指针
具有相同元素类型和长度的 array
具有相同元素类型的 slice
具有相同键值类型的 map
具有相同元素类型和传送方向的 channel
具体相同字段序列（字段名、类型、标签、顺序）的匿名 struct
签名相同的（参数和返回值，不包括参数名称） function
方法集相同的（方法名、方法签名相同，和次序无关） interface

定义新类型

可以使用 type 在全局或函数内定义新类型。

func main() {
    type bigint int64
    var x bigint = 100
    println(x)
}

新类型不是原类型的别名，除拥有相同数据存储结构外，它们之间没有任何关系，不会持有原类型任何信息。

类型转换

类型转换可以看成转换原内存的解释方式。

不支持隐式类型转化，即便是从窄向宽转换也不行。

表达式 T(v) 将值 v 转换为类型 T。

值语义和引用语义

在 Go 语言中，值语义很彻底，传递整个值的拷贝，不像 C 语言中的数组，在作为函数参数传递时基于引用语义，传递第一个元素的指针地址。

在结构体中定义数组变量是基于值语义(为结构体赋值时，该数组会被完整的复制)。Go 中的数组和基本类型没有区别，在哪都是纯粹的值语义，会被完全复制！

使用指针表达引用语义。

// 数组 a
a := [3]int{1, 2, 3}
// b 为数组 a 的地址
b := &a
// 通过 a 的地址取出 a 第二个元素增加 1
b[1]++
// a 第二个元素改变，b 依旧指向 a
fmt.Println(a, *b) // [1 3 3] [1 3 3]

Go 中只有 4 个类型 看起来像引用语义（其实是值语义）

slice
map
channel
interface

在这 4 个类型的内部，都存储着指向实际值的指针。

map 本质上存储一个字典指针，使用值传递没有额外开销，实际的底层哈希表也不会复制。

interface 类型，内部就 2 个指针，没有额外开销。

Go 语言——基本类型