1 运算符分类

1 算数运算符：+,-,*,/,%,++,--
2 赋值运算符：=,+=,-=,*=,/=,%=
3 关系运算符：==,!=,<,>,<=,>=
4 逻辑运算符：&&,||,!
5 位运算符：&,|,^,<<,>>
6 其他运算符：&,*

2 算数运算符：

2.1 ”+“示例

package main

import "fmt"

func main() {
	//"+" 可以表示正数
	var x = +4
	fmt.Println(x)
	//"+" 可以表示加法运算
	var y = 3 + 4
	fmt.Println(y)
	//"+" 可以表示加法运算
	var str1 = "hello" + " word!"
	fmt.Println(str1)
}

-------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
4
7
hello word!
PS C:\Goproject\src\gocode\project01\main> 

2.2 ”/“ 示例

package main

import "fmt"

func main() {
	//两个int类型的数据运算结果一定为整数型
	var x = 10 / 3
	fmt.Println(x)
	//浮点类型数据参与的运算结果为浮点型
	var y = 10.00 / 3
	fmt.Println(y)
}

---------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
3
3.3333333333333335
PS C:\Goproject\src\gocode\project01\main> 

2.3 "%" 示例

package main

import "fmt"

func main() {
	//"%"取余，必须为整数型
	var x = 15 % 6
	fmt.Println(x)

	fmt.Println(-15 % 6)
	fmt.Println(-15 % -6)
	fmt.Println(15 % -6)
}

-------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
3
-3
-3
3
PS C:\Goproject\src\gocode\project01\main> 

2.4 ”++“示例

package main

import "fmt"

func main() {
	//"++" 自增 加1操作  "--" 自减 减1操作
	//go语言中 ++,-- 只能写在变量的后面，++a，--a都是错误写法
	var a int = 5
	a++
	fmt.Println(a)
	a--
	fmt.Println(a)

}

----------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
6
5
PS C:\Goproject\src\gocode\project01\main> 

3 赋值运算符

3.1 ”+=“和”/=“ 示例

package main

import "fmt"

func main() {

	var a int = 5
	a += 3 //等价于a = a+3
	fmt.Println(a)
	a /= 4 //等价于 a = a/4
	fmt.Println(a)

}

-----------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
8
2
PS C:\Goproject\src\gocode\project01\main> 

4 关系运算符

1. 关系运算符的结果都是bool类型（true、false）

2. 关系运算符常在流程控制中使用

4.1 示例

package main

import "fmt"

func main() {

	var a int = 5
	b := 6
	fmt.Println("a =", a, "; b =", b)
	fmt.Println("a >  b", a > b)
	fmt.Println("a <  b", a < b)
	fmt.Println("a == b", a == b)
	fmt.Println("a != b", a != b)
	fmt.Println("a <= b", a <= b)
	fmt.Println("a >= b", a >= b)
}

----------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
a = 5 ; b = 6
a >  b false
a <  b true 
a == b false
a != b true 
a <= b true 
a >= b false
PS C:\Goproject\src\gocode\project01\main> 

5 逻辑运算符

5.1 示例

package main

import "fmt"

func main() {
	fmt.Println(true && false)
	fmt.Println(true || false)
	fmt.Println(true && true)
	fmt.Println(!true)
}

-------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
false
true 
true
false
PS C:\Goproject\src\gocode\project01\main>

6 位运算符

位运算符是对数据转换为二进制后某个位上的数进行的运算，各个语言中都有位运算符，Golang也不例外，由于位运算符的执行效率比较高，在实际开发过程中也都有使用.

6.1 位运算符（逻辑）

& --- 当两个操作位上值均为1时，结果为1，其余结果一概为0 （与 理解：全为真才是真）
| --- 当两个操作位上值均为0时，结果为0，其余结果一概为1 （或 理解：有一真就为真）
^ --- 当两个操作位上值相同时，结果为0，其余结果为1  （理解：相同就是假，不同才为真）

无符号整数8  二进制 1000  
无符号整数12 二进制 1100
8 & 12的结果 二进制 1000 = 8
8 | 12的结果 二进制 1100 = 12
8 ^ 12的结果 二进制 0100 = 4

无符号整数8  二进制 1000  
无符号整数4  二进制 0100
8 & 4的结果  二进制 0000 = 0
8 | 4的结果  二进制 1100 = 12
8 ^ 4的结果  二进制 1100 = 12

package main

import "fmt"

func main() {

	fmt.Println(8 & 12)
	fmt.Println(8 | 12)
	fmt.Println(8 ^ 12)
	fmt.Println("")
	fmt.Println(8 & 4)
	fmt.Println(8 | 4)
	fmt.Println(8 ^ 4)
}
------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
8
12
4 
  
0 
12
12
PS C:\Goproject\src\gocode\project01\main> 

6.2 位运算符（位移）

相关：golang语言中负数在计算机中存储的是补码
https://www.cnblogs.com/du-z/p/17648638.html

<< : 左移即在二进制中将所有的"1"向左移n位；遵循高位溢出舍去，低位用"0"补齐；
>> : 右移即在二进制中将所有的"1"向右移n位；遵循低位溢出舍去，高位用符号位补齐（负数补1，正数补0）；

int8类型 二进制 01010101  a= +85 
int8类型 二进制 11010101  b= 符号位为1所以为负数，此码为补码，取反码(-1)： 1010100  原码：0101011  值：-43
a << 3   二进制 10101000  符号位为1所以为负数，此码为补码，取反码(-1)： 0100111  原码：1011000  值：-88
a >> 3   二进制 00001010  值为：10 
b >> 3   二进制 11111010  符号位为1所以为负数，此码为补码，取反码(-1)： 1111001  原码：0000110  值：-6

package main

import "fmt"

func main() {
	var a int8 = +85
	var b int8 = -43

	fmt.Println(a << 3)
	fmt.Println(a >> 3)
	fmt.Println(b >> 3)

}

---------------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
-88
10
-6
PS C:\Goproject\src\gocode\project01\main> 

7 指针--派生数据类型

7.1 基本介绍

1. 变量表示内存中的一个存储区域，该区域有自己的名称（变量名）、类型（数据类型）和（值）
2. 指针变量存的值是某个其他变量的存储区域的地址
3. 指针变量的声明方式： var  ptr *int = xxxxxxxxxxxx

8 其他运算符(& 和 *)

1. &：返回变量的存储地址
1. *：取指针内存地址变量对应的值

8.1 示例

8.1.1 查看内存地址和值

package main

import "fmt"

func main() {
	//定义一个变量a
	var a int = 8
	//取出变量a的内存地址
	var ptr *int = &a
	fmt.Println("a的内存地址为:", ptr)
	//通过内存指针地址取变量值
	fmt.Println("ptr内存地址的变量值为:", *ptr)

}

------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
a的内存地址为: 0xc000012088
ptr内存地址的变量值为: 8
PS C:\Goproject\src\gocode\project01\main> 

8.1.2 通过指针变量修改原变量的值

package main

import "fmt"

func main() {
	var a int = 9
	fmt.Printf("a address= %v\n", &a)

	var ptr *int
	ptr = &a
	*ptr = 10
	//这里修改后相当于修改了变量a，a的内存地址不变
	fmt.Println(a)
	fmt.Printf("a address= %v\n", &a)
}

-----------------输出
PS C:\Goproject\src\gocode\project01\main> go run .\test.go
a address= 0xc000012088
10
a address= 0xc000012088
PS C:\Goproject\src\gocode\project01\main> 

链接：https://www.cnblogs.com/du-z/p/17650801.html

（版权归原作者所有，侵删）