运算符
运算符用于在程序运行时执行数学和逻辑运算
Go 语言内置的运算符有：
- 关系运算符
- 算数运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
- 其他运算符
关系运算符
| 运算符 | 描述 | 实例 (假设 a = 5, b = 3) |
|---|---|---|
== |
等于 | a == b 返回 false |
!= |
不等于 | a != b 返回 true |
> |
大于 | a > b 返回 true |
< |
小于 | a < b 返回 false |
>= |
大于等于 | a >= b 返回 true |
<= |
小于等于 | a <= b 返回 false |
代码如下：
go
package main
import "fmt"
func main() {
var a int = 12
var b int = 20
var c bool
c = a > b
fmt.Println(c) // false
c = a < b
fmt.Println(c) // true
c = a == b
fmt.Println(c) // false
c = a >= b
fmt.Println(c) // false
c = a <= b
fmt.Println(c) // true
}算数运算符
| 运算符 | 描述 | 实例 (假设 a = 5) |
|---|---|---|
+ |
相加 | a + 2 返回 7 |
- |
相减 | a - 2 返回 3 |
* |
相乘 | a * 2 返回 10 |
/ |
相除 | a / 2 返回 2 (整数除法) |
% |
取余/模 | a % 2 返回 1 |
++ |
自增 | a++ 执行后 a 变为 6 |
-- |
自减 | a-- 执行后 a 变为 4 |
注：
/除法运算符，根据数据类型不同，输出不同数据类型- float64 相除结果为普通除法
- int64 相除结果为向零取整
代码如下：
go
package main
import "fmt"
func main() {
const a int = 12
const b int = 13
var c int
c = a + b
fmt.Printf("%d + %d = %d\n", a, b, c)
c = a - b
fmt.Printf("%d - %d = %d\n", a, b, c)
c = a * b
fmt.Printf("%d * %d = %d\n", a, b, c)
c = b / a
fmt.Printf("%d / %d = %d\n", b, a, c) // 常数类型为 int 型，除法算数后向零取整，抛弃小数点后
c = a % b
fmt.Printf("%d %% %d = %d\n", a, b, c)
const d float64 = 12.12
const e float64 = 13
var f float64
f = e / d
fmt.Printf("%.2f / %.2f = %f\n", e, d, f) // 常数类型为 float 型，除法算数后带小数点后
var g int = 5
g++
fmt.Printf("g = 5,g++ = %d\n", g)
g = 5 //重新赋值
g--
fmt.Printf("g = 5,g-- = %d\n", g)
}输出：
go
12 + 13 = 25
12 - 13 = -1
12 * 13 = 156
13 / 12 = 1
12 % 13 = 12
13.00 / 12.12 = 1.072607
g = 5,g++ = 6
g = 5,g-- = 4逻辑运算符
| 运算符 | 描述 | 实例 (假设 a = true, b = false) |
|---|---|---|
&& |
逻辑与 (AND) | a && b 返回 false |
| || | 逻辑或 (OR) | a || b 返回 true |
! |
逻辑非 (NOT) | !a 返回 false |
代码如下：
go
package main
import "fmt"
func main() {
// AND(&&) 同真才真;
// OR(||) 一真则真;
// NOT(!) 假为真，真为假;
var a bool = true
var b bool = false
var c bool
c = a && b
fmt.Println(c) // false
c = a || b
fmt.Println(c) // true
a = true
b = true
c = a && b
fmt.Println(c) // true
c = a || b
fmt.Println(c) // true
a = false
b = false
c = a && b
fmt.Println(c) // false
c = a || b
fmt.Println(c) // false
a = true
b = false
c = !a
fmt.Println(c) // false
c = !b
fmt.Println(c) // true
}位运算符
| 运算符 | 描述 | 实例 (假设 a = 5, b = 3) 备注：5=0101, 3=0011 |
|---|---|---|
& |
按位与 (AND) | a & b 返回 1 (0101 & 0011 = 0001) |
| ` | ` | 按位或 (OR) |
^ |
按位异或 (XOR) | a ^ b 返回 6 (0101 ^ 0011 = 0110) |
&^ |
位清空 (AND NOT) | a &^ b 返回 4 (0101 &^ 0011 = 0100) |
<< |
左移 | a << 1 返回 10 (0101 << 1 = 1010) |
>> |
右移 | a >> 1 返回 2 (0101 >> 1 = 0010) |
代码如下：
go
package main
import "fmt"
func main() {
// 按位与(&) 两位都为1才为1;
// 按位或(|) 有一位为1则为1;
// 按位异或(^) 两位不同则为1;
// 位清空(&^) 若右位为1则左位清零;
// 左移(<<) 左移n位相当于乘以2的n次方;
// 右移(>>) 右移n位相当于除以2的n次方;
var a uint8 = 5 // 二进制: 0101
var b uint8 = 3 // 二进制: 0011
var c uint8
c = a & b
fmt.Println(c) // 1 (0001)
c = a | b
fmt.Println(c) // 7 (0111)
a = 5
b = 3
c = a ^ b
fmt.Println(c) // 6 (0110)
c = a &^ b
fmt.Println(c) // 4 (0100)
a = 2
b = 1
c = a << 1
fmt.Println(c) // 4 (2*2)
c = a >> 1
fmt.Println(c) // 1 (2/2)
a = 3
b = 2
c = a << 2
fmt.Println(c) // 12 (3*4)
c = a >> 1
fmt.Println(c) // 1 (3/2 整数除法)
}赋值运算符
| 运算符 | 描述 | 实例 (假设 a = 10, b = 3) |
|---|---|---|
= |
直接赋值 | c = a 将 a 的值赋给 c |
+= |
相加并赋值 | 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 |
&= |
按位与并赋值 | a &= b 等价于 a = a & b |
| ` | =` | 按位或并赋值 |
^= |
按位异或并赋值 | a ^= b 等价于 a = a ^ b |
&^= |
位清空并赋值 | a &^= b 等价于 a = a &^ b |
<<= |
左移并赋值 | a <<= 2 等价于 a = a << 2 |
>>= |
右移并赋值 | a >>= 2 等价于 a = a >> 2 |
代码如下：
go
package main
import "fmt"
func main() {
// 赋值运算符
// = 直接赋值
// += 相加并赋值
// -= 相减并赋值
// *= 相乘并赋值
// /= 相除并赋值
// %= 取余并赋值
var a int = 10
var b int = 3
// 直接赋值 =
var c int
c = a
fmt.Println(c) // 10
// += 相加并赋值
a = 10
a += b
fmt.Println(a) // 13 (10+3)
// -= 相减并赋值
a = 10
a -= b
fmt.Println(a) // 7 (10-3)
// *= 相乘并赋值
a = 10
a *= b
fmt.Println(a) // 30 (10*3)
// /= 相除并赋值
a = 10
a /= b
fmt.Println(a) // 3 (10/3)
// %= 取余并赋值
a = 10
a %= b
fmt.Println(a) // 1 (10%3)
}其他运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
& |
取地址 | p = &x 将 x 的地址赋给 p |
* |
指针解引用 | val = *p 获取指针 p 指向的值 |
<- |
通道操作符（发送/接收） | ch <- v 发送，v := <-ch 接收 |
. |
结构体字段选择器 | person.name 访问 name 字段 |
[] |
数组/切片索引 | arr[0] 访问第一个元素 |
() |
函数调用/强制类型转换 | add(1,2) 或 int(3.14) |
代码如下：
go
package main
import "fmt"
func main() {
// 取地址 & 和 指针解引用 *
var x int = 10
var p *int
p = &x // & 取地址
fmt.Println(p) // 内存地址
fmt.Println(*p) // 10，* 解引用
*p = 20
fmt.Println(x) // 20
// 通道操作符 <-
ch := make(chan int)
go func() {
ch <- 42 // 发送
}()
val := <-ch // 接收
fmt.Println(val) // 42
// 结构体字段选择器 .
type Person struct {
Name string
Age int
}
person := Person{Name: "张三", Age: 20}
fmt.Println(person.Name) // 张三
fmt.Println(person.Age) // 20
// 数组/切片索引 []
arr := [3]int{1, 2, 3}
fmt.Println(arr[0]) // 1
fmt.Println(arr[1]) // 2
fmt.Println(arr[2]) // 3
// 函数调用 ()
fmt.Println("Hello") // 调用函数
var pi float64 = float64(3) // 类型转换
fmt.Println(pi) // 3
}
// 这个里面有一些比较发展，后面的文章会赘述
// 例如：切片，通道，指针会单独开篇