表达式
关键字
一共有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 * / & << >> & &^
+ - | " ^
== != < <= < >=
<-
&&
||
运算符demo:
0110 & 1011 = 0010 与 都为 1。
0110 | 1011 = 1111 或 ⾄至少⼀一个为 1。
0110 ^ 1011 = 1101 异或 只能⼀一个为 1。
0110 &^ 1011 = 0100 清除标志位 计算x&^y 首先我们先换算成2进制 如果ybit位上的数是0则取x上对应位置的值， 如果ybit位上为1则取结果位上取0。
不支持运算符重载。尤其需要注意，"++"、"--" 是语句而非表达式。
n := 0
p := &n
// b := n++ // syntax error
// if n++ == 1 {} // syntax error
// ++n // syntax error
n++
*p++ // (*p)++ 两种均可，为了方便，使用前面那种方式
初始化
初始化复合对象，必须使用类型标签，且左大括号必须在类型尾部。
// var a struct { x int } = { 100 } // syntax error
// var b []int = { 1, 2, 3 } // syntax error
// c := struct {x int; y string} // syntax error: unexpected semicolon or newline
// {
// }
var a = struct{ x int }{100}
var b = []int{1, 2, 3}
初始化值以 "," 分隔。可以分多行，但最后一行必须以 "," 或 "}" 结尾。
a := []int{
1,
2 // Error: need trailing comma before newline in composite literal
}
a := []int{
1,
2, // ok
}
b := []int{
1,
2 } // ok
控制流
if
- 可省略条件表达式括号。
- 支持初始化语句，可定义代码块局部变量。
- 代码块左大括号必须在条件表达式尾部。
if j:=4;j>5 { //j作为局部变量可以在此范围中使用
...
}else if j==5 {
...
}else {
...
}
for
s := "abc"
for i, n := 0, len(s); i < n; i++ { // 常见的 for 循环，支持初始化语句。
println(s[i])
}
n := len(s)
for n > 0 { // 替代 while (n > 0) {}
println(s[n]) // 替代 for (; n > 0;) {}
n--
}
for { // 替代 while (true) {}
println(s) // 替代 for (;;) {}
}
循环优化：
func main() {
s := "abcd"
for i, n := 0, len(s); i < n; i++ { // 避免多次调⽤用 length 函数。
fmt.Println(s[i])
}
}
迭代range
执行类似迭代操作，返回（索引，值）或（键，值）
可与string、array、slice、map、channel联合使用
string 返回：下标 字符
array 返回：下标 元素
slice 返回：下标 元素
map 返回：键 元素
channel 返回：元素
range会复制对象，如果使用引用类型，其底层数据就不会被复制
type wrapper struct {
x int
}
func main() {
a := [3]int{0, 1, 2}
for i, v := range a { // index、value 都是从复制品中取出。
if i == 0 { // 在修改前，我们先修改原数组。
a[1], a[2] = 999, 999
fmt.Println(a) // 确认修改有效，输出 [0, 999, 999]。
}
fmt.Println(v)
a[i] = v + 100 // 使用复制品中取出的 value 修改原数组。
}
fmt.Println(a) // 输出 [100, 101, 102]。
b := []wrapper{{1},{2},{3}}
for i, v := range b { // index、value 都是从底层中取出。
if i == 0 { // 在修改前，我们先修改原数组。
b[1], b[2] = wrapper{999},wrapper{999}
fmt.Println(a) // 确认修改有效，输出 [0, 999, 999]。
}
fmt.Println(v)
a[i] = v.x + 100 // 使用底层中取出的 value 修改原数组。
}
fmt.Println(b) // 输出 [{1} {999} {999}]。
}
switch case
分支表达式可以是任意类型，不限于常量。可省略 break，默认自动终止。
x := []int{1, 2, 3}
i := 2
switch i {
case x[1]:
fmt.Println("a")
case 1, 3:
fmt.Println("b")
default:
fmt.Println("c")
//输出a
}
如需要继续下一分支，可使用 fallthrough，但不再判断条件。
x := 10
switch x {
case 10:
fmt.Println("a") //输出a
fallthrough
case 0:
fmt.Println("b") //输出b
}
省略条件表达式，可当 if...else if...else 使用。
switch {
case x[1] > 0:
println("a")
case x[1] < 0:
println("b")
default:
println("c")
}
switch i := x[2]; { // 带初始化语句
case i > 0:
println("a")
case i < 0:
println("b")
default:
println("c")
}
goto break continue
支持在函数内 goto 跳转。标签名区分大小写，未使用标签引发错误。
func main() {
var i int
for {
fmt.Println(i)
i++
if i > 2 {
goto BREAK
}
}
BREAK:
fmt.Println("break")
EXIT: // Error: label EXIT defined and not used
}
break 可用于 跳出 for、switch、select
continue 仅能用于 跳出单次for 循环。
参考
Q.E.D.
