表达式(Expressions) 与运算符(Operator)
表达式
表达式是用运算符和函数的描述的一个计算过程。
常量表达式(Constant expressions)
常量表达式在编译时执行，常量表达式中只能使用常量。
使用常量表达式时，需要特别注意未明确声明类型的常量的类型。
const a = 2 + 3.0 // a == 5.0 (untyped floating-point constant)
const b = 15 / 4 // b == 3 (untyped integer constant)
const c = 15 / 4.0 // c == 3.75 (untyped floating-point constant)
const Θ float64 = 3/2 // Θ == 1.0 (type float64, 3/2 is integer division)
const Π float64 = 3/2. // Π == 1.5 (type float64, 3/2. is float division)
const d = 1 << 3.0 // d == 8 (untyped integer constant)
const e = 1.0 << 3 // e == 8 (untyped integer constant)
const f = int32(1) << 33 // illegal (constant 8589934592 overflows int32)
const g = float64(2) >> 1 // illegal (float64(2) is a typed floating-point constant)
const h = "foo" > "bar" // h == true (untyped boolean constant)
const j = true // j == true (untyped boolean constant)
const k = 'w' + 1 // k == 'x' (untyped rune constant)
const l = "hi" // l == "hi" (untyped string constant)
const m = string(k) // m == "x" (type string)
const Σ = 1 - 0.707i // (untyped complex constant)
const Δ = Σ + 2.0e-4 // (untyped complex constant)
const Φ = iota*1i - 1/1i // (untyped complex constant)
complex是内置的函数，返回常量：
const ic = complex(0, c) // ic == 3.75i (untyped complex constant)
const iΘ = complex(0, Θ) // iΘ == 1i (type complex128)
如果常量的值超过了能够表达的范围，这个常量可以作为中间值使用：
const Huge = 1 << 100 // Huge == 1267650600228229401496703205376 (untyped integer constant)
const Four int8 = Huge >> 98 // Four == 4 (type int8)
除数不能为0：
const n = 3.14 / 0.0 // illegal: division by zero
不可以将常量转换为不匹配的类型：
uint(-1) // -1 cannot be represented as a uint
int(3.14) // 3.14 cannot be represented as an int
int64(Huge) // 1267650600228229401496703205376 cannot be represented as an int64
Four * 300 // operand 300 cannot be represented as an int8 (type of Four)
Four * 100 // product 400 cannot be represented as an int8 (type of Four)
选择表达式(Selector)
选择表达式的格式如下:
x.f
其中f是选择器(selector)，类型为f，它不能是空白标记符_。
如果x是包名，那么选择的是包中的标记符。
f可以是x的成员、方法、匿名成员、匿名成员的方法，到达f时经过的选择次数是f的深度(depth)。
如果f是x的直接成员，深度为0，f是x的直接匿名成员的成员，深度为f在匿名成员中的深度+1。
选择表达式遵循下面的规则：
x的类型为T或者*T，并且T不是指针和接口，x.f是T中深度最小的名为f的成员。
x的类型为T，T是接口, x.f是x的动态类型的名为f的方法。
如果x是指针，x.f是(*x).f的简写，两者等同
如果按照上面的规则，找不到f，编译或运行时报错。
对于下面的代码：
type T0 struct {
x int
}
func (*T0) M0()
type T1 struct {
y int
}
func (T1) M1()
type T2 struct {
z int
T1
*T0
}
func (*T2) M2()
type Q *T2
var t T2 // with t.T0 != nil
var p *T2 // with p != nil and (*p).T0 != nil
var q Q = p
可以有这么些选择方法：
t.z // t.z
t.y // t.T1.y
t.x // (*t.T0).x
p.z // (*p).z
p.y // (*p).T1.y
p.x // (*(*p).T0).x
q.x // (*(*q).T0).x (*q).x is a valid field selector
p.M0() // ((*p).T0).M0() M0 expects *T0 receiver
p.M1() // ((*p).T1).M1() M1 expects T1 receiver
p.M2() // p.M2() M2 expects *T2 receiver
t.M2() // (&t).M2() M2 expects *T2 receiver, see section on Calls
注意q没有选择M0()，因为M0()的Reciver类型是*T1，类型Q中不能继承T1的方法。
方法表达式(Method expressions)
方法(method)表达式就是方法的实现语句。
MethodExpr = ReceiverType "." MethodName .
ReceiverType = TypeName | "(" "*" TypeName ")" | "(" ReceiverType ")" .
与函数的不同的是，方法是有接收者(Receiver)的，如下：
type T struct {
a int
}
func (tv T) Mv(a int) int { return 0 } // value receiver
func (tp *T) Mp(f float32) float32 { return 1 } // pointer receiver
var t T
方法是属于类型的，类型的方法和类型的指针的方法是不同的。
类型的方法是一个将接收者作为参数传入的函数，例如在上面例子中:
T.Mv 的类型为 func(tv T, a int) int
T.Mp 的类型为 func(tv *T, a int) int
类型的方法可以直接通过类型名调用：
T.Mv(t, 7) //注意要传入接收者
(T).Mv(t, 7)
(*T).Mp(&t, 7) //注意传入的是接收者是指针
类型不能调用类型指针的方法，类型指针可以调用类型的方法：
T.Mp(&t,7) //Mp是(*T)的方法，不允许T调用
(*T).Mv(t,7) //Mv是T的方法，*T可以调用
也可以把方法赋值给变量，然后通过变量调用:
f1 := T.Mv; f1(t, 7) //要传入接受者t
f2 := (T).Mv; f2(t, 7) //要传入接受者t
f3 := T.Mp; f3(&t, 7) //要传入接受者&t
f4 := (T).Mp; f4(&t, 7) //要传入接受者&t
也可以通过该类型的变量调用，这时候不需要传入接收者。
t.Mv(7)
t.Mp(7)
因为变量的方法和类型的方法是不同的，所以不需要传入接收者。
t.Mv 的类型为 func(a int) int
t.Mp 的类型为 func(a int) int
无论一个变量(t)是不是指针(类型为*T的变量），它都既可以调用类型(T)的方法，也可以调用类型指针(*T)的方法。go语言自身代为完成了取址和取值操作。
变量的方法也可以存放单独的变量中，然后通过变量调用：
f := t.Mv; f(7) // like t.Mv(7)
f := pt.Mp; f(7) // like pt.Mp(7)
f := pt.Mv; f(7) // like (*pt).Mv(7)
f := t.Mp; f(7) // like (&t).Mp(7)
f := makeT().Mp // invalid: result of makeT() is not addressable
变量的类型为接口时，用同样的方式调用方法：
var i interface { M(int) } = myVal
f := i.M; f(7) // like i.M(7)
索引表达式(Index expressions)
索引表达式格式如下：
a[x]
a的类型不同，表达式的运行结果不同。
如果a不是字典，x的必须是整数，并且0<= x <len(a)
如果a是数组，返回数组中x位置处的成员，如果x超出数组范围，程序panic
如果a是指向数组的指针，a[x]等同于(*a)[x]
如果a是分片(Slice)， a[x]返回x位置处的数组成员，如果x超出范围，程序panic
如果a是字符串，返回x位置处的字符，如果x超出范围，程序panic，且a[x]不能被赋值
如果a是字典(map)，x的类型必须是字典的key的类型，返回字典中x对应的值，和表示对应成员是否存在的布尔类型的值(bool)
如果a是字典(map)，且a的值是nil，a[x]返回字典中成员类型的零值
分片表达式(Slice expressions)
分片表达式适用于字符串、数组、指向数组的指针和分片。
a[low : high]
返回一个从零开始，长度为high-low的分片。
a := [5]int{1, 2, 3, 4, 5}
s := a[1:4]
得到分片s的情况如下：
s[0] == 2
s[1] == 3
s[2] == 4
分片表达式中low和high省略：
a[2:] // same as a[2 : len(a)]
a[:3] // same as a[0 : 3]
a[:] // same as a[0 : len(a)]
如果a是指向数组的指针，a[low:high]等同于(*a)[low:high]。
如果a是字符串、数组、指向数组的指针，low和high的取值范围为：
0 <= low <= high <= len(a)
如果a是分片，low和high的取值范围为：
0 <= low <= high <= cap(a)
low和high超出范围时，引发panic。
如果a是已经声明字符串、分片，返回值也是字符串、分片。
如果a是未声明的字符串，返回一个类型为字符串的变量.
如果a是数组，返回指向这个数组的分片。
完整分片表达式(Full slice expressions)
完整的分片表达式还带有一个max，限定返回的分片的容量为(capacity)为max-low。
a[low : high : max]
在完整的分片表达式中，只有low可以省略，默认为0。
如果a是字符串、数组、指向数组的指针，low和high的取值范围为：
0<= low <= high <= max <= len(a)
如果a是分片，low、high和max的取值范围为：
0<= low <= high <= max <= cap(a)
如果超出范围，引发panic。
类型断言表达式(Type assertions expressions)
断言表达式用来判断x是否不为nil，且它的类型是否与T匹配。
x.(T)
如果T不是接口类型，x的类型必须是接口，判断T是否可以成为x的动态类型。
如果T是接口类型，判断x是否实现了接口T。
如果T不是接口类型，x的类型也不是接口，引发panic。
如果断言成立，表达式的值就是类型为T的x，和布尔值true；如果断言不成立，表达式的值是类型T的零值，和布尔值false。
调用表达式(Call expressions)
调用表达式适用于函数和方法：
f(a1, a2, … an)
针对方法使用时，需要带有receiver:
math.Atan2(x, y) // function call
var pt *Point
pt.Scale(3.5) // method call with receiver pt
传入值按值、按顺序传递给函数或方法的参数，返回值也是按值传递的。
如果一个函数的返回值，满足另一个参数的传入参数要求，可以写成f(g(parameters_of_g))，例如：
func Split(s string, pos int) (string, string) {
return s[0:pos], s[pos:]
}
func Join(s, t string) string {
return s + t
}
if Join(Split(value, len(value)/2)) != value {
log.Panic("test fails")
}
调用表达式支持变长参数，变长参数必须是最后一个，且类型前是...。
例如在下面的函数中：
func Greeting(prefix string, who ...string)
如果以这种方式调用，参数who的值是nil：
Greeting("nobody")
如果以这种方式调用，参数who的值的类型是[]string：
Greeting("hello:", "Joe", "Anna", "Eileen")
如果以这种方式调用，参数who等于s：
s:= []string{"James", "Jasmine"}
Greeting("goodbye:", s...)
运算符(Operator)
运算符用于构成表达式。
Expression = UnaryExpr | Expression binary_op Expression .
UnaryExpr = PrimaryExpr | unary_op UnaryExpr .
binary_op = "||" | "&&" | rel_op | add_op | mul_op .
rel_op = "==" | "!=" | "<" | "<=" | ">" | ">=" .
add_op = "+" | "-" | "|" | "^" .
mul_op = "*" | "/" | "%" | "<<" | ">>" | "&" | "&^" .
unary_op = "+" | "-" | "!" | "^" | "*" | "&" | "<-" .
运算符都是go语言内置的。
Precedence Operator
5 * / % << >> & &^
4 + - | ^
3 == != < <= > >=
2 &&
1 ||
优先级相同的二元运算符按照先左后右的顺序结合：
x / y * z
等同于：
(x / y) * z
算数运算符(Arithmetic operators)
+ sum integers, floats, complex values, strings
- difference integers, floats, complex values
* product integers, floats, complex values
/ quotient integers, floats, complex values
% remainder integers
& bitwise AND integers
| bitwise OR integers
^ bitwise XOR integers
&^ bit clear (AND NOT) integers
<< left shift integer << unsigned integer
>> right shift integer >> unsigned integer
字符串拼接(String concatenation)
字符串可以用运算符"+"进行拼接：
:= "hi" + string(c)
s += " and good bye"
比较运算符(Comparison operators)
== equal
!= not equal
< less
<= less or equal
> greater
>= greater or equal
逻辑运算符(Logical operators)
&& conditional AND p && q is "if p then q else false"
|| conditional OR p || q is "if p then true else q"
! NOT !p is "not p"
地址运算符(Address operators)
&
*
读取运算符(Receive operator)
v1 := <-ch
v2 = <-ch
f(<-ch)
<-strobe // wait until clock pulse and discard received value
类型转换(Conversions)
Conversion = Type "(" Expression [ "," ] ")" .