【转】Go 语言教程（1）——类型系统

类型系统

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

小礼物走一走，来简书关注我

作者：流年1004
链接：https://www.jianshu.com/p/c392127940a8
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。