【Go】深入探索Go语言中运算符

在这里插入图片描述

✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑
🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Go语言开发零基础到高阶实战
景天的主页：景天科技苑

在这里插入图片描述

文章目录

Go语言中运算符
- 一、算术运算符
- - 1. 加法运算符（`+`）
  - 2. 减法运算符（`-`）
  - 3. 乘法运算符（`*`）
  - 4. 除法运算符（`/`）
  - 5. 取模运算符（`%`）
  - 6. 自增自减(++ --)
- 二、赋值运算符
- - 1. 简单赋值运算符（=）
  - 2. 复合赋值运算符
- 三、关系运算符
- - 1. 等于（`==`）
  - 2. 不等于（`!=`）
  - 3. 大于（`>`）、小于（`<`）、大于等于（`>=`）、小于等于（`<=`）
- 四、逻辑运算符
- - 1. 逻辑与（`&&`）
  - 2. 逻辑或（`||`）
  - 3. 逻辑非（`!`）
- 五、位运算符
- - 1. 按位与（`&`）
  - 2. 按位或（`|`）
  - 3. 按位异或（`^`）
  - 4. 按位取反（`^`，单独使用时）
  - 5. 按位左移(<<)
  - 6. 按位右移(>>)
- 六、运算符优先级
- 七、总结

Go语言中运算符

在Go语言中，运算符是编程中不可或缺的一部分，它们用于执行数学、逻辑和位运算等操作。理解这些运算符的工作原理及其与Go语言其他元素的交互，对于深入学习Go语言至关重要。本文将详细探讨Go语言中的各类运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符等，并通过实际案例展示其用法。

一、算术运算符

算术运算符用于执行基本的数学运算，如加、减、乘、除等。在Go语言中，这些运算符适用于整数、浮点数和复数等数值类型。

1. 加法运算符（`+`）

加法运算符用于将两个数值类型的操作数相加。其语法为：result = operand1 + operand2。

示例：

package main

import "fmt"

func main() {
    a := 5
    b := 3
    result := a + b
    fmt.Println("加法运算结果:", result) // 输出: 加法运算结果: 8

    // 字符串加法（拼接）
    str1 := "Hello"
    str2 := "World"
    resultStr := str1 + " " + str2
    fmt.Println("字符串拼接结果:", resultStr) // 输出: 字符串拼接结果: Hello World
}

2. 减法运算符（`-`）

减法运算符用于从一个数值类型的操作数中减去另一个数值类型的操作数。其语法为：result = operand1 - operand2。

示例：

package main

import "fmt"

func main() {
    a := 5
    b := 3
    result := a - b
    fmt.Println("减法运算结果:", result) // 输出: 减法运算结果: 2
}

3. 乘法运算符（`*`）

乘法运算符用于两个数值类型的操作数相乘。其语法为：result = operand1 * operand2。

示例：

package main

import "fmt"

func main() {
    a := 5
    b := 3
    result := a * b
    fmt.Println("乘法运算结果:", result) // 输出: 乘法运算结果: 15
}

4. 除法运算符（`/`）

除法运算符用于一个数值类型的操作数除以另一个数值类型的操作数。其语法为：result = operand1 / operand2。注意，整数除法会向下取整。

示例：

package main

import "fmt"

func main() {
    a := 10
    b := 3
    resultInt := a / b
    fmt.Println("整数除法结果:", resultInt) // 输出: 整数除法结果: 3

    aFloat := 10.0
    bFloat := 3.0
    resultFloat := aFloat / bFloat
    fmt.Println("浮点数除法结果:", resultFloat) // 输出: 浮点数除法结果: 3.3333333333333335
}

5. 取模运算符（`%`）

取模运算符用于返回两个整数相除的余数。其语法为：result = operand1 % operand2。

示例：

package main

import "fmt"

func main() {
    a := 10
    b := 3
    result := a % b
    fmt.Println("取模运算结果:", result) // 输出: 取模运算结果: 1
}

6. 自增自减(++ --)

