学习Golang操作符指南与实例

Go语言运算符

像许多编程语言一样，Golang 支持各种内置的操作符。

Go语言中操作符的重要意义

• 操作符是用来对给定的操作数执行一些操作的字符序列。
• Go语言中的每个运算符都是单项运算符或二项运算符的类型。二进制运算符接受两个操作数，单进制运算符接受一个操作数。
• 操作符用表达式对一个或两个操作数进行操作
• 这些都是用来形成表达式的

以下是本博文中涉及的不同类型:

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位操作符
• 赋值运算符
• 地址操作符
• 其他运算符
• 操作符优先级

操作符的语法

有两种类型的运算符

• unary - 适用于单个操作数
• binary - 适用于两个操作数。

下面是一个Unary 操作符语法

下面是一个Binary 操作符语法

Operand1 Operator Operand2  

操作数是需要被操作的数据或变量。

Golang算术运算符

Arithmetic 运算符对数值进行算术计算，如加法、乘法、减法等。 假设操作数a和b的值是10,5。

符号	符号名称	用法	说明	例子
+	加法	a+b	两个数值的总和	10+5=15
-	减法	a-b	减去两个值	10-5=5
	乘法	a*b	两个数值相乘	10*5=50
	商数	a/b	操作数除以分母	10/5=2
%	模数	a%b	应用商数后的剩余部分	10%5=0
++	增量	a+=	增加一个值	10++=11
--	递减	a-	递减值为一	10-=9

四个运算符（+,-,*,/）对数字类型进行操作，如Integer 和Float,Complex 。+ 对字符串进行操作。++ 和-- 对数字类型进行操作。

以下是一个使用算术运算符的例子

package main  
  
import "fmt"  
  
func main() {  
 var a int = 100  
 var b int = 50  
 var result int  
  
 result = a + b  
 fmt.Printf("Output of Plus Operator %d\n", result)  
 result = a - b  
 fmt.Printf("Output of Minus Operator %d\n", result)  
 result = a * b  
 fmt.Printf("Output of Star Operator %d\n", result)  
 result = a / b  
 fmt.Printf("Output of Divide Operator %d\n", result)  
 result = a % b  
 fmt.Printf("Output of Remainder Operator %d\n", result)  
 a++  
 fmt.Printf("Output of Increment Operator %d\n", a)  
 a--  
 fmt.Printf("Output of Decrement Operator %d\n", a)  
}  

上述程序代码执行的输出是

Output of Plus Operator 150  
Output of Minus Operator 50  
Output of Star Operator 5000  
Output of Divide Operator 2  
Output of Remainder Operator 0  
Output of Increment Operator 101  
Output of Decrement Operator 100

Golang比较或关系运算符

Comparison 运算符用于比较表达式中的操作数，操作数可以是命名的类型，比较同一类型的操作数或同一类型的值。

这些运算符用（和）括起来，即（a==b），如果没有括起来--a==b会产生编译错误--不能在赋值中使用a==b（bool类型）作为int类型的运算符，正如下面的关键说明中提到的，任何类型的运算符都可以使用，并且这种比较的返回值是未定型的布尔值--真或假。

比较运算符的要点

• 所有的原始类型（整数、浮点数、布尔值、字符串）都可以进行比较。
• 复杂的数据类型，通道指针可以与此比较
• 接口可以比较，并返回true - 如果两个接口的动态类型、数值相同，或为nil，否则返回false
• 如果结构体可以比较并返回true--属性或字段是相等的
• 如果数组与此比较，返回true - 如果两个数组的值都相等

以下是Go内置的比较运算符的列表

符号	符号名称	用法	说明	例子
==	相同或相等	(a==b)	检查并比较两个值，如果都相等，则为真，如果都不相等，则为假	(10==5)为假
!=	不相等	(a!=b)	检查并比较两个值，真--如果两者都不相等，假--如果两者都相等	(10!=5)为真
>	大于	(a>b)	检查并比较第一个值是否大于第二个值，返回真，否则返回假	(10>5)为真
>=	大于等于	(a>=b)	检查并且第一个值大于或等于第二个值，返回真，否则返回假。	(10>=5)为真
<	小于	(a<b)	检查并且第一个值小于第二个值，返回真，否则返回假。	(11<5)为假
<=	小于等于	(a<=b)	检查并且第一个值小于等于第二个值，返回真，否则返回假。	(10<=5)为真

