第六章:Go语言运算符

golang-gopher.png

1. 算术运算符

运算符	描述	示例	结果
+	正数符号	+99	99
-	负数符号	-99	-99
+	加	1+99	100
-	减	99-1	98
*	乘	3*3	9
/	除	99/3	33
%	取模	9/2	1
++	自增	var i = 2 i++	3
--	自减	var i= 2 i--	1
+	字符串连接符号	"score:"+"100"	"score:100"

算术运算符只能在同一数据类型之间进行,否则会报错, int32 只能和int32 类型的数据进行算术运算

package main

import "fmt"

func main(){
    var n1 int32 = 99
    var n2 int64 = 1
    fmt.Println(n1+n2)
}

$ go run main.go
invalid operation: n1 + n2 (mismatched types int32 and int64)

Go语言中自增(++)和自减(--)只能跟在变量的后面 ,放在变量前面就是语法错误

package main

import "fmt"

func main(){
    var a int
    //正确
    a++
    fmt.Println(a)
    //syntax error: unexpected ++, expecting 
    ++a
    fmt.Println(a)
}

2. 赋值运算符

运算符	描述	示例	结果
=	赋值运算符 将右边的值赋给左边	s = x+y
+=	相加之后 赋值给左边	var s int = 99<br />s +=1 <br />//等价于<br />//s = s+1	100
-=	相减之后 赋值给左边	var s int = 99<br />s -=1 <br />//等价于<br />//s = s-1	98
*=	相乘之后 赋值给左边	var s int = 99<br />s *=10 <br />//等价于<br />//s = s *10	990
/=	相除之后 赋值给左边	var s int = 9<br />s /=3 <br />//等价于<br />//s = s / 3	3
%=	取余之后 赋值给左边	var s int = 9<br />s %=2 <br />//等价于<br />//s = 9 % 2	1
<<=	位左移后赋值
>>=	位右移后赋值
&=	按位与后赋值
^=	按位异或后赋值
|=	按位或后赋值

package main

import "fmt"

func main(){
    var n int = 32
    n <<=3
    fmt.Println("n=",n) // 256
    n >>=2
    fmt.Println("n=",n) // 64
    n1 := 64
    n1 &= 2
    fmt.Println("n1=",n1)
    n2 := 63
    n2 ^= 2
    fmt.Println("n2=",n2)
    n3 := 62
    n3 |= 2
    fmt.Println("n3=",n3)
}

$ go run main.go
n= 256
n= 64
n1= 0
n2= 61
n3= 62

3. 关系运算符

运算符	描述	示例	结果
==	相等	9==8	false
!=	不等	9==8	true
<	小于	9<8	false
>	大于	9>8	true
<=	小于等于	9<=8	false
>=	大于等于	9=>8	true

关系运算的结果都是bool型,不是true 就是false,多见于逻辑流程中

关系运算符都是二元运算符,运算符两端都需要有数据

4. 逻辑运算符

运算符	描述	示例	结果
&&	逻辑与运算符 ,都是true才为true,否则false	T(true) &&F(false)	false
||	逻辑或运算符 ,都为false才为false,否则true	T(true) || F(false)	true
!	逻辑非运算符, 最终结果取反,true的为false,false的为true	!(T(true) &&F(false))	true

逻辑运算之后的结果是一个bool类型 ,true或者false

&& 又叫做短路与 ,第一个条件为false ,则第二个条件不判断,结果就是false

|| 又叫做短路或 ,第一个条件为true ,则第二个条件不判断,结果就是true

5. 位运算符

运算符	描述
&	按位与运算符 参与运算的两数对应的二进制位相与,(同为1结果是1 ,否则是0)
|	按位或运算符 参与运算的两数对应的二进制位相或,(同为0结果是0 ,否则是1)
^	按位异或运算符 参与运算的两数对应的二进制位相异或,(二进制位相同则为0 ,不同则为1)
<<	左移运算符,左边运算数的各位二进制位全部左移若干位,高位丢弃 ,低位补零,移动n位就是乘以2的n次方
>>	右移运算符,左边运算数的各位二进制位全部右移若干位,移动n位就是除以2的n次方

package main

import "fmt"

func main() {
    var n1 uint = 9
    var n2 uint = 3
    fmt.Printf("%08b\n", n1)        //              00001001
    fmt.Printf("%08b\n", n2)        //              00000011
    fmt.Printf("%08b\n", n2&n1)  //  按位与运算       00000001
    fmt.Printf("%08b\n", n2|n1)  //  按位或运算       00001011
    fmt.Printf("%08b\n", n2^n1)  //  按位异或运算     00001010
    fmt.Printf("%08b\n", n1<<1)  //  左移运算符       00010010
    fmt.Printf("%08b\n", n1>>1)  //  右移运算符       00000100
}

$ go run main.go
00001001
00000011
00000001
00001011
00001010
00010010
00000100

6. 其他运算符

运算符	描述	示例	结果
&	取地址符,返回变量的实际存储地址	&x	变量x在内存中的实际地址
*	指针变量	*x	访问指针变量

package main

import "fmt"

func main() {
    var n int = 99
    fmt.Printf("n memory address = %v\n", &n)
    var p *int
    p = &n
    fmt.Printf("p memory address = %v\n", p)
    fmt.Printf("*p = %d",*p)
}

$ go run main.go
n memory address = 0xc000054080
p memory address = 0xc000054080
*p = 99