保留关键字

语言设计简练，只有 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

运算符

全部运算符、分隔符、以及其他符号。

+ & += &= && == != ( )
- | -= |= || < <= [ ]
* ^ *= ^= <- > >= { }
/ << /= <<= ++ = := , ;
% >> %= >>= -- ! ... . :
 &^ &^=

运算符结合率从左到右。

优先级   运算符
------------+---------------------------------------------+----------------------------
high    * / & << >> & &^
        + - | ^
        == != < <= < >=
        <- 
        &&
low     ||

简单位运算

0110 & 1011 = 0010 AND 都为 1。
0110 | 1011 = 1111 OR ⾄少⼀个为 1。
0110 ^ 1011 = 1101 XOR 只能⼀个为 1。
0110 &^ 1011 = 0100 AND NOT 清除标志位

a := 0
a |= 1 << 2 // 0000100: 在 bit2 设置标志位
a |= 1 << 6 // 1000100: 在 bit6 设置标志位
a = a &^ (1 << 6) // 0000100: 清除 bit6 标志位

x := 1
^x // 取反运算 -0010

初始化

初始化复合对象，必须使用类型标签，且左大括号必须在类型尾部。

var a = struct{x int}{100}
var b = []int{1, 2, 3}

If

• 可以省略条件表达式括号
• 支持初始化语句，可以定义代码块局部变量
• 代码块左大括号必须在条件表达式尾部

x := 0

// 局部变量 n 只能在循环中使用
if n := "abc"; x > 0 {
    println(n[0])
} else if x < 0 {
    println(n[1])
} else {
    println(n[2])
}

不支持三元操作符 a > b ? a : b

For

For 支持三种循环方式，Go 中没有 while 关键字语法，可以用 For 模拟。

s := "abc"

// 常见 For 循环
// 计算出长度 n，避免多次调用 len 函数
for i, n := 0, len(s); i < n; i++ {
    println(s[i])
}

// 替代 while (n > 0) {}
n := len(s)
for n > 0 {
    println(s[n])
    n--
}

// 替代 while (true) {}
for {
    println(s)
}

Range

类似迭代器操作，返回 （索引， 值）或（键， 值）

Range 会复制对象，应该使用引用类型 slice、map。

for 循环的 range 格式可以对 slice 或者 map 进行迭代循环。

遍历 slice 时，返回当前的下标和该下标对应元素的一个拷贝。

s := []int{1, 2, 3, 4, 5}

for i, v := range s { // 复制 struct slice { pointer, len, cap }
    if i == 0 {
        s = s[:3] // 对 slice 修改，不会影响 range
        s[2] = 100 // 对底层数据的修改
    }

    println(i, v)
}

输出：

0 1
1 2
2 100
3 4
4 5

Switch

分支表达式可以是任意类型，不限于常量。可以省略 break，默认自动终止。

继续下一分支，可以使用 fallthrough，但不再判断条件。

x := []int{1, 2, 3}
i := 2

switch i {
    case x[1]:
        println("1")
        fallthrough
    case 1, 3:
        println("2")
    default:
        println("3")
}

输出
1
2

省略条件表达式，可以当 if…else if…else 使用。

switch {
    case x[1] > 0: // if
        println("1")
    case x[1] < 0: // else if
        println("2")
    default: // else
        println("3")
}

// 带初始化语句
switch i := x[2]; {
    case x[1] > 0: // if
        println("1")
    case x[1] < 0: // else if
        println("2")
    default: // else
        println("3")
}

Goto、Break、Continue

⽀持在函数内 goto 跳转。标签名区分⼤⼩写，未使⽤标签引发错误。

func main() {
    var i int
    for {
        println(i)
        i++
        if i > 2 { goto BREAK }
}
BREAK:
    println("break")
EXIT: // Error: label EXIT defined and not used
}

配合标签，break 和 continue 可在多级嵌套循环中跳出。

func main() {
L1:
    for x := 0; x < 3; x++ {
L2:
        for y := 0; y < 5; y++ {
            if y > 2 { continue L2 }
            if x > 1 { break L1 }

            print(x, ":", y, " ")
        }
        
        println()
    }
}

输出
0:0 0:1 0:2
1:0 1:1 1:2

break 可⽤于 for、switch、select，⽽ continue 仅能⽤于 for 循环。