下面是一个Golang比较运算符的例子

package main  
  
import "fmt"  
  
func main() {  
 var a int = 100  
 var b int = 50  
 var result bool  
  
 result = (a == b)  
 fmt.Printf("1# Output of Equal Operator %t\n", result)  
 result = (a != b)  
 fmt.Printf("2# Output of Not Equal Operator %t\n", result)  
 result = (a < b)  
 fmt.Printf("3# Output of Less Than Operator %t\n", result)  
 result = (a <= b)  
 fmt.Printf("4# Output of Less Than Equal Operator %t\n", result)  
 result = (a > b)  
 fmt.Printf("5# Output of Greater Than Operator %t\n", result)  
 result = (a >= b)  
 fmt.Printf("6# Output of Greater Than Equal Operator %t\n", result)  
}  

当上述程序被编译和执行时，输出以下结果

1# Output of Equal Operator false  
2# Output of Not Equal Operator true  
3# Output of Less Than Operator false  
4# Output of Less Than Equal Operator false  
5# Output of Greater Than Operator true  
6# Output of Greater Than Equal Operator true  

Golang逻辑运算符

Logical 操作符接受布尔值并返回一个布尔值。

它包含左和右操作数。如果左操作数被评估为真，右操作数将不会被评估。

这些被称为短路规则，如果两个操作数（1 && 1）都不是布尔值，就会产生无效操作的编译错误。1 && 1 (操作符&&在未定型的数字上没有定义)

以下是Go语言中支持的运算符列表。

符号	符号名称	用法	说明	例子
&&	逻辑与	(a&&b)	true - 如果两个操作数都被评估为真， false - 如果其中一个操作数被评估为假	(true&true)为真
			逻辑OR	(a		b)	true - 如果其中一个操作数被评估为真，false - 如果两个操作数都被评估为假。	(false		true)为真
!	逻辑NOT	(a!b)	与操作数的评估值相反 - 真变成假，假变成真	(!true)为假

下面是一个逻辑运算符的使用例子

package main  
  
import "fmt"  
  
func main() {  
 var operand1 bool = true  
 var operand2 bool = false  
 var result bool  
 result = (operand1 && operand2)  
 fmt.Printf("1# Output of Conditional AND Operator %t\n", result)  
 result = (operand1 || operand1)  
 fmt.Printf("2# Output of Conditional OR Operator %t\n", result)  
 result = (!operand1)  
 fmt.Printf("3# Output of Conditional NOT Operator %t\n", result)  
  
}  

编译和运行上述操作是

1# Output of Conditional AND Operator false  
2# Output of Conditional OR Operator true  
3# Output of Conditional NOT Operator false  

Golang位操作符

这些操作符用于位操作。 Go语言支持不同的位操作符。 它只对位进行操作。在位0和1上生成真表操作值

| 操作数1 | 操作数2 | 操作数1 & 操作数2 | Operand1 | Operand2 | 操作数1 ^ 操作数2 | | --- | --- | --- | --- | --- | | 0 | 0 | 0 | 0 | 0 | | 0 | 1 | 0 | 1 | 1 | | 1 | 1 | 1 | 1 | 1 | | 1 | 0 | 0 | 1 | 1 | | {< /table >}}} | | | | |

以下是Go中支持的Bitwise操作符的列表

下面是一个逻辑运算符的例子

package main    
import "fmt"  
  
func main() {  
 var operand1 uint = 10 // bits are 0000 1010  
 var operand2 uint = 5  // bits are 0000 0011  
 var result uint = 0  
  
 result = (operand1 & operand2)  
 fmt.Printf("1# Output of Bitwise AND Operator %d\n", result)  
 result = (operand1 | operand1)  
 fmt.Printf("2# Output of Bitwise OR Operator %d\n", result)  
 result = (operand1 ^ operand2)  
 fmt.Printf("3# Output of Bitwise XOR Operator %d\n", result)  
 result = (operand1 &^ operand2)  
 fmt.Printf("4# Output of AND NOT Operator %d\n", result)  
 result = (operand1 << operand2)  
 fmt.Printf("5# Output of Left Shift Operator %d\n", result)  
 result = (operand1 >> operand2)  
 fmt.Printf("6# Output of Right Shift Operator %d\n", result)  
}  
  

