Golang运算子范例| Go运算符教程

Golang运算符是一个符号，告诉编译器执行特定的数学或逻辑操作。 Go语言具有丰富的内置运算符，并提供以下类型的运算符。 Golang运算符是任何编程语言的基础。如果不使用运算符，Go语言的功能是不完整的。运算符允许我们对操作数执行各种运算。在Go语言中，可以根据操作员的不同功能对其进行分类。

Golang运算子

内容概述

• 1位Golang运算子
• 2个算术运算符
• 3个关系或比较运算符
• 4个逻辑运算符
• 5位运算符
• 6个赋值运算符
• 7名其他操作员
• 8结论
• 9另请参见

运算符是告诉编译器执行特定操作的令牌，这些操作可以是数学的，关系的或逻辑的。 Golang语言具有内置的运算符，可以将其分为以下几类。

1. 算术运算符
2. 关系运算符
3. 逻辑运算符
4. 按位运算符
5. 杂项运算符

算术运算符

这些用于对Golang中的操作数执行算术运算符。

操作员	描述	例
+	加两个操作数	X + Y给出21
–	从第一个减去第二个操作数	X – Y给出-11
*	将两个操作数相乘	X * Y给出100
/	分子除以分母。	Y / X给出29
％	模运算符在整数除法后给出余数。	Y％X给出0
++	增量运算符。它将整数值增加一。	X ++给出11
—	递减运算符。它将整数值减一。	X– 90

-，+，，＆，*，<-和^也称为一元运算符，一元运算符的优先级更高。 ++和—运算符来自语句，它们不是表达式，因此不在运算符层次结构中。

请参见以下代码示例。

// hello.go

package main

import "fmt"

func main() {
	var p int = 23
	var q int = 60
	fmt.Println(p + q)
}

输出量

go run hello.go
40

关系运算符或比较运算符

下表列出了Golang支持的所有比较运算符。假设变量X保持11，变量Y保持21。

操作员	描述	例
==	它检查两个操作数的值是否相等。如果是，则条件变为真。	（X == Y）不正确。
=	它检查两个操作数的值是否相等。如果不相等，则条件变为真。	（X= Y）为真。
>	它检查左操作数的值是否大于右操作数的值；如果是，则条件变为真。	（X> Y）不正确。
<	它检查左操作数的值是否小于右操作数的值；如果是，则条件成立。	（X
> =	它检查左操作数的值是否大于或等于右操作数的值；如果是，则条件成立。	（X> = Y）不正确。
<=	它检查左操作数的值是否小于或等于右操作数的值；如果是，则条件成立。	（X <= Y）为真。

请参见以下关系运算符的代码示例。

// hello.go

package main

import "fmt"

func main() {
	var k int = 21
	var b int = 19

	if k != b && k <= b {
		fmt.Println("1st True")
	}

	if k != b || k <= b {
		fmt.Println("2nd True")
	}

	if !(k == b) {
		fmt.Println("3rd True")
	}

}

输出量

go run hello.go
2nd True
3rd True

关键点

1. 布尔，整数，浮点数，复数值和字符串相等。
2. 字符串按字节顺序按词法排序。
3. 如果两个指针指向同一个变量，或者两个指针均为零，则它们相等。
4. 如果两个通道的值是通过相同的make调用构建的，或者两个值均为零，则它们相等。
5. 如果两个接口值具有相同的动态类型和相等的具体值，或者两个均为零，则它们相等。

逻辑运算符

逻辑运算符用于组合两个或多个条件/约束或补充对原始条件的评估。

1. 逻辑AND：当同时考虑到两个条件时，'&&'运算符将返回布尔True。否则，它返回false。例如，当a和b都为True（即非零）时，&& b返回True。
2. 逻辑或：'||'运算符在满足所考虑的一个或两个条件时返回True。否则，它返回False。例如，||如果a或b中的一个为True（即非零），则b返回True。当然，当a和b均为True时，它将返回true。
3. 逻辑非：如果考虑的条件不满足，“”（NOT）运算符将返回True。否则，它返回false。例如，如果a为False，即a = 0时，a返回true。

请参见以下逻辑运算符的代码示例。

// hello.go

package main

import "fmt"

func main() {
	var x int = 11
	var y int = 21

	if x != y && x >= y {
		fmt.Println("1st True")
	}

	if x != y || x <= y {
		fmt.Println("2nd True")
	}

}

输出量

go run hello.go
2nd True

按位运算符

按位运算符对位进行运算并执行逐位运算。

＆，|和^的真值表如下。

