一.运算符介绍
运算符是一种特殊的符号，用以表示的数据的运算、复制和比较等。
go没有三元运算符。
1）算术运算符
2）赋值运算符
3）比较运算符/关系运算符
4）逻辑运算符
5）位运算符
6）其他运算符
1.算术运算符
算术运算符主要是对数值类型的变量进行运算的，比如：加减乘除。在Go程序中使用的非常多。
算术运算符一览
| 运算符 |
运算 |
范例 |
结果 |
| + |
正号 |
+3 |
3 |
| - |
负号 |
-4 |
-4 |
| + |
加 |
5+5 |
10 |
| - |
减 |
6-4 |
2 |
| * |
乘 |
3*4 |
12 |
| / |
除 |
5/5 |
1 |
| % |
取模 |
7%5 |
2 |
| ++ |
自增 |
a=2 a++ |
a=3 |
| -- |
自减 |
a=2 a-- |
a=1 |
| + |
字符串相加 |
“he”+”llo” |
“hello” |
代码例子如下：
package main
import "fmt"
func main() {
// 运算符举例
var a int = 21
fmt.Println(+1)
fmt.Println(-1)
fmt.Println(5 + 5)
fmt.Println(5 - 3)
fmt.Println(3 * 4)
fmt.Println(6 / 3)
// 除法使用的特点:
// 说明： 如果运算的数都是整数，那么除后，去掉小数部，保留整数部分
fmt.Println(10 / 4)
var n1 float32 = 10 / 4
fmt.Println(n1)
// 如果我们希望保留小数部分，则需要有浮点数参与运算
var n2 float32 = 10.0 / 4
fmt.Println(n2)
// 取模使用的特点：
// 取模公式如下：a % b = a - a / b * b
fmt.Println("10模3等于 ：", 10%3) // 1
fmt.Println("-10模3等于 ：", -10%3) // = -10 - (-10) / 3 * 3 = -10 - (-9) = -1
fmt.Println("10模-3等于 ：", 10%-3) // = 10 - 10/(-3)*(-3) = 10 - 9 = 1
fmt.Println("-10模-3等于：", -10%-3) // = -10 - （-10）/(-3)*(-3) = -10 + 9 = -1
a--
fmt.Printf(" a 的值为 %d\n", a)
a = 21 // 为了方便测试，a 这里重新赋值为 21
a++
fmt.Printf(" a 的值为 %d\n", a)
}
（1）算术运算符的细节说明
1.对于除号”/”，它的整数除和小数除是有区别的：整数之前做除法时，只保留整数部分而舍弃小数部分。例如： x := 19/5 ,结果是 3 （去掉小数部分）
2.当对一个数取模时，可以等价a%b=a-a/b*b
3.Golang的自增自减只能当做一个独立语言时，不能这样使用[和其他语言有区别，注意]
b := a ++ 或者 b ：= a-- 并且没有 ++a 或 -- a
4.Golang的设计者去掉c/java中的自增自减容易混淆的写法。
练习题1：// 假如还有97天，问：**个星期零**天
package main
import (
"fmt"
)
func main() {
// 假如还有97天，问：**个星期零**天
var days int = 97
var week int = days / 7
var day int = days % 7
fmt.Printf("%d个星期零%d天\n", week, day)
}
练习题2：
package main
import (
"fmt"
)
func main() {
// 定义一个变量保存华氏温度，华氏温度转换摄氏度的公式为：
// 5/9*(华氏温度-100)，请求出华氏温度对应的摄氏温度
// 注意当一个整数除以另外一个比它的整数的时候，go中等于0，除非使用小数才会得出小数
var huashi float32 = 134.2
var sheshi float32 = 5.0 / 9 * (huashi - 100)
fmt.Println("摄氏温度为：", sheshi)
}
2.关系运算符（比较运算符）
1）关系运算符的结果都是bool类型，也就是要么是true，要么是false
2) 关系表达式经常用在if结构的条件中或循环结构的条件中
| 运算符 |
运算 |
范例 |
结果 |
| == |
相等于 |
4==3 |
false |
| != |
不等于 |
4!=3 |
true |
| < |
小于 |
4<3 |
false |
| > |
大于 |
4>3 |
true |
| <= |
小于等于 |
4<=3 |
false |
| >= |
大于等于 |
4>=3 |
true |
举例代码例子：
package main
import (
"fmt"
)
func main() {
// 演示关系运算符的使用
var n1 int = 9
var n2 int = 8
fmt.Println(n1 == n2) // flase
fmt.Println(n1 != n2) // true
fmt.Println(n1 > n2) // true
fmt.Println(n1 >= n2) // true
fmt.Println(n1 < n2) // flase
fmt.Println(n1 <= n2) // flase
flag := n1 > n2
fmt.Println("flag=", flag)
}
（1）关系运算符的细节说明
1.关系运算符组成的表达式，我们称为关系表达式：a>b
2.比较运算符”==” 不能误写为”=”
3.逻辑运算符
假定A值为True,B值为False。
| 运算符 |
描述 |
结果 |
| && |
逻辑与运算符。如果两边的操作数都是True,则为True,否则为False |
(A&&B) 为False |
| || |
逻辑或运算符。如果两边的操作数有一个True,则为True,否则为False |
(A||B) 为True |
| ! |
逻辑非运算符。如果条件为True,则逻辑为false,否则为True |
!(A&&B) 为True |
逻辑运算举例：
package main
import (
"fmt"
)
func main() {
// 逻辑运算符的使用 &&
var age int = 40
if age > 30 && age < 50 {
fmt.Println("ok1") // 执行
}
if age > 30 && age < 40 {
fmt.Println("ok2") // 不执行
}
if age > 30 || age < 50 {
fmt.Println("ok3") // 执行
}
if age > 30 || age < 40 {
fmt.Println("ok4") // 执行
}
if !(age > 30 && age < 50) {
fmt.Println("ok5") // 不执行
}
if !(age > 30 && age < 40) {
fmt.Println("ok6") // 执行
}
}
（1）逻辑运算符的细节说明
1.&&也叫短路与：如果第一个条件为False,则第二个条件不会判断，最终结果为False。
2.||也叫短路或 ：如果第一个条件为True,则第二个条件不会判断，最终结果为True。
举例：
package main
import (
"fmt"
)
func test() bool {
fmt.Println("test ok....")
return true
}
func main() {
var i int = 10
fmt.Println("test01=========")
if i > 9 && test() {
fmt.Println("0k...")
} // 这个先打印 test ok .... 再打印 ok...
fmt.Println("test02==========")
if i < 9 && test() {
fmt.Println("0k...")
} // 不打印 短路与现象
fmt.Println("test03========")
if i > 9 || test() {
fmt.Println("0k...")
} // 只打印ok 短路或现象
fmt.Println("test04========")
if i < 9 && test() {
fmt.Println("0k...")
} // 这个先打印 test ok .... 再打印 ok...
}
4.赋值运算符
赋值运算符就是将某个运算后的值，赋给指定的变量。
| 运算符 |
描述 |
结果 |
| = |
简单的赋值运算符，将右表达式赋给左值 |
C = A+B将A+B表达式赋值给C |
| += |
相加后再赋值 |
C+=A 等于C = C + A |
| -= |
相减后再赋值 |
C-=A 等于C = C - A |
| *= |
相乘后再赋值 |
C*=A 等于C = C * A |
| /= |
相处后再赋值 |
C/=A 等于C = C / A |
| %= |
求余后再赋值 |
C%=A 等于C = C % A |
赋值运算举例：
package main
import "fmt"
func main() {
// 赋值运算符的使用演示
var i int
i = 10 // 基本赋值
fmt.Println(i)
// 有两个变量，a和b ,要求将其进行交换，最终打印结果
// a = 9， b = 2 ===> a = 2 b = 9
a := 9
b := 2
fmt.Printf("交换前的情况是a=%v,b=%v\n", a, b)
// 定义一个临时变量
t := a
a = b
b = t
fmt.Printf("交换后的情况是a=%v,b=%v\n", a, b)
// 复合赋值操作
a += 17
fmt.Println(a)
}
（1）赋值运算符的细节说明
1.运算顺序从右到左
2.赋值运算符的左边，只能是变量，右边可以是变量、表达式、常量
3.复合赋值运算符等价于下面的效果
[如：a+=3 等价于 a = a + 3]
举例1：
package main
import "fmt"
func test() int {
return 1
}
func main() {
//
var c int = 5
var d int
d = c + 3 // 赋值运算的执行顺序是从右向左
fmt.Println(d) // 8
// 赋值运算符的左边，只能是变量，右边可以是变量、表达式、常量
var e int
e = c
fmt.Println(e) // 5
e = 8 + c * 2
fmt.Println(e) // 18
e = test() + 90
fmt.Println(e) // 91
e = 900
fmt.Println(e) // 900
}
举例2：
package main
import "fmt"
func test() int {
return 1
}
func main() {
// 有两个变量，a和b ,要求将其进行交换，但不允许使用中间变量，最终打印结果
var a int = 6
var b int = 5
fmt.Printf("开始值：a=%v,b=%v\n",a,b)
a = a + b
b = a - b
a = a - b
fmt.Printf("交换后：a=%v,b=%v\n",a,b)
5.位运算符与移运算符
| 运算符 |
描述 |
| & |
按位与运算符”&”是双目运算符。其功能是参与运算的两数各对应的二进位相与。 运算规则是： 同时为1结果为1 ，否则为0 |
| | |
按位或运算符”|”是双目运算符。其功能是参与运算的两束各对应的二进位相或 运算规则是：有一个为1，结果为1，否则为0 |
| ^ |
按异或运算符”^” 是双目运算符。其功能是参与运算的两数各对应的二进制位相异或。 运算规则是：当二进位不同时，结果为1，否则为0。 |
| << |
左移运算符”<<” 是双目运算符。其功能把”<<” 左边的运算数的各二进位全部左移若干位，高位丢弃，低位补0。左移补0.左移n位就是乘以2的n次方。 |
| >> |
右移运算符”<<” 是双目运算符。其功能把”<<” 右边的运算数的各二进位全部右移若干位，高位丢弃，低位补0。右移补0。右移n位就是乘以2的n次方。 |
举例1：
package main
import "fmt"
func main() {
// 移运算例子
var a int = 1 >> 2
var b int = -1 >> 2
var c int = 1 << 2
var d int = -1 << 2
// a,b,c,d结果是什么
fmt.Println("a=",a)
fmt.Println("b=",b)
fmt.Println("c=",c)
fmt.Println("d=",d)
}
举例2：
ackage main
import "fmt"
func main() {
// 位运算例子
// 二进制的补码的运算
fmt.Println(2&3)
fmt.Println(2|3)
fmt.Println(13&7)
fmt.Println(5|4)
fmt.Println(-3^3)
6.其他运算符
| 运算符 |
描述 |
实例 |
| & |
返回变量存储地址 |
&a ;将给出变量的实际地址 |
| * |
指针变量 |
*a ; 是一个指针变量 |
举例：
package main
import "fmt"
func main() {
// 演示 & 和 * 的使用
a := 200
fmt.Println("a的地址=",&a)
var ptr *int = &a
fmt.Println("ptr指向的值是=",*ptr)
}
特别说明：
GO语言明确不支持三目运算。只能用if else代替。
GO的设计理念：
一种事情有且只有一种方法完成。
二．运算符的优先级
1）运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行。
2）只有单目运算符、赋值运算符是从右向左运算的
3）大致的顺序整理
1.括号，++ ，--
2.单目运算
3.算术运算符
4.移位运算
5.关系运算符
6.位运算符
7.逻辑运算符
8.赋值运算符
9.符号
| 分类 |
描述 |
关联性 |
| 后缀 |
()、[]、->、++、-- |
左到右 |
| 单目 |
+ - ！ ~ (type) * & sizeof |
右到左 |
| 乘法 |
* / % |
左到右 |
| 加法 |
+ - |
左到右 |
| 移位 |
<< >> |
左到右 |
| 关系 |
< <= > >= |
左到右 |
| 相等（关系） |
== ！= |
左到右 |
| 按为AND |
& |
左到右 |
| 按为XOR |
^ |
左到右 |
| 按为OR |
| |
左到右 |
| 逻辑AND |
&& |
左到右 |
| 逻辑OR |
|| |
左到右 |
| 赋值运算符 |
= += -= *= /= %= >>= <<= &= ^= |= |
右到左 |
| 符号 |
, |
左到右 |
上表优先级从上到下，从高到低。