在本教程中，我们介绍了Go运算符。我们展示了如何使用运算符来创建表达式。
$ go version go version go1.18.1 linux/amd64
我们使用Go版本1.18。
运算符是一个特殊的符号，表示执行了某个过程。编程语言中的运算符取自数学。程序员与数据打交道。运算符用于处理数据。操作数是运算符的输入（参数）之一。
表达式由操作数和运算符构成。表达式的运算符指示将哪些操作应用于操作数。表达式中运算符的计算顺序由运算符的优先级和结合性决定。
一个运算符通常有一个或两个操作数。那些只使用一个操作数的运算符称为一元运算符。那些使用两个操作数的运算符称为二元运算符。
某些运算符可能会在不同的上下文中使用。例如，+运算符可用于不同的情况：它添加数字、连接字符串或指示数字的符号。我们说运算符过载。
去标志运算符
有两个符号运算符：+和-。它们用于指示或更改值的符号。
package main
import "fmt"
func main() {
fmt.Println(2)
fmt.Println(+2)
fmt.Println(-2)
}
+和-符号表示值的符号。加号可以用来表示我们有一个正数。它可以被省略，并且在大多数情况下都是这样做的。
package main
import "fmt"
func main() {
var a = 1
fmt.Println(-a)
fmt.Println(-(-a))
}
减号改变值的符号。
Go赋值运算符
赋值运算符=为变量赋值。变量是值的占位符。在数学中，=运算符具有不同的含义。在等式中，=运算符是一个相等运算符。等式左边等于右边。
var x = 1
这里我们为x变量分配一个数字。
x = x + 1
这个表达式在数学上没有意义，但在编程中是合法的。该表达式将1添加到x变量。右边等于2，2赋值给x。
3 = x
此代码行导致语法错误。我们不能为文字赋值。
x := 2
Go有一个简短的变量声明运算符:=;它声明变量并在一步中分配一个值。x:=2等于varx=2。
Go自增自减运算符
我们经常在编程中将一个值递增或递减一个。Go有两个方便的运算符：++和--。
x++ // x = x + 1 y-- // y = y - 1
package main
import "fmt"
func main() {
x := 6
x++
x++
fmt.Println(x)
x--
fmt.Println(x)
}
在上面的例子中，我们演示了这两个运算符的用法。
x := 6 x++ x++
我们将x变量初始化为6。然后我们将x递增两次。现在变量等于8。
x--
我们使用减量运算符。现在变量等于7。
$ go run inc_dec.go 8 7
Go复合赋值运算符
复合赋值运算符由两个运算符组成。他们是速记员。
a = a + 3 a += 3
+=复合运算符就是这些简写运算符之一。以上两个表达式是相等的。值3被添加到a变量。
其他复合运算符包括：
-= *= /= %= &= |= <<= >>=
package main
import "fmt"
func main() {
var a int = 1
a = a + 1
fmt.Println(a)
a += 5
fmt.Println(a)
a *= 3
fmt.Println(a)
}
在代码示例中，我们使用了两个复合运算符。
var a int = 1 a = a + 1
a变量初始化为1。使用非速记符号将1添加到变量。
a += 5
使用+=复合运算符，我们将5添加到a变量。该语句等于a=a+5。
a *= 3
使用*=运算符，a乘以3。语句等于a=a*3。p>
$ go run compound_operators.go 2 7 21
Go算术运算符
下图是Go中的算术运算符表。
| 符号 | 名称 |
|---|---|
+ |
加法 |
- |
减法 |
* |
乘法 |
| / | 除法 |
% |
剩余 |
以下示例显示算术运算。
package main
import "fmt"
func main() {
var a = 10
var b = 11
var c = 12
var add = a + b + c
var sb = c - a
var mult = a * b
var div = c / 3
var rem = c % a
fmt.Println(add)
fmt.Println(sb)
fmt.Println(mult)
fmt.Println(div)
fmt.Println(rem)
}
在前面的示例中，我们使用了加法、减法、乘法、除法和取余运算。这在数学中都很熟悉。
var rem = c % a
%运算符称为余数或取模运算符。它计算一个数除以另一个数的余数。例如，9%4，9模4为1，因为4进9两次，余数为1。
$ go run arithmetic.go 33 2 110 4 2
接下来我们将展示整数除法和浮点数除法的区别。
package main
import "fmt"
func main() {
c := 5 / 2
fmt.Println(c)
d := 5 / 2.0
fmt.Println(d)
}
在前面的示例中，我们将两个数字相除。
c := 5 / 2 fmt.Println(c)
在这段代码中，我们完成了整数除法。除法运算的返回值是一个整数。当我们将两个整数相除时，结果是一个整数。
d := 5 / 2.0 fmt.Println(d)
如果其中一个值是双精度或浮点数，我们将执行浮点除法。在我们的例子中，第二个操作数是一个双精度数，所以结果是一个双精度数。
$ go run division.go 2 2.5
Go布尔运算符
在Go中，我们有三个逻辑运算符。
| 符号 | 名称 |
|---|---|
&& |
逻辑与 |
|| |
逻辑或 |
! |
否定 |
布尔运算符也称为逻辑运算符。
package main
import "fmt"
func main() {
var x = 3
var y = 8
fmt.Println(x == y)
fmt.Println(y > x)
if y > x {
fmt.Println("y is greater than x")
}
}
许多表达式会产生一个布尔值。例如，布尔值用于条件语句。
fmt.Println(x == y) fmt.Println(y > x)
关系运算符总是产生一个布尔值。这两行打印假和真。
if y > x {
fmt.Println("y is greater than x")
}
if语句的主体只有在满足括号内的条件时才会执行。y>x返回true，因此消息“yisgreaterthanx”被打印到终端。
true和false关键字表示Go中的布尔文字。
package main
import "fmt"
func main() {
var a = true && true
var b = true && false
var c = false && true
var d = false && false
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
}
代码示例显示了逻辑与(&&)运算符。仅当两个操作数都为真时，它才计算为真。
$ go run and_operator.go true false false false
只有一个表达式结果为真。
如果任一操作数为真，则逻辑或(||)运算符的计算结果为真。
package main
import "fmt"
func main() {
var a = true || true
var b = true || false
var c = false || true
var d = false || false
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
}
如果运算符的其中一侧为真，则运算结果为真。
$ go run or_operator.go true true true false
四个表达式中的三个结果为真。
否定运算符!使true为false，false为true。
package main
import "fmt"
func main() {
fmt.Println(!true)
fmt.Println(!false)
fmt.Println(!(4 < 3))
}
该示例显示了否定运算符的作用。
$ go run negation_operator.go false true true
Go比较运算符
比较运算符用于比较值。这些运算符总是产生一个布尔值。
| 符号 | 含义 |
|---|---|
< |
小于 |
<= |
小于等于 |
> |
大于 |
>= |
大于或等于 |
== |
等于 |
| code>!= | 不等于 |
比较运算符也称为关系运算符。
package main
import "fmt"
func main() {
fmt.Println(3 < 4)
fmt.Println(3 == 4)
fmt.Println(4 >= 3)
fmt.Println(4 != 3)
}
在代码示例中，我们有四个表达式。这些表达式比较整数值。每个表达式的结果不是真就是假。在Go中我们使用==来比较数字。（一些语言，如Ada、VisualBasic或Pascal使用=来比较数字。）
Go位运算符
小数对人类来说很自然。二进制数是计算机固有的。二进制、八进制、十进制或十六进制符号只是相同数字的表示法。按位运算符处理二进制数的位。
| 符号 | 含义 |
|---|---|
^ |
按位异或 |
& |
按位与 |
| |
按位或 |
&^ |
位清除（不) |
<< |
左移 |
>> |
右移 |
按位与运算符在两个数字之间执行逐位比较。仅当操作数中的对应位均为1时，位位置的结果才为1。
00110 & 00011 = 00010
第一个数是6的二进制数，第二个是3，结果是2。
fmt.Println(6 & 3) // prints 2 fmt.Println(3 & 6) // prints 2
按位或运算符执行两个数字之间的逐位比较。如果操作数中的相应位中的任何一个为1，则位位置的结果为1。
00110 | 00011 = 00111
结果是00110或十进制的7。
fmt.Println(6 | 3) // prints 7 fmt.Println(3 | 6) // prints 7
按位异或运算符在两个数字之间执行逐位比较。如果操作数中相应位的一个或另一个（但不是两个）为1，则位位置的结果为1。
00110 ^ 00011 = 00101
结果为00101或十进制数5。
fmt.Println(6 ^ 3) // prints 5 fmt.Println(3 ^ 6) // prints 5
Go指针运算符
在Go语言中，&是运算符的地址，*是指针间接运算符。
package main
import "fmt"
func main() {
var count int = 4
fmt.Println(count)
var pv = &count
*pv = 3
fmt.Println(pv)
fmt.Println(*pv)
}
在代码示例中，我们演示了两个运算符。
var count int = 4
定义了一个整数变量。
var pv = &count
我们得到了count变量的地址；我们创建一个指向变量的指针。
*pv = 3
通过指针解引用，我们修改了count的值。
fmt.Println(*pv)
同样，通过指针解引用，我们打印指针引用的值。
$ go run pointer_op.go 4 0xc0000140f8 3
去渠道运营商
通道是一种类型化的管道，我们可以通过它使用通道运算符<-发送和接收值。
package main
import "fmt"
func main() {
messages := make(chan string)
go func() { messages <- "hello" }()
msg := <-messages
fmt.Println(msg)
}
该示例介绍了渠道运营商。
go func() { messages <- "hello" }()
我们向通道发送一个值。
msg := <-messages
我们从通道接收一个值。
Go运算符优先级
运算符优先级告诉我们首先评估哪些运算符。优先级级别对于避免表达式中的歧义是必要的。
以下表达式的结果是28还是40？
3 + 5 * 5
与数学一样，乘法运算符的优先级高于加法运算符。所以结果是28。
(3 + 5) * 5
要更改评估顺序，我们可以使用括号。括号内的表达式总是先求值。上面表达式的结果是40。
package main
import "fmt"
func main() {
fmt.Println(3 + 5*5)
fmt.Println((3 + 5) * 5)
fmt.Println(!true || true)
fmt.Println(!(true || true))
}
在这个代码示例中，我们展示了几个表达式。每个表达式的结果取决于优先级。
fmt.Println(3 + 5*5)
此行打印28。乘法运算符的优先级高于加法运算符。首先计算5*5的乘积，然后加上3。
fmt.Println((3 + 5) * 5)
表达式的计算可以通过使用圆括号来改变。在这种情况下，将计算3+5，然后将该值乘以5。此行打印40。
fmt.Println(!true || true)
在这种情况下，否定运算符的优先级高于按位或。首先，将初始真值取反为假，然后|运算符将假和真结合起来，从而得到真结束。
$ go run precedence.go 28 40 true false
结合性规则
有时优先级不能令人满意地确定表达式的结果。还有一个规则称为关联性。运算符的结合性决定了具有相同优先级的运算符的求值顺序。
9 / 3 * 3
这个表达式的结果是9还是1？乘法、删除和取模运算符从左到右关联。因此表达式的计算方式如下：(9/3)*3结果为9。
算术运算符、布尔运算符和关系运算符从左到右关联。三元运算符、递增、递减、一元加减、取反、位非、类型转换、对象创建运算符从右到左关联。
package main
import "fmt"
func main() {
var j = 0
j *= 3 + 1
fmt.Println(j)
}
在代码示例中，我们的关联性规则决定了表达式的结果。
var j = 0 j *= 3 + 1
复合赋值运算符是从右到左关联的。我们可能期望结果为1，但实际结果为0。由于结合性。首先计算右侧的表达式，然后应用复合赋值运算符。
在本教程中，我们介绍了Go运算符。
列出所有Go教程。