1. ＆（按位与）：它接受两个数字作为操作数，并对两个数字的每一位进行“与”运算。仅当两个位均为1时，AND的输出才为1。
2. | （按位或）：它接受两个数字作为操作数，并对两个数字的每一位进行“或”运算。 OR的输出为1，两位中的任意一位为1。
3. ^（按位XOR）：它接受两个数字作为操作数，并对两个数字的每一位进行XOR。如果两个位不同，则XOR的输出为1。
4. <<（左移）：需要两个数字，左移第一个操作数的位，第二个操作数确定要移数的位置。
5. >>（右移）：需要两个数字，右移第一个操作数的位，第二个操作数确定要移数的位。
6. ＆^（AND NOT）：＆^是位清晰的运算符。

请参阅以下Go中按位运算符的代码示例。

// hello.go

package main

import "fmt"

func main() {
	p := 19
	k := 21

	// & (bitwise AND)
	op1 := p & k
	fmt.Printf("Result of p & k = %d", op1)

	// | (bitwise OR)
	op2 := p | k
	fmt.Printf("nResult of p | k = %d", op2)

	// ^ (bitwise XOR)
	op3 := p ^ k
	fmt.Printf("nResult of p ^ k = %d", op3)

	// << (left shift)
	op4 := p << 1
	fmt.Printf("nResult of p << 1 = %d", op4)

	// >> (right shift)
	op5 := p >> 1
	fmt.Printf("nResult of p >> 1 = %d", op5)

	// &^ (AND NOT)
	op6 := p &^ k
	fmt.Printf("nResult of p &^ k = %d", op6)

}

输出量

go run hello.go
Result of p & k = 17
Result of p | k = 23
Result of p ^ k = 6
Result of p << 1 = 38
Result of p >> 1 = 9
Result of p &^ k = 2

赋值运算符

请参阅以下赋值运算符。

操作员	描述	例
=	它是一个简单的赋值运算符，将值从右侧操作数分配到左侧操作数。	Z = X + Y将X + Y的值赋给Z
+ =	它添加AND赋值运算符，将右操作数添加到左操作数，并将结果分配给左操作数。	Z + = X等效于Z = X + Y
-=	它减去AND赋值运算符，从左边的操作数减去右边的操作数，然后将结果赋给左边的操作数。	Z-= X等效于Z = Z – X
* =	它将AND运算符相乘，将右操作数与左操作数相乘并将结果分配给左操作数。	Z * = X等效于Z = Z * X
/ =	将AND运算符相除，将左操作数除以右操作数，并将结果分配给左操作数。	Z / = X等效于Z = Z / X
％=	模AND赋值运算符，它使用两个操作数获取模数，并将结果分配给左操作数。	Z％= X等于Z = Z％X
<< =	左移AND赋值运算符。	Z << = 2与Z = Z << 2相同
>> =	右移和赋值运算符。	Z >> = 2与Z = Z >> 2相同
＆=	按位与赋值运算符。	Z＆= Z与Z = Z＆2相同
^ =	按位异或和赋值运算符。	Z ^ = 2与Z = Z ^ 2相同
| =	按位或（OR）和赋值运算符。	Z | = 2与Z = Z |相同2

请参见以下赋值运算符的代码示例。

// hello.go

package main

import "fmt"

func main() {
	var x int = 19
	var y int = 21

	// “=”(Simple Assignment)
	x = y
	fmt.Println(x)

	// “+=”(Add Assignment)
	x += y
	fmt.Println(x)

	//“-=”(Subtract Assignment)
	x -= y
	fmt.Println(x)

	// “*=”(Multiply Assignment)
	x *= y
	fmt.Println(x)

	// “/=”(Division Assignment)
	x /= y
	fmt.Println(x)

	// “%=”(Modulus Assignment)
	x %= y
	fmt.Println(x)
}

输出量

go run hello.go
21
42
21
441
21

杂项运算符

请参阅以下运算符。

1. ＆：此运算符返回变量的地址。
2. *：该运算符提供指向变量的指针。
3. <-：已收到此运算符的名称。它用于从通道接收值。

请参见下面的其他运算符的代码示例。

// hello.go

package main

import "fmt"

func main() {
	x := 9
	y := &x

	fmt.Println(*y)

	*y = 11
	fmt.Println(x)
}

输出量

go run hello.go
9
11

结论

运算符是任何编程语言的组成部分之一。这就是为什么不使用运算符就无法完全引入Go语言的原因。我们已经看到了算术，逻辑，比较，按位，赋值和其他运算符。

最后，Golang运算符示例结束了。

也可以看看

Golang中的标识符

Golang中的关键字

Golang变量

高朗常数

Golang介绍

在MacOS上安装Golang