【Go 基础】运算符

运算符的分类

运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等,简单来说,运算符就是用于在程序运行时执行数学或逻辑的运算。

Go 语言内置的运算符有:

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 赋值运算符
  • 位运算符
  • 其他运算符

算术运算符

算术运算符是对数值类型的变量进行运算的,比如:加减乘除取模。
算术运算符的一览表:

运算符 运算 范例 结果
+ 正号 +3 3
- 负号 -4 -4
+ 加号 1+1 2
- 减号 1-1 0
* 3*4 12
/ 5/5 1
% 取模(取余) 7%5 2
++ 自增 a=2 a++ a=3
-- 自减 a=2 a-- a=1
+ 字符串相加 "wang" + "xiong" wangxiong

案例说明:

 // 如果参与运算的数都是整数,那么除后,去掉小数部分,保留整数部分
 fmt.Println("10/4=", 10/4) // 10/4=2
 var n1 float32 = 10 / 4
 fmt.Println(n1) // 2

 // 如果我们希望保留小数部分,则需要有浮点数参与运算
 var n2 float32 = 10.0 / 4
 fmt.Println("10.0 / 4=", n2) // 10.0 / 4=2.5

 // % 取模的使用
 // % 的公式 a % b = a - a / b * b
 fmt.Println("10%3=", 10%3) // 10%3=1
 fmt.Println("-10%3=", -10%3) // -10%3=-1 // -10 - (-10) / 3 * 3 = -10 - (-9) = -1
 fmt.Println("10%-3=", 10%-3) // 10%-3=1 //10-10 /(-3)*(-3) = 10-(-3)*(-3)=1
 fmt.Println("-10%-3=", -10%-3) // -10%-3=-1 // -10-(-10) / (-3) * (-3) = -10-(-9) = -1

 // ++ 和 -- 的使用
 var i int = 10
 i++ // 等价 i = i + 1
 fmt.Println("i=", i) // i=11
 i-- // 等价 i = i - 1
 fmt.Println("i=", i) // i=10

使用注意事项:

  • 对于除号 "/",它的整数除和小数除是有区别的:整数之间做除法时,只保留整数部分而舍弃 小数部分。 例如: x := 19/5 ,结果是 3。
  • 当对一个数取模时,可以等价 a%b=a-a/b*b , 这样我们可以看到取模的一个本质运算。
  • Go 的自增自减只能当做一个独立语言使用,不能像这样使用: a = i++a = i--
  • Go 的++-- 只能写在变量的后面,不能写在变量的前面,即:只有 a++ a-- 没有 ++a --a
// 在 go 中,++ 和 -- 只能独立使用
 var i int = 8
 var a int 
 a = i++ // 错误,i++ 只能独立使用 syntax error: unexpected ++ at end of statement
 a = i-- // 错误, i-- 只能独立使用 syntax error: unexpected -- at end of statement

 if i++ > 0 { // 错误,syntax error: i++ used as value
  fmt.Println("ok")
 }

 var i int = 1
 i++
 ++i // 错误,在 go 中没有前++ syntax error: unexpected ++, expecting )
 i-- 
 --i // 错误,在 go 中没有前-- syntax error: unexpected --, expecting )
 fmt.Println("i=", i)

问:如下代码的结果是多少?为什么?

var i int = 1
i = i++
fmt.Println(i); // unexpected ++ at end of statement
var i int = 1
if i++ > 10 {
fmt.Println("wangxiong"); // syntax error: unexpected >, expecting {
 }

Go 的自增自减只能当做一个独立语言使用。

问:假如还有 100 天放假,还剩多少个星期零多少天?

package main
import "fmt"
func main() {
 var days int = 100
 var week int = days / 7
 var day int = days % 7
 fmt.Printf("假如还有%d天放假,还剩%d个星期零%d天。", days, week, day)
 // 假如还有100天放假,还剩14个星期零2天。
}

问:请求出华氏温度对应的摄氏温度,华氏温度转换摄氏温度的公式为:5/9*(华氏温度-100)。

package main
import "fmt"
func main() {
 // 请求出华氏温度对应的摄氏温度,华氏温度转换摄氏温度的公式为:5/9*(华氏温度-100)
 var fahrenheit float32 = 165.7
 var celsius float32 = 5.0 / 9 * (fahrenheit - 100)
 fmt.Printf("%v 对应的摄氏温度=%v \n", fahrenheit, celsius) // 165.7 对应的摄氏温度=36.5
}

需要注意的是,上述5.0不能写为5,否则除法运算无法保留小数运算,会使得所有对应的摄氏温度结果为0。

关系运算符

关系运算符也叫比较运算符,其结果都是 bool 型,也就是要么是 true,要么是 false

运算符 运算 范例 结果
== 等于 4==3 false
!= 不等于 4!=3 true
< 小于 4<3 false
> 大于 4>3 true
>= 大于等于 4>=3 true
<= 小于等于 4<=3 false

示例说明:

// 关系运算符的使用
 var n1 int = 9
 var n2 int = 8
 fmt.Println(n1 == n2) // false
 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) // flag=true

使用注意事项:

  • 关系运算符的结果都是 bool 型,也就是要么是 true,要么是 false
  • 关系运算符组成的表达式,我们称为关系表达式: a > b
  • 比较运算符"=="不能误写成 "=" !!

逻辑运算符

用于连接多个条件(一般来讲就是关系表达式),最终的结果也是一个 bool 值。