编译和运行上述内容是

1# Output of Bitwise AND Operator 0  
2# Output of Bitwise OR Operator 10  
3# Output of Bitwise XOR Operator 15  
4# Output of AND NOT Operator 10  
5# Output of Left Shift Operator 320  
6# Output of Right Shift Operator 0  

Golang赋值运算符

Assignment 运算符用来进行一些运算，最后将结果分配给左边的操作数。

Golang支持多个赋值运算符

下面是一个使用赋值运算符的例子

package main  
  
import "fmt"  
  
func main() {  
 var operand1 int = 10  
 var result = 0  
 result = operand1  
 fmt.Printf("1# Output of Assignment Operator %d\n", result)  
 result += operand1  
 fmt.Printf("2# Output of Addition AND Assignment Operator %d\n", result)  
 result -= operand1  
 fmt.Printf("3# Output of Subtraction AND Assignment Operator %d\n", result)  
 result *= operand1  
 fmt.Printf("4# Output of Multiply AND Assignment Operator %d\n", result)  
 result /= operand1  
 fmt.Printf("5# Output of Divide AND Assignment Operator %d\n", result)  
 result %= operand1  
 fmt.Printf("6# Output of Moudulus AND Assignment Operator %d\n", result)  
 result &= operand1  
 fmt.Printf("7# Output of Bitwise And  AND Assignment Operator %d\n", result)  
 result |= operand1  
 fmt.Printf("8# Output of Bitwise OR AND Assignment Operator %d\n", result)  
 result ^= operand1  
 fmt.Printf("9# Output of Bitwise XOR AND Assignment Operator %d\n", result)  
}  

当上述程序代码被编译和执行时，输出为

1# Output of Assignment Operator 10  
2# Output of Addition AND Assignment Operator 20  
3# Output of subtraction AND Assignment Operator 10  
4# Output of Multiply AND Assignment Operator 100  
5# Output of Divide AND Assignment Operator 10  
6# Output of Modulus AND Assignment Operator 0  
7# Output of Bitwise And  AND Assignment Operator 0  
8# Output of Bitwise OR AND Assignment Operator 10  
9# Output of Bitwise XOR AND Assignment Operator 0  

Golang地址运算符

有两个操作符与变量的地址有关
星号 * 操作符
这些都是用来给出一个变量的指针和取消指针的，它给出了一个指向某一点的指针。

安培号&操作符
这给出了一个变量的地址。它给出了保存在内存中的变量的实际位置。
下面是一个Asterisk和Ampersand操作符的例子

package main  
  
import "fmt"  
  
func main() {  
 var v1 int = 12  
 var v2 int32  
 var v3 float32  
 var v4 string  
 var v5 bool  
 var pointerVar *int  
 fmt.Printf("1# Variable Data Type %T\n", v1)  
 fmt.Printf("2# Variable Data Type %T\n", v2)  
 fmt.Printf("3# Variable Data Type %T\n", v3)  
 fmt.Printf("4# Variable Data Type %T\n", v4)  
 fmt.Printf("5# Variable Data Type %T\n", v5)  
 fmt.Printf("6# variable v1 value %d\n", v1)  
 fmt.Printf("7# Address of varible v1 %d\n", &v1)  
 pointerVar = &v1  
 fmt.Printf("8# variable pointerVar value %d\n", *pointerVar)  
 fmt.Printf("9# Address of varible pointerVar %d\n", &pointerVar)  
  
}  

上述程序的输出是

1# Variable Data Type int  
2# Variable Data Type int32  
3# Variable Data Type float32  
4# Variable Data Type string  
5# Variable Data Type bool  
6# variable v1 value 12  
7# Address of varible v1 824634048600  
8# variable pointerVar value 12  
9# Address of varible pointerVar 824634212376  

Golang操作符的优先级

在任何表达式中，多个运算符被应用，优先级决定了哪个运算符先运行的评估顺序。一元运算符比二元运算符的优先级最高。