Question

清晰完备的预定义基础类型，使得开发跨平台应用时无需过多考虑符号和长度差异。

==== type ==== | = len = | = default = | ====== comment =============

 bool               1         false
 byte               1           0         uint8

 int,   uint        8           0         x86:4, x64:8
 int8,  uint8       1           0         -128 ~ 127,     0 ~ 255
 int16, uint16      2           0         -32768 ~ 32767, 0 ~ 65535
 int32, uint32      4           0
 int64, uint64      8           0

 float32            4          0.0
 float64            8          0.0

 complex64          8
 complex128        16

 rune               4           0         unicode code point, int32
 uintptr            8           0         uint

 string                        ""         len()
 array                                    len() == cap()
 struct

 function                      nil
 interface                     nil

 map                           nil        make(), len()
 slice                         nil        make(), len(), cap()
 channel                       nil        make(), len(), cap()

支持二进制、八进制、十六进制以及科学记数法。

• math ：定义了各数字类型的取值范围。
• strconv ：在不同进制（字符串）间转换。

func main() {
	a, b, c := 0b1010, 0o144, 0x64

	fmt.Printf("0b%b, %#o, %#x\n", a, b, c)
	fmt.Println(math.MinInt8, math.MaxInt8)
}

// 0b1010, 0144, 0x64
// -128 127

可用下划线作为数字分隔符，以便于阅读。

func main() {
	a := 111_22_3_44
	println(a)
}

注意， nil 是预定义标识符，不是关键字。

• 其含义是默认零值（zero value），而非 “空”。
• 没有类型，不能作为初始值供编译器推断。
• 不同类型的 nil 值不能比较。

func main() {
	x := nil   // use of untyped nil in assignment
}

func main() {
	var m map[string]int = nil
	var c []int = nil

	// fmt.Println(m == c)
	//             invalid: mismatched types map[string]int and []int
}

标准库 sync/atomic 提供了某些基本类型的原子操作版本。

package main

import (
	"sync/atomic"
)

func main() {
	// var x int
	var x atomic.Int64

	go func() {
		x.Add(1)
	}()

	x.Store(x.Load() + 1)

	select{}
}

别名

语言规范中，专门提到两个别名。

byte        // alias for uint8
rune        // alias for int32

• 只是语法糖，编译器会将其还原为原始类型。
• 让通用类型具备更清晰的上下文含义。

type X = int   // 别名

func main() {
	var a int = 100
	var b X = a

	fmt.Printf("%T, %v\n", b, b)    // int, 100
    fmt.Println(reflect.TypeOf(b))  // int
}