GO学习笔记之表达式
GO学习笔记之表达式
-
- 保留字
- 运算符
- 优先级
- 二元运算符
- 位运算符
- 自增
- 指针
保留字
Go语言仅25个保留关键字（keyword），这是最常见的宣传语，虽不是主流语言中最少的，但也确实体现了Go语法规则的简洁性。保留关键字不能用作常量、变量、函数名，以及结构字段等标识符。
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
相比在更新版本中不停添加新语言功能，我更喜欢简单的语言设计。某些功能可通过类库扩展，或其他非侵入方式实现，完全没必要为了“方便”让语言变得臃肿。过于丰富的功能特征会随着时间的推移抬升门槛，还会让代码变得日趋“魔幻”，降低一致性和可维护性。
运算符
很久以前，流传“程序=算法+数据”这样的说法。
算法是什么？通俗点说就是“解决问题的过程”。小到加法指令，大到成千上万台服务器组成的分布式计算集群，抛去抽象概念和宏观架构，最终都由最基础的机器指令过程去处理不同层次存储设备里的数据。
学习语言和设计架构不同，我们所关心的就是微观层次，诸如语法规则所映射的机器指令，以及数据存储位置和格式等等。其中，运算符和表达式用来串联数据和指令，算是最基础的算法。
另有一句话：“硬件的方向是物理，软件的结局是数学。”
全部运算符及分隔符列表：
+ & += &= && == != ( )
- | -= |= || < <= [ ]
* ^ *= ^= <- > >= { }
/ << /= <<= ++ = := , ;
% >> %= >>= -- ! ... . :
&^ &^=
没有乘幂和绝对值运算符，对应的是标准库math里的Pow、Abs函数实现。
优先级
一元运算符优先级最高，二元则分成五个级别，从高往低分别是：
highest * / % << >> & &^ + - | ^ == != < <= > >= && lowest ||
相同优先级的二元运算符，从左往右依次计算。
二元运算符
除位移操作外，操作数类型必须相同。如果其中一个是无显式类型声明的常量，那么该常量操作数会自动转型。
func main() {
const v=20 // 无显式类型声明的常量
var a byte=10
b:=v+a //v自动转换为byte/uint8类型
fmt.Printf("%T, %v\n",b,b)
const c float32=1.2
d:=c+v //v自动转换为float32类型
fmt.Printf("%T, %v\n",d,d)
}
uint8,30
float32,21.2
func main() {
b:=23 //b是有符号int类型变量
x:=1<<b // 无效操作:1<
println(x)
}
位移右操作数必须是无符号整数，或可以转换的无显式类型常量。
如果是非常量位移表达式，那么会优先将无显式类型的常量左操作数转型。
func main() {
a:=1.0<<3 // 常量表达式（包括常量展开）
fmt.Printf("%T, %v\n",a,a) //int,8
var s uint=3
b:=1.0<<s // 无效操作:1<
fmt.Printf("%T, %v\n",b,b) // 因为b没有提供类型，那么编译器通过1.0推断，
// 显然无法对浮点数做位移操作
var c int32=1.0<<s // 自动将1.0转换为int32类型
fmt.Printf("%T, %v\n",c,c) //int32,8
}
位运算符
二进制位运算符比较特别的就是“bit clear”，在其他语言里很少见到。
AND 按位与：都为1 a&b 0101&0011=0001
OR 按位或：至少一个1 a|b 0101|0011=0111
XOR 按位亦或：只有一个1 a^b 0101^0011=0110
NOT 按位取反 (一元) ^a ^0111=1000
AND NOT 按位清除 (bit clear) a&^b 0110&^1011=0100
LEFT SHIFT 位左移 a<<2 0001<<3=1000
RIGHT SHIFT 位右移 a>>2 1010>>2=0010
位清除（AND NOT）和位亦或（XOR）是不同的。它将左右操作数对应二进制位都为1的重置为0（有些类似位图），以达到一次清除多个标记位的目的。
const(
read byte=1<<iota
write
exec
freeze
)
func main() {
a:=read|write|freeze
b:=read|freeze|exec
c:=a&^b // 相当于a^read^freeze，但不包括exec
fmt.Printf("%04b&^ %04b= %04b\n",a,b,c)
}
自增
自增、自减不再是运算符。只能作为独立语句，不能用于表达式。
指针
不能将内存地址与指针混为一谈。
内存地址是内存中每个字节单元的唯一编号，而指针则是一个实体。指针会分配内存空间，相当于一个专门用来保存地址的整型变量。
p:= &x x:=100
-----------------+--------+------\\-------+------+---------
memory ... |0x1200| .... |100 | ...
-----------------+--------+------\\-------+------+---------
address 0x800 0x1200
取址运算符“&”用于获取对象地址。
指针运算符“”用于间接引用目标对象。
二级指针**T，如包含包名则写成package.T。
并非所有对象都能进行取地址操作，但变量总是能正确返回（addressable）。指针运算符为左值时，我们可更新目标对象状态；而为右值时则是为了获取目标状态。
func main() {
x:=10
var p*int= &x // 获取地址，保存到指针变量
*p+=20 // 用指针间接引用，并更新对象
println(p, *p) // 输出指针所存储的地址，以及目标对象
}
输出
0xc82003df30 30
指针类型支持相等运算符，但不能做加减法运算和类型转换。如果两个指针指向同一地址，或都为nil，那么它们相等。
func main() {
x:=10
p:= &x
p++ // 无效操作:p++ (non-numeric type*int)
var p2*int=p+1 // 无效操作:p+1(mismatched types*int and int)
p2= &x
println(p==p2)
}
可通过unsafe.Pointer将指针转换为uintptr后进行加减法运算，但可能会造成非法访问。
Pointer类似C语言中的void*万能指针，可用来转换指针类型。它能安全持有对象或对象成员，但uintptr不行。后者仅是一种特殊整型，并不引用目标对象，无法阻止垃圾回收器回收对象内存。
指针没有专门指向成员的“->”运算符，统一使用“.”选择表达式。
func main() {
a:=struct{
x int
}{}
a.x=100
p:= &a
p.x+=100 // 相当于p->x+=100
println(p.x)
}
零长度（zero-size）对象的地址是否相等和具体的实现版本有关，不过肯定不等于nil。即便长度为0，可该对象依然是“合法存在”的，拥有合法内存地址，这与nil语义完全不同。
在runtime/malloc.go里有个zerobase全局变量，所有通过mallocgc分配的零长度对象都使用该地址。不过上例中，对象a、b在栈上分配，并未调用mallocgc函数。
func main() {
var a,b struct{}
println(&a, &b)
println(&a== &b, &a==nil)
}
运行结果：
0xc820041f2f 0xc820041f2f
true false