运算符 描述 实例
&& 逻辑 AND 运算符,如果两边的操作数都是 true,则条件 true,否则为 False。 (true && false) 为 false
\|\| 逻辑 OR 运算符,如果两边的操作数有一个 true,则条件 true,否则为 False。 (true \|\| false) 为 true
! 逻辑 NOT 运算符,如果条件为 true,则逻辑 NOT 条件 false,否则为 true。 !(true && false) 为 true

示例说明:

package main
import "fmt"
func test() bool {
 return true
}
func main() {
 // && 短路与,如果第一个条件为false,则第二个条件不会判断,最终结果为false
 var i int = 10
 if i < 9 && test() {
  fmt.Println("ok...") // 不执行
 }
 // || 短路或,如果第一个条件为true,则第二个条件不会判断,最终结果为true
 if i > 9 || test() {
  fmt.Println("hello...") // hello...
 }

 // 逻辑运算符 && 的使用
 var age int = 40
 if age > 30 && age < 50 {
  fmt.Println("ok1") // ok1
 }
 if age > 30 && age < 40 {
  fmt.Println("ok2") // 不执行
 }

 // 逻辑 || 运算符的使用
 if age > 30 || age < 50 {
  fmt.Println("ok3") // ok3
 }

 if age > 30 || age < 40 {
  fmt.Println("ok4") // ok4
 }

 // 逻辑 ! 运算符的使用
 if age > 30 {
  fmt.Println("ok5") //ok5
 }

 if !(age > 30) {
  fmt.Println("ok6") // 不执行
 }
}

注:

  • && 短路与,如果第一个条件为false,则第二个条件不会判断,最终结果为false。
  • || 短路或,如果第一个条件为true,则第二个条件不会判断,最终结果为true。

赋值运算符

下表列出了Go语言所有的赋值运算符:

运算符 描述 实例
= 简单的赋值运算符,将一个表达式的值赋给一个左值 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
<<= 左移后赋值 C <<= 2 等于 C = C << 2
>>= 右移后赋值 C >>= 2 等于 C = C >> 2
&= 按位与后赋值 C &= 2 等于 C = C & 2
^= 按位异或后赋值 C ^= 2 等于 C = C ^ 2
|= 按位或后赋值 C|= 2 等于 C = C | 2

示例说明:

// 交换两个变量
 a := 9
 b := 2
 fmt.Printf("交换前的情况是 a = %v , b=%v \n", a, b) // 交换前的情况是 a = 9 , b=2
 // 临时变量
 t := a
 a = b
 b = t
 fmt.Printf("交换后的情况是 a = %v , b=%v \n", a, b) // 交换后的情况是 a = 2 , b=9

 // 复合赋值
 a += 17 // 等价 a = a + 17
 fmt.Println("a=", a) // a= 19

 var c int
 c = a + 3 // 赋值运算的执行顺序是从右向左
 fmt.Println("c=", c) // c=22

 // 赋值运算符的左边只能是变量,右边可以是变量、表达式(任何有值都可以看做表达式)、常量值
 var d int
 d = a //
 d = 8 + 2*8 // 变量的右边是表达式
 d = true + 90 // 变量的右边是表达式, invalid operation: true + 90 (mismatched types bool and int)
 fmt.Println("d=", d) // 报错

使用注意事项:

  • 赋值运算符的执行顺序是从右向左。
  • 赋值运算符的左边只能是变量,右边可以是变量、表达式、常量值。

问:不使用临时变量,交换两个变量的值?

func main() {
 // 交换两个变量
 a := 9
 b := 2
 fmt.Printf("交换前的情况是 a = %v , b=%v \n", a, b) // 交换前的情况是 a = 9 , b=2
 a = a + b
 b = a - b // a + b - b
 a = a - b // a + b - b
 fmt.Printf("交换后的情况是 a = %v , b=%v \n", a, b) // 交换后的情况是 a = 2 , b=9
}

运算符的优先级

分类 描述 关联性
后缀 () [] -> . ++ -- 左到右
单目 + - ! ~ (type) * & sizeof 右到左
乘法 * / % 左到右
加法 + - 左到右
移位 << >> 左到右
关系 < <= > >= 左到右
相等 == != 左到右
按位AND & 左到右
按位XOR ^ 左到右
按位OR | 左到右
逻辑AND && 左到右
逻辑OR || 左到右
赋值 = += -= *= /= %= >>= <<= &= ^= |= 右到左
逗号 , 左到右

注意事项:

  • 运算符有不同的优先级,所谓优先级就是表达式运算中的运算顺序。如上表,上一行运算符总优先于下一行。
  • 只有单目运算符、赋值运算符是从右向左运算的。

其他运算符

运算符 描述 实例
& 返回变量存储地址 &a 将给出变量的实际地址
* 指针变量 *a 是一个指针变量

示例说明:

// &a 将给出变量的实际地址
 a := 100
 fmt.Println("a 的地址=", &a) // a 的地址= 0xc000018178

 // *ptr 是一个指针变量
 var ptr *int = &a
 fmt.Println("ptr 指向的值是=", *ptr) // ptr 指向的值是= 100

 var n int
 var i int = 10
 var j int = 12
 // 传统的三元运算 n = i > j ? i : j
 if i > j {
  n = i
 } else {
  n = j
 }
 fmt.Println("n=", n) // n= 12

Go 中不支持三元运算符,原因是Go的设计理念,一种事情有且只有一种最佳的解决办法完成。

相关推荐

微信扫一扫,分享到朋友圈

【Go 基础】运算符
返回顶部

显示

忘记密码?

显示

显示

获取验证码

Close