Golang 数据类型：int、float64、string、bool、byte、rune

Go 的基本类型包括数字、布尔值和字符串。每个变量都恰好有一个在编译期确定的类型，Go 从不会替你在类型之间自动转换。%T 可以打印任何值的类型：

package main

import "fmt"

func main() {
	count := 42
	price := 19.99
	name := "gopher"
	ok := true
	initial := 'G'
	raw := byte('G')
	z := 3 + 4i

	fmt.Printf("%-8v %T\n", count, count)
	fmt.Printf("%-8v %T\n", price, price)
	fmt.Printf("%-8v %T\n", name, name)
	fmt.Printf("%-8v %T\n", ok, ok)
	fmt.Printf("%-8v %T\n", initial, initial)
	fmt.Printf("%-8v %T\n", raw, raw)
	fmt.Printf("%v %T\n", z, z)
}

注意 'G' 打印出来是 71，类型是 int32：单引号括起来的字符是 rune，而 rune 是一个数字（Unicode 码点）。rune 是 int32 的别名（同一个类型的第二个名字），所以 %T 报告的是 int32。同样，byte 报告的是 uint8。

整数

默认使用 int。 len() 返回 int，切片索引是 int，循环计数器也是 int。在所有 64 位平台上，int 都是 64 位。当大小是约定的一部分时，再使用固定大小的类型：二进制文件格式中的 int32，原始字节用的 uint8，以纳秒为单位的 Unix 时间戳用的 int64。

对于“不可能为负”的数量（比如计数），不要使用无符号类型。减到零以下时，它会回绕成一个巨大的数字，而不是产生一个你能发现的负数。

上限与溢出

math 包为每个上限都提供了常量。在运行时，溢出的整数运算会悄无声息地回绕：

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Println("MaxInt:  ", math.MaxInt)
	fmt.Println("MaxInt32:", math.MaxInt32)
	fmt.Println("MaxUint8:", math.MaxUint8)

	var small int8 = 127
	small++
	fmt.Println("127 + 1 as int8:", small)

	var u uint = 0
	u--
	fmt.Println("0 - 1 as uint:", u)

	var n int32 = math.MaxInt32
	fmt.Println("MaxInt32 * 2:", n*2)
}

没有 panic，也没有错误：127 + 1 变成了 -128。只有常量表达式会在编译期检查（var b int8 = 128 无法通过编译）。如果你的数据可能溢出，请在运算之前检查，或者使用 math/big。

整数字面量

million := 1_000_000   // underscores for readability (Go 1.13+)
mask := 0xFF           // hexadecimal
perm := 0o755          // octal (also the older form 0755)
flags := 0b1010        // binary

浮点数

带小数点或指数的字面量（2.5、1e6）默认是 float64，math 包接受和返回的也是 float64。除非大型数组的内存很重要，否则就用它。

浮点数是二进制的，所以大多数十进制小数都只是近似值：

package main

import (
	"fmt"
	"math"
)

func main() {
	a := 0.1
	b := 0.2
	fmt.Println(a+b, a+b == 0.3)

	// compare with a tolerance instead
	fmt.Println(math.Abs((a+b)-0.3) < 1e-9)

	// integer division vs float division
	fmt.Println(7/2, 7.0/2, float64(7)/2)

	// special values
	zero := 0.0
	fmt.Println(1/zero, -1/zero, math.NaN())
}

由此得出两条规则：运算之后绝不要用 == 比较浮点数；也绝不要用浮点数存储金额，请用以“分”为单位的整数，或者使用十进制数库。

浮点数除以零得到 +Inf、-Inf 或 NaN，而不会 panic。整数除以零会在运行时 panic（runtime error: integer divide by zero），除数是常量零时则是编译错误。

布尔值

bool 保存 true 或 false，零值是 false。Go 不会把数字、空字符串或 nil 当作布尔值。if count {} 是编译错误，要写成 if count > 0 {}。运算符是 &&、|| 和 !，其中 && 和 || 会短路求值。

字符串

string 是一个不可变的字节序列，通常是 UTF-8 文本。len(s) 计算的是字节数，而不是字符数：

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "héllo"
	fmt.Println(len(s))                    // bytes
	fmt.Println(utf8.RuneCountInString(s)) // characters
	fmt.Println(s[0], string(s[0]))        // indexing gives a byte

	multiline := `raw string:
backslashes \n stay as written`
	fmt.Println(multiline)
}

é 在 UTF-8 中占两个字节，所以五个字符的 len 是 6。双引号字符串会处理 \n 这样的转义序列；反引号括起来的原始字符串不会，并且可以跨越多行。strings 包在字符串页面中讲解，UTF-8 的细节在 rune 和字节页面中深入介绍。

byte 和 rune

它们是别名，而不是新类型：byte 和 uint8 无需转换即可互换。名字只是说明这个数字代表什么。

复数

Go 内置了复数类型 complex64 和 complex128，配合 real、imag 以及 math/cmplx 包使用：

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	c := complex(3, 4) // complex128
	fmt.Println(c, real(c), imag(c))
	fmt.Println(cmplx.Abs(c))
	fmt.Println(cmplx.Sqrt(-1))
}

很少有程序需要它们，但信号处理和一些数值计算代码会用到。

复合类型与引用类型

基本类型可以组合成复合类型。每种类型都有自己的页面：

any 是 interface{} 的别名（从 Go 1.18 开始），可以保存任何类型的值。

命名类型

你可以基于已有类型定义一个新类型。它的底层表示相同，但是一个不同的类型，并且可以拥有方法：

type Celsius float64
type UserID int64

var t Celsius = 21.5
var f float64 = t // compile error: cannot use t (variable of float64 type Celsius) as float64 value in variable declaration

这种严格正是目的所在：UserID 不会被意外传到需要 OrderID 的地方。确实需要时再显式转换：float64(t)。转换规则见类型转换页面，数字与字符串之间的转换见 strconv 包的函数。

零值

每种类型都有零值，也就是变量在你赋值之前保存的值：数字是 0，bool 是 false，字符串是 ""，指针、切片、map、通道、函数和接口是 nil。Go 中不存在未初始化的变量。