1. 变量, 常量, 枚举,基本类型,引用类型,字符串

1.1 变量

Go 是静态类型语言，不能在运行期改变变量类型。使用关键字 var 定义变量，自动初始化为零值。如果提供初始化值，可省略变量类型，由编译器自动推断。

var x int
var f float32 = 1.6
var s = "abc"

在函数内部，可用更简略的 “:=” 方式定义变量。

func main() {
    x := 123 // 注意检查，是定义新局部变量，还是修改全局变量。该方式容易造成错误。
}

可一次定义多个变量。

var x, y, z int
var s, n = "abc", 123
var (
    a int
    b float32
)
func main() {
    n, s := 0x1234, "Hello, World!"
    println(x, s, n)
}

多变量赋值时，先计算所有相关值，然后再从左到右依次赋值。

data, i := [3]int{0, 1, 2}, 0
i, data[i] = 2, 100 // (i = 0) -> (i = 2), (data[0] = 100)

特殊只写变量 “_”，用于忽略值占位。

func test() (int, string) {
    return 1, "abc"
}
func main() {
    _, s := test()
    println(s)
}

编译器会将未使用的局部变量当做错误。

var s string // 全局变量没问题。
func main() {
    i := 0 // Error: i declared and not used。(可使用 "_ = i" 规避)
}

注意重新赋值与定义新同名变量的区别。

s := "abc"
println(&s)
s, y := "hello", 20 // 重新赋值: 与前 s 在同一层次的代码块中，且有新的变量被定义。
println(&s, y) // 通常函数多返回值 err 会被重复使用。
{
    s, z := 1000, 30 // 定义新同名变量: 不在同一层次代码块。
    println(&s, z)
}
输出：
0x2210230f30
0x2210230f30 20
0x2210230f18 30

1.2 常量

常量值必须是编译期可确定的数字、字符串、布尔值。

const x, y int = 1, 2 // 多常量初始化
const s = "Hello, World!" // 类型推断
const ( // 常量组
    a, b = 10, 100
    c bool = false
)
func main() {
    const x = "xxx" // 未使用局部常量不会引发编译错误。
}

不支持 1UL、2LL 这样的类型后缀。
在常量组中，如不提供类型和初始化值，那么视作与上一常量相同。

const (
    s = "abc"
    x  // x = "abc"
)

常量值还可以是 len、cap、unsafe.Sizeof 等编译期可确定结果的函数返回值。

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(b)
)

如果常量类型足以存储初始化值，那么不会引发溢出错误。

const (
    a byte = 100 // int to byte
    b int = 1e20 // float64 to int, overflows
)

1.3 枚举

关键字 iota 定义常量组中从0开始按行计数的自增枚举值。

const (
    Sunday = iota // 0
    Monday // 1，通常省略后续行表达式。
    Tuesday // 2
    Wednesday // 3
    Thursday // 4
    Friday // 5
    Saturday // 6
)
const (
    _ = iota // iota = 0
    KB int64 = 1 << (10 * iota) // iota = 1
    MB // 与 KB 表达式相同，但 iota = 2
    GB
    TB
)

在同一常量组中，可以提供多个 iota，它们各自增长。

const (
    A, B = iota, iota << 10 // 0, 0 << 10
    C, D // 1, 1 << 10
)

如果 iota 自增被打断，须显式恢复。

const (
    A = iota // 0
    B // 1
    C = "c" // c
    D // c，与上一行相同。
    E = iota // 4，显式恢复。注意计数包含了 C、D 两行。
    F // 5
)

可通过自定义类型来实现枚举类型限制。

type Color int
const (
    Black Color = iota
    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) // 常量会被编译器自动转换。
}

1.4 基本类型

更明确的数字类型命名，支持 Unicode，支持常用数据结构。

支持八进制、十六进制，以及科学记数法。标准库 math 定义了各数字类型取值范围。
a, b, c, d := 071, 0x1F, 1e9, math.MinInt16
空指针值 nil，而非 C/C++ NULL。

1.5 引用类型

引用类型包括 slice、map 和 channel。它们有复杂的内部结构，除了申请内存外，还需要初始化相关属性。

内置函数 new 计算类型大小，为其分配零值内存，返回指针。而 make 会被编译器翻译成具体的创建函数，由其分配内存和初始化成员结构，返回对象而非指针。

a := []int{0, 0, 0} // 提供初始化表达式。
a[1] = 10
b := make([]int, 3) // makeslice
b[1] = 10
c := new([]int)
c[1] = 10 // Error: invalid operation: c[1] (index of type *[]int)

有关引用类型具体的内存布局，可参考后续章节。

1.6 类型转换

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

var b byte = 100
// var n int = b // Error: cannot use b (type byte) as type int in assignment
var n int = int(b) // 显式转换

使用括号避免优先级错误。

Point(p) // 相当于 (Point(p))
(*Point)(p)
<-chan int(c) // 相当于 <-(chan int(c))
(<-chan int)(c)

同样不能将其他类型当 bool 值使用。

a := 100
if a { // Error: non-bool a (type int) used as if condition
    println("true")
}

1.7 字符串

字符串是不可变值类型，内部用指针指向 UTF-8 字节数组。

• 默认值是空字符串 “”。
• 用索引号访问某字节，如 s[i]。
• 不能用序号获取字节元素指针，&s[i] 非法。
• 不可变类型，无法修改字节数组。
• 字节数组尾部不包含 NULL。

runtime.h
struct String
{
    byte* str;
    intgo len;
};
//使用索引号访问字符 (byte)。
s := "abc"
println(s[0] == '\x61', s[1] == 'b', s[2] == 0x63)
输出：
true true true

使用 “`" 定义不做转义处理的原始字符串，支持跨行。

s :=`a
b\r\n\x00
c`
println(s)
输出:
a
b\r\n\x00
c

连接跨行字符串时，”+” 必须在上一行末尾，否则导致编译错误。

s := "Hello, " +
"World!"
s2 := "Hello, "
+ "World!" // Error: invalid operation: + untyped string

支持用两个索引号返回子串。子串依然指向原字节数组，仅修改了指针和长度属性。

s := "Hello, World!"
s1 := s[:5] // Hello
s2 := s[7:] // World!
s3 := s[1:5] // ello

单引号字符常量表示 Unicode Code Point，支持 \uFFFF、\U7FFFFFFF、\xFF 格式。对应 rune 类型，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))
    u := "电脑"
    us := []rune(u)
    us[1] = '话'
    println(string(us))
}
//输出:
aBcd
电话

用 for 循环遍历字符串时，也有 byte 和 rune 两种方式。

func main() {
    s := "abc汉字"
    for i := 0; i < len(s); i++ { // byte
        fmt.Printf("%c,", s[i])
    }
    fmt.Println()
    for _, r := range s { // rune
        fmt.Printf("%c,", r)
    }
 }
// 输出：
a,b,c,,±,,,,,
a,b,c,汉,字,