1、go语言运算符种类

运算符是一种特殊的符号，运算符用于在程序运行时执行数学或逻辑运算，用以表示数据的运算、赋值和比较等，go语言内置的运算符如下：

\1) 算术运算符

\2) 赋值运算符

\3) 比较运算符/关系运算符

\4) 逻辑运算符

\5) 位运算符

\6) 其它运算符

1.1 算数运算符

算术运算符是对数值类型的变量进行运算的，比如：加减乘除。在 Go 程序中使用的非常多

注意： ++（自增）和–（自减）在Go语言中是单独的语句，并不是运算符。

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 16
	var c int
	c = a + b
	fmt.Println("a+b=", c)
	c = a - b
	fmt.Println("a-b=", c)
	c = a * b
	fmt.Println("a*b=", c)
	c = a / b
	fmt.Println("a/b=", c)
	c = a % b
	fmt.Println("a%b=", c)
	a++ //a的值进行加一
	fmt.Println("a++=", a)
	a = 10
	a-- //a的值减一
	fmt.Println("a--=", a)
}



//输出的结果
a+b= 26
a-b= -6
a*b= 160
a/b= 0
a%b= 10
a++= 11
a--= 9

算数运算符使用细节

1、 /号使用注意事项：
如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
    fmt.Println(10 / 4)      //值是2
    var n1 float32 = 10 / 4  
    fmt.Println(n1)     //值是2
  如果我们希望保留小数部分，则需要有浮点数参与运算
    var n2 float32 = 10.0 / 4 
    fmt.Println(n2)  //值是2.5

2、 %号使用注意事项：
   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) // =1
    fmt.Println("-10%-3=", -10 % -3) // =-1

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

4、golang中自增和自减只能当作一个独立语言使用
a = i++ // 错误的写法
b = i-- //错误的写法

1.2 关系运算符

关系运算符的结果都是bool 型，也就是要么是 true，要么是 false

关系表达式经常用 if 结构的条件中或循环结构的条件中

package main

import "fmt"

func main() {
	//演示关系运算符
	var n1 int = 16
	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)  //false
	fmt.Println(n1 <= n2) //false

	flag := n1 > n2
	fmt.Println("flag=", flag)
}


//输出的结果
false
true
true
true
false
false
flag= true

package main

import "fmt"

func main() {
	var a int = 10
	var b int = 20
	if a == b {
		fmt.Printf("a等于b\n")
	} else {
		fmt.Printf("a不等于b\n")
	}
	if a < b {
		fmt.Printf("a小于b\n")
	} else {
		fmt.Printf("a不小于b\n")
	}
	if a > b {
		fmt.Printf("a大于b\n")
	} else {
		fmt.Printf("a不大于b\n")
	}
	a = 16
	b = 26
	if a <= b {
		fmt.Printf("a小于等于b\n")
	}
	if a >= b {
		fmt.Printf("a大于等于b\n")
	}

}



//输出的结果
a不等于b
a小于b
a不大于b
a小于等于b

总结：

1、关系运算符的结果都是bool型，也就是要么是true，要么是false

2、关系运算符组成的表达式，我们称之为关系表达式：a > b

3、比较运算符“==”，不能写成“=”

1.3 逻辑运算符

用于连接多个条件，最终的结果也是一个bool值

package main

import "fmt"

func main() {
	var a bool = true
	var b bool = false
	if a && b {
		fmt.Printf("第一行--条件为true\n")
	}
	if a || b {
		fmt.Printf("第二行--条件为true\n")
	}
	//修改a和b的值
	a = false
	b = true
	if a && b {
		fmt.Printf("第三行-条件为true\n")
	} else {
		fmt.Printf("第三行-条件为false\n")
	}
	if !(a && b) {
		fmt.Printf("第四行-条件为true\n")
	} else {
		fmt.Printf("第四行-条件为false\n")
	}
}


