Go语言运算符
- 运算符类型：Go 语言提供了各种运算符，包括算术运算符（用于加减乘除等）、赋值运算符、关系运算符（比较值）和逻辑运算符（基于条件返回布尔值）。
- 算术和赋值运算符示例：算术运算符如
+、-、*、/用于基本数学运算。赋值运算符=用于赋值，而复合赋值运算符如+=、-=结合了算术和赋值操作。 - 关系和逻辑运算符：关系运算符（如
==、<、>）用于比较两个值，逻辑运算符（如&&、||、!）用于基于条件的复合逻辑判断。
在计算机编程中，运算符是执行对值或变量的操作的符号。
例如，+ 是 一个运算符，用于加两个数字。
Go 编程提供了广泛的运算符，它们可以分为以下几个主要类别：
- 算术运算符
- 赋值运算符
- 关系运算符
- 逻辑运算符
算术运算符
我们使用算术运算符来执行加法、减法、乘法和除法等算术操作。
以下是 Go 中可用的各种算术运算符列表。
| 运算符 | 示例 |
|---|---|
+（加法） | a + b |
-（减法） | a - b |
*（乘法） | a * b |
/（除法） | a / b |
%（取模） | a % b |
示例 1：加法、减法和乘法运算符
package main
import "fmt"
func main() {
num1 := 6
num2 := 2
// + 加两个变量
sum := num1 + num2
fmt.Printf("%d + %d = %d\n", num1, num2, sum)
// - 减两个变量
difference := num1 - num2
fmt.Printf("%d - %d = %d\n",num1, num2, difference)
// * 乘两个变量
product := num1 * num2
fmt.Printf("%d * %d 是 %d\n",num1, num2, product)
}
输出
6 + 2 = 8
6 - 2 = 4
6 * 2 = 12
示例 2：Golang 除法运算符
package main
import "fmt"
func main() {
num1 := 11
num2 := 4
// / 两个整数变量相除
quotient := num1 / num2
fmt.Printf(" %d / %d = %d\n", num1, num2, quotient)
}
输出
11 / 4 = 2
在上面的例子中，我们使用 / 运算符来除两个数字：11 和 4。这里，我们得到输出 2。
然而，在正常计算中，11 / 4 会得到 2.75。这是因为当我们用 / 运算符对整数值进行操作时，我们得到的是商而不是实际结果。
如果我们想要实际结果，我们应该始终使用 / 运算符对浮点数进行操作。例如，
package main
import "fmt"
func main() {
num1 := 11.0
num2 := 4.0
// / 两个浮点变量相除
result := num1 / num2
fmt.Printf(" %g / %g = %g\n", num1, num2, result)
}
输出
11 / 4 = 2.75
这里，我们在除法后得到了实际的结果。
示例 3：Go 中的取模运算符
package main
import "fmt"
func main() {
num1 := 11
num2 := 4
// % 两个变量取模
remainder := num1 % num2
fmt.Println(remainder )
}
在上面的例子中，我们使用了取模运 算符对数字 11 和 4 进行操作。这里，我们得到结果 3。
这是因为在编程中，取模运算符总是返回除法后的余数。
注意： 取模运算符始终与整数值一起使用。
Go 中的自增和自减运算符
在 Golang 中，我们使用 ++（自增）和 --（自减）运算符来分别使变量的值增加或减少 1。例如，
package main
import "fmt"
func main() {
num := 5
// num 自增 1
num++
fmt.Println(num) // 6
// num 自减 1
num--
fmt.Println(num) // 5
}
在上面的例子中，
- num++ - 将 num 的值增加
1，从5变为6 - num-- - 将 num 的值减少
1，从6变为5
注意： 我们在变量前使用了 ++ 和 -- 作为前缀。然而，我们也可以把它们作为后缀使用（num++ 和 num--）。
作为前缀和后缀使用自增和自减运算符之间有细微的区别。
Go 赋值运算符
我们使用赋值运算符将值赋给变量。例如，
var number = 34
这里，= 运算符将右侧的值（34）赋给左侧的变量（number）。
示例：Go 中的赋值运算符
package main
import "fmt"
func main() {
num := 6
var result int
// 使用 = 运算符将 num 的值赋给 result
result = num
fmt.Println(result) // 6
}
在上面的例子中，我们使用了赋值运算符将 num 变量的值赋给了 result 变量。
复合赋值运算符
在 Go 中，我们也可以将赋值运算符与算术运算符一起使用。例如，
number := 2
number += 6
这里，+= 是加法赋值运算符。它首先将 6 加到 number 的值（2）上，然后将最终结果（8）赋给 number。
以下是 Golang 中可用的各种复合赋值运算符列表。
| 运算符 | 示例 | 相当于 |
|---|---|---|
+= (加法赋值) | a += b | a = a + b |
-= (减法赋值) | a -= b | a = a - b |
*= (乘法赋值) | a *= b | a = a * b |
/= (除法赋值) | a /= b | a = a / b |
%= (取模赋值) | a %= b | a = a % b |
Golang 中的关系运算符
我们使用关系运算符来比较两个值或变量。例如，
5 == 6
这里，== 是一个关系运算符，用于检查 5 是否等于 6。
关系运算符返回
true如果两个值的比较是正确的false如果比较是错误的
以下是 Go 中可用的各种关系运算符列表：
| 运算符 | 示例 | 描述 |
|---|---|---|
== (等于) | a == b | 如果 a 和 b 相等则返回 true |
!= (不等于) | a != b | 如果 a 和 b 不相等则返回 true |
> (大于) | a > b | 如果 a 大于 b 则返回 true |
< (小于) | a < b | 如果 a 小于 b 则返回 true |
>= (大于或等于) | a >= | b | 如果 a大于或等于b则返回true |
<=(小于或等于) | a <= b | 如果 a小于或等于b则返回true |
要了解更多，请访问Go 关系运算符。
Go 中的逻辑运算符
我们使用逻辑运算符来执行逻辑操作。逻辑运算符根据条件返回 true 或 false。
| 运算符 | 描述 | 示例 |
|---|---|---|
&& (逻辑与) | exp1 && exp2 | 如果两个表达式 exp1 和 exp2 都为 true 则返回 true |
|| (逻辑或) | exp1 || exp2 | 如果任一表达式为 true 则返回 true。 |
! (逻辑非) | !exp | 如果 exp 为 false 则返回 true，如果 exp 为 true 则返回 false。 |
要了解更多，请访问Go 逻辑运算符。
Go 运算符的更多信息
Go 二进制右移运算符 >>
右移运算符将所有位向右移动指定的位数。
假设我们想将数字 212 向右移动一些位，
212 = 11010100（二进制）
212 >> 3 = 00011010 = 26（向右移 3 位）
212 >> 7 = 00000001 = 1（向右移 7 位）
212 >> 0 = 11010100 = 212（无移动）
例如，
package main
import "fmt"
func main() {
num := 212
for i := 0; i <= 3; i++ {
// 将 212 向右移动从 0 到 3 的位数
fmt.Printf("向右移动 %d 位: %d\n", i, num>>i)
}
}
输出
向右移动 0 位: 212
向右移动 1 位: 106
向右移动 2 位: 53
向右移动 3 位: 26
Go 二进制左移运算符 <<
左移运算符将所有位向左移动指定的位数。被左移运算符清空的位位置被填充为 0。
假设我们想将数字 212 向左移动一些位，
212 = 11010100（二进制）
212 << 1 = 110101000 = 424（右侧增加一个 0）
212 << 3 = 11010100000 = 1696（右侧增加三个 0）
212 << 0 = 11010100 = 212（无移动）
例如，
package main
import "fmt"
func main() {
num := 212
for i := 0; i <= 3; i++ {
// 将 212 向左移动从 0 到 3 的位数
fmt.Printf("向左移动 %d 位: %d\n", i, num<<i)
}
}
输出
向左移动 0 位: 212
向左移动 1 位: 424
向左移动 2 位: 848
向左移动 3 位: 1696
在 Go 中 & 运算符的作用是什么？
在 Go 中，& 是地址运算符，用于指针。它保存变量的内存地址。例如，
package main
import "fmt"
func main() {
num := 20
// &num 打印存储 20 的
// 内存地址
fmt.Println(&num)
}
// 输出：0xc0000b8000
这里，我们使用了 * 运算符来声明指针变量。要了解更多，请访问Go 指针。
在 Go 中 * 运算符的作用是什么？
在 Go 中，* 是解引用运算符，用于声明指针变量。指针变量存储内存地址。例如，
package main
import "fmt"
func main() {
b := 20
// 指针声明
var num *int = &b
// 输出内存地址
fmt.Println(num)
}
// 输出：0xc00010a000
这里，我们使用了 * 运算符来声明指针变量。要了解更多，请访问 Go 指针。
如果我们在单个语句中同时使用多个运算符，哪个运算符会首先执行？
在 Go 中，我们使用称为运算符优先级的概念，以确定如果同时使用多个运算符时，哪个运算符会首先执行。例如，
result := 32 / 8 + 2 * 9 - 4
这里，/ 运算符首先执行，然后是 * 运算符。+ 和 - 运算符分别最后执行。
这是因为优先级较高的运算符会首先执行，而优先级较低的运算符则最后执行。