单元运算符，用自己就可以操作得出结果

package main

import "fmt"

func main() {
	// 算术运算符  ++ --
	var a int = 7

	// 单元运算符，用自己就可以操作得出结果
	//  自增++  自减--
	fmt.Println(a) // 7
	a++ // a = a + 1 自增，在自己的基础上 + 1
	fmt.Println(a)  // 8

	a = 7
	a-- // a = a-1。  自减 遍历输出一些东西（10000个数字）
	fmt.Println(a)  // 6

}

二、赋值运算符

赋值运算符用于将值赋给变量。
下表列出了所有Go语言的赋值运算符。
在这里插入图片描述

1. 简单赋值运算符（=）

案例：

a := 5  
b := 3  
b = a // b的值变为5  
fmt.Println("b:", b) // 输出: b: 5

2. 复合赋值运算符

案例：

a := 5  
b := 3  
b += a // b的值变为8  
fmt.Println("b:", b) // 输出: b: 8  
  
b *= 2 // b的值变为16  
fmt.Println("b:", b) // 输出: b: 16

三、关系运算符

关系运算符用于比较两个值，并返回一个布尔结果（true 或 false）。

1. 等于（`==`）

判断两个操作数是否相等。

示例：

package main

import "fmt"

func main() {
    a := 5
    b := 3
    result := a == b
    fmt.Println("a 是否等于 b:", result) // 输出: a 是否等于 b: false
}

2. 不等于（`!=`）

判断两个操作数是否不相等。

示例：

package main

import "fmt"

func main() {
    a := 5
    b := 3
    result := a != b
    fmt.Println("a 是否不等于 b:", result) // 输出: a 是否不等于 b: true
}

3. 大于（`>`）、小于（`<`）、大于等于（`>=`）、小于等于（`<=`）

分别用于判断左侧操作数是否大于、小于、大于等于、小于等于右侧操作数。

示例：

package main

import "fmt"

func main() {
    a := 5
    b := 3
    fmt.Println("a 是否大于 b:", a > b) // 输出: a 是否大于 b: true
    fmt.Println("a 是否小于 b:", a < b) // 输出: a 是否小于 b: false
    fmt.Println("a 是否大于等于 b:", a >= b) // 输出: a 是否大于等于 b: true
    fmt.Println("a 是否小于等于 b:", a <= b) // 输出: a 是否小于等于 b: false
}

四、逻辑运算符

逻辑运算符用于构建布尔逻辑表达式，通常用于条件判断。

判断多个条件是否存在的时候，就需要逻辑

&& 与只要有一个错，大家都是错的 false，两个都对才是对的。多条件同时满足（与）

与（和） And 对 And 错对 And 对（true）错 And 对错和错共生！

|| 或只要有一个对的，那么就是对的，两个都是错的，结果才是错的。（or）

或 Or 或者对 or 错（true）对 or对（true）错 or对（true）错or错（错）

**！**如果是真的，那么为假，如果是假，则为真。

非（取反）

1. 逻辑与（`&&`）

当两个条件都为真时，结果为真。

示例：

package main

import "fmt"

func main() {
    a := true
    b := false
    result := a && b
    fmt.Println("a && b 的结果:", result) // 输出: a && b 的结果: false
}

2. 逻辑或（`||`）

当至少一个条件为真时，结果为真。

示例：

package main

import "fmt"

func main() {
    a := true
    b := false
    result := a || b
    fmt.Println("a || b 的结果:", result) // 输出: a || b 的结果: true
}

3. 逻辑非（`!`）

取反一个条件的值。

示例：

package main

import "fmt"

func main() {
    a := true
    result := !a
    fmt.Println("!a 的结果:", result) // 输出: !a 的结果: false
}

五、位运算符

位运算符用于对整数在内存中的二进制位进行操作，常用于底层编程、网络协议或哈希算法等场景。
Go 语言支持的位运算符如下表所示。
在这里插入图片描述

1. 按位与（`&`）

对两个数的二进制进行按位与操作。

示例：

package main

import "fmt"