//输出的结果
第二行--条件为true
第三行-条件为false
第四行-条件为true

package main

import "fmt"

func main() {
	//演示逻辑运算符的使用&&
	//
	var age int = 30
	if age > 20 && age < 40 {
		fmt.Println("ok1")
	}
	if age > 20 && age < 30 {
		fmt.Println("ok2")
	}

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

	//演示逻辑运算符的使用 ！
	if age > 20 {
		fmt.Println("ok5")
	}
	if !(age > 20) {
		fmt.Println("ok6")
	}
}


//输出的结果
ok1
ok3
ok4
ok5

备注：

1. &&也叫短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false

2. ||也叫短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true

1.4 赋值运算符

赋值运算符是将某个运算后的值，赋值给指定的变量

package main

import "fmt"

func main() {
	var a int = 16
	var c int
	c = a
	fmt.Printf("=赋值后的c的值为%d\n", c) //16
	c += a
	fmt.Printf("+=赋值后的c的值为%d\n", c) //c=c+a=16+16=32
	c -= a
	fmt.Printf("-=赋值后的c的值为%d\n", c) //c=c-a=32-16=16
	c *= a
	fmt.Printf("*=赋值后的c的值为%d\n", c) //c=c*a=16*16=256
	c /= a
	fmt.Printf("/=赋值后的c的值为%d\n", c) //c=c/a=256/16=16
}


//输出的结果
=赋值后的c的值为16
+=赋值后的c的值为32
-=赋值后的c的值为16
*=赋值后的c的值为256
/=赋值后的c的值为16

package main

import "fmt"

func main() {
	//赋值运算符的使用演示
	//var i int
	//i = 10 //基本赋值
	//有两个变量，a和b，要求将其进行交换，最终打印结果
	//a = 6,b = 8 ==> a = 8,b = 6
	a := 6
	b := 8
	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 += 6 //a=a+6=8+6=14
	fmt.Println("a=", a)

	//赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值
	var c int
	c = a + 3 //赋值运算的执行顺序是从右向左 14+3=17
	fmt.Println("c=", c)

	var d int
	d = 6 + 2*6 //=右边的为表达式d=6+12=18
	fmt.Println("d=", d)
}


//输出的结果
交换前的情况是a = 6,b = 8
交换后的情况是a = 8,b = 6
a= 14
c= 17
d= 18

1.5 位运算符

学二进制的时候再学

1.6 其它运算符

package main

import "fmt"

func main() {

	a := 200
	fmt.Println("a的地址=", &a)

	var ptr *int = &a
	fmt.Println("ptr本身的值=", ptr)
	fmt.Println("ptr指向的值=", *ptr)

	//传统的三元运算
	//n = i > j ? i : j
	//go语言不支持三元运算，只能用如下方式实现三元运算
	var n int
	var i int = 10
	var j int = 16
	if i > j {
		n = i
	} else {
		n = j
	}
	fmt.Println("n=", n) //16
}



//输出的结果
a的地址= 0xc0000180a8
ptr本身的值= 0xc0000180a8
ptr指向的值= 200
n= 16

1.7 运算符的优先级

注意：优先级值越大，表示优先级越高。

“-*>*”是一个整体，它是用于指向结构体子数据的指针，用来取子数据

package main

import "fmt"

func main() {
	var a int = 20
	var b int = 10
	var c int = 15
	var d int = 5
	var e int

	e = (a + b) * c / d
	fmt.Println("(a+b)*c/d =", e)

	e = ((a + b) * c) / d
	fmt.Println("((a+b)*c)/d =", e)

	e = (a + b) * (c / d)
	fmt.Println("(a+b)*(c/d) =", e)

	e = a + (b*c)/d
	fmt.Println("a+(b*c)/d =", e)
}



//输出的结果
(a+b)*c/d = 90
((a+b)*c)/d = 90
(a+b)*(c/d) = 90
a+(b*c)/d = 50