func main() {
    a := 60 // 二进制: 0011 1100
    b := 13 // 二进制: 0000 1101
    result := a & b
    fmt.Printf("a & b 的结果: %d\n", result) // 输出: a & b 的结果: 12
}

2. 按位或（`|`）

对两个数的二进制进行按位或操作。

示例：

package main

import "fmt"

func main() {
    a := 60 // 二进制: 0011 1100
    b := 13 // 二进制: 0000 1101
    result := a | b
    fmt.Printf("a | b 的结果: %d\n", result) // 输出: a | b 的结果: 61
}

3. 按位异或（`^`）

对两个数的二进制进行按位异或操作。

示例：

package main

import "fmt"

func main() {
    a := 60 // 二进制: 0011 1100
    b := 13 // 二进制: 0000 1101
    result := a ^ b
    fmt.Printf("a ^ b 的结果: %d\n", result) // 输出: a ^ b 的结果: 49
}

4. 按位取反（`^`，单独使用时）

对二进制数的每一位进行取反操作。

示例：

package main  
  
import "fmt"  
  
func main() {  
    a := 60 // 二进制: 0011 1100（这里假设是8位整数，实际中int类型通常占用更多位）  
    // 注意：在实际环境中，int类型通常占用32位或64位，但这里为了简化说明，我们假设是8位。  
  
    // 对a进行按位取反  
    result := ^a  
  
    // 因为a是正数，其二进制最高位（符号位）为0，取反后变为1，表示负数。  
    // 同时，其他位也取反。但直接打印负数可能不会直接显示其二进制形式，所以这里只做说明。  
  
    // 为了更直观地看到结果，我们可以将result转换为无符号整数来查看其二进制表示（忽略符号位的变化）  
    var unsignedResult uint8 = uint8(result) // 强制转换为uint8以忽略符号位的影响（仅用于展示目的）  
    fmt.Printf("a的二进制按位取反（忽略符号位）: %08b\n", unsignedResult) // 输出a的二进制取反结果，忽略符号位的变化  
  
    // 注意：上面的转换仅用于演示目的，实际上^a得到的是一个int类型的负数。  
    // 如果你想查看这个负数的具体值，直接打印result即可。  
    fmt.Println("a的按位取反结果（作为int类型）:", result) // 输出结果可能是一个负数  
}  
  
// 注意：上面的代码在真实环境中运行时，由于int类型的实际位数（32位或64位），直接打印^a的二进制表示并不直观。  
// 因此，这里使用uint8进行转换只是为了演示按位取反的二进制效果，并忽略符号位的影响。

5. 按位左移(<<)

左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。

a := 60 // 二进制: 0011 1100  
b := 13 // 二进制: 0000 1101  
  
// 左移  
resultLeftShift := a << 2  
fmt.Printf("a << 2 = %d, Binary: %b\n", resultLeftShift, resultLeftShift) // 输出: a << 2 = 240, Binary: 11110000

6. 按位右移(>>)

右移运算符">>“是双目运算符。右移n位就是除以2的n次方。其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。

a := 60 // 二进制: 0011 1100  
b := 13 // 二进制: 0000 1101  
  
// 右移  
resultRightShift := a >> 1  
fmt.Printf("a >> 1 = %d, Binary: %b\n", resultRightShift, resultRightShift) // 输出: a >> 1 = 30, Binary: 11110

六、运算符优先级

了解运算符的优先级对编写正确且高效的代码至关重要。Go语言中运算符的优先级遵循标准的数学规则，如乘法和除法先于加法和减法执行。可以使用括号()来改变默认的运算顺序。

案例：

a := 10
b := 2
c := 3

// 不使用括号
result1 := a + b * c
fmt.Println("Result1:", result1) // 输出: Result1: 26，因为 b*c (2*3=6) 先于 a+ 执行

// 使用括号
result2 := (a + b) * c
fmt.Println("Result2:", result2) // 输出: Result2: 39，因为 (a+b) (10+2=12) 作为一个整体与 c 相乘