Operadores da Linguagem Go

运算符是任何编程语言的基础。因此，在不使用运算符的情况下，Go语言的功能是不完整的。运算符允许我们对操作数执行不同类型的运算。在Go语言中，可以根据操作员的不同功能对其进行分类：

• 算术运算符

• Operadores de relação

• Operadores lógicos

• operadores bit a bit

• Operador de atribuição

• 杂项运算符

算术运算符

这些用于对Go语言中的操作数执行算术/数学运算：

• 加法： " +”运算符将两个操作数相加。例如，x + y。

• 减法： "-”运算符减去两个操作数。例如，x-y。

• 乘法： '*' 运算符将两个操作数相乘。例如，x * y。

• 除法： '/' 运算符将第一个操作数除以第二个。例如，x / y。

• 求模：当第一个操作数除以第二个操作数时，'％'运算符返回余数。例如，x％y。

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

package main
import "fmt"
func main() {
　　　　p :=　34
　　　　q :=　20
　　　　//　加法
　　　　result1　:= p　+　q
　　　　fmt.Printf("计算结果 p　+　q = %d", result1)
　　　　//　减法
　　　　result2　:= p　-　q
　　　　fmt.Printf("\n计算结果 p　-　q = %d", result2)
　　　　//　乘法
　　　　result3　:= p　*　q
　　　　fmt.Printf("\n计算结果 p　*　q = %d", result3)
　　　　//　除法
　　　　result4　:= p　/　q
　　　　fmt.Printf("\n计算结果 p　/　q = %d", result4)
　　　　//　求模
　　　　result5　:= p % q
　　　　fmt.Printf("\nCalcular o resultado p %% q = %d", result5)
}

Saída:

Calcular o resultado p　+　q =　54
Calcular o resultado p　-　q =　14
Calcular o resultado p　*　q =　680
Calcular o resultado p　/　q =　1
Calcular o resultado p % q =　14

Operadores de relação

Os operadores de relação são usados para comparar dois valores. Vamos analisá-los um por um:

• ‘==’ (igual)O operador verifica se os dois operandos fornecidos são iguais. Se forem iguais, retorna true. Caso contrário, ele retorna false. Por exemplo:5 == 5também retornará true.

• ‘!=’ (diferente)O operador verifica se os dois operandos fornecidos são iguais. Se não forem iguais, retorna true. Caso contrário, ele retorna false. É o complemento booleano exato do operador '=='.5!= 5também retornará false.

• ‘>’ (maior)O operador verifica se o primeiro operando é maior do que o segundo operando. Se for maior, retorna true. Caso contrário, ele retorna false. Por exemplo:6> 5também retornará true.

• ‘<’ (menor)O operador verifica se o primeiro operando é menor do que o segundo operando. Se for menor, retorna true. Caso contrário, ele retorna false. Por exemplo:6 <5também retornará false.

• O operador verifica se o primeiro operando é maior ou igual ao segundo operando. Se for maior ou igual, retorna true. Caso contrário, ele retorna false. Por exemplo:5>= 5também retornará true.

• “<=” (menor ou igual)O operador verifica se o primeiro operando é menor ou igual ao segundo operando. Se for menor ou igual, retorna true. Caso contrário, ele retorna false. Por exemplo:5 <= 5também retornará true.

package main
import "fmt"
func main() {
　　　　p :=　34
　　　　q :=　20
　　　　//　‘==’ (igual)
　　　　result1　:= p == q
　　　　fmt.Println(result1)
　　　　//　‘!=’ (diferente)
　　　　result2　:= p != q
　　　　fmt.Println(result2)
　　　　//　‘<’ (menor)
　　　　result3　:= p < q
　　　　fmt.Println(result3)
　　　　//　‘>’ (maior)
　　　　result4　:= p > q
　　　　fmt.Println(result4)
　　　　//　‘>=’ (maior ou igual)
　　　　result5　:= p >= q
　　　　fmt.Println(result5)
　　　　//　‘<=’ (menor ou igual)
　　　　result6　:= p <= q
　　　　fmt.Println(result6)
}

Saída:

falso
verdadeiro
falso
verdadeiro
verdadeiro
falso

Operadores lógicos

• Operador lógico AND:Quando ambas as condições consideradas forem satisfeitas, o operador && retorna true. Caso contrário, retorna false. Por exemplo, quando ambos a e b forem verdadeiros (não zero), a && b retorna verdadeiro.

• Operador lógico OU: Quando uma (ou ambas) das condições forem satisfeitas, o operador || retorna true. Caso contrário, retorna false. Por exemplo, se um de a ou b for verdadeiro (não zero), || b retorna true. Claro, quando ambos a e b forem verdadeiros, ele retorna true.

• Negação lógica: Se não satisfaz as condições consideradas, o operador ! retorna true. Caso contrário, ele retorna false. Por exemplo, se a for falsa, ou seja, a = 0, então !a retorna true.

package main
import "fmt"
func main() {
　　　　var p int =　23
　　　　var q int =　60
　　　　if p != q && p <= q {
　　　　　　　　fmt.Println("Verdadeiro")
　　　　}
　　　　if p != q || p <= q {
　　　　　　　　fmt.Println("Verdadeiro")
　　　　}
　　　　if !(p == q) {
　　　　　　　　fmt.Println("Verdadeiro")
　　　　}
}

Saída:

Verdadeiro
Verdadeiro
Verdadeiro

operadores bit a bit

No idioma Go, há6Vários operadores bit a bit podem trabalhar bit a bit ou ser usados para operações bit a bit. Aqui estão os operadores bit a bit:

• ＆（bitwise AND）：que representaDois números como operandos, e realiza a operação de AND em cada bit dos dois números. Apenas quando ambos os bits forem1quando, o resultado do AND será1.

• | （bitwise OR）：que representaDois números como operandos, e realiza a operação de OR em cada bit dos dois números. Se qualquer um dos bits for1O resultado do OR é1.

• ^（bitwise XOR）：que representaDois números como operandos, e realiza XOR em cada bit dos dois números. Se os bits forem diferentes, o resultado do XOR é1.

• <<（left shift）：Pega dois números, move os bits do primeiro operando para a esquerda, e o segundo operando determina a quantidade de bits a serem movidos.

• >>（right shift）：Pega dois números, move os bits do primeiro operando para a direita, e o segundo operando determina a quantidade de bits a serem movidos.

• ＆^（AND NOT）：O operador de limpeza de bits, que opera na verdade como operador & (^).

package main
import "fmt"
func main() {
　　　　p :=　134
　　　　q :=　320
　　　　//　& (AND)
　　　　result1　:= p & q
　　　　fmt.Printf("Resultados da operação p & q = %d", result1)
　　　　//　| (OR)
　　　　result2　:= p | q
　　　　fmt.Printf("\nResultados da operação p | q = %d", result2)
　　　　//　^ (XOR)
　　　　result3　:= p ^ q
　　　　fmt.Printf("\nResultados da operação p ^ q = %d", result3)
　　　　//　<< (left shift)
　　　　result4　:= p <<　1
　　　　fmt.Printf("\nResultados da operação p <<　1　= %d", result4)
　　　　//　>> (right shift)
　　　　result5　:= p >>　1
　　　　fmt.Printf("\nResultados da operação p >>　1　= %d", result5)
　　　　//　&^ (AND NOT)
　　　　result6　:= p &^ q
　　　　fmt.Printf("\nResultados da operação p &^ q = %d", result6)
}

Saída:

Resultados da operação p & q = 0
Resultados da operação p | q =　454
Resultados da operação p ^ q =　454
Resultados da operação p <<　1　=　268
Resultados da operação p >>　1　=　67
Resultados da operação p &^ q =　134

Operador de atribuição

O operador de atribuição é usado para atribuir valores a variáveis. O operando à esquerda do operador de atribuição é uma variável, enquanto o operando à direita é um valor. O valor à direita deve ter o mesmo tipo de dados que a variável à esquerda, caso contrário, o compilador lançará um erro. Os operadores de atribuição de tipos diferentes são exibidos da seguinte forma:

• “ =”（简单赋值）：这是最简单的赋值运算符。该运算符用于将右侧的值分配给左侧的变量。

• " + ='（加法赋值）：此运算符是+‘和’='运算符的组合。该运算符首先将左侧变量的当前值添加到右侧的值，然后将结果分配给左侧的变量。

• "-='（减法赋值）：此运算符是-‘和’='运算符的组合。该运算符首先从右侧的值中减去左侧变量的当前值，然后将结果分配给左侧的变量。

• " * ='（乘法赋值）：此运算符是*‘和’='运算符的组合。该运算符首先将左侧变量的当前值乘以右侧值，然后将结果分配给左侧变量。

• " / ‘='（除法赋值）：此运算符是/‘和’='运算符的组合。该运算符首先将左侧变量的当前值除以右侧值，然后将结果分配给左侧变量。

• “％=”（模赋值）：此运算符是“％”和“ =”运算符的组合。该运算符首先对左侧变量的当前值乘以右侧变量的值，然后将结果赋给左侧变量。

• “＆=”（按位与赋值）：此运算符是'＆'和'='运算符的组合。该运算符首先将左侧变量的当前值与右侧变量进行“按位与”运算，然后将结果分配给左侧变量。

• “ ^ =”（按位异或）：此运算符是'^'和'='运算符的组合。该运算符首先将左侧变量的当前值与右侧变量进行“按位异或”，然后将结果分配给左侧变量。

• “ | =”（按位或）：此运算符是“ |”和'='运算符的组合。该运算符首先将左边变量的当前值与右边的值“按位或”，然后将结果分配给左边的变量。

package main　
　　　　
import "fmt"
　　　　
func main() {　
　　　var p int =　38
　　　　var q int =　70
　　　　　　　
　　　//　“=”（简单赋值）　
　　　p = q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　"+=（加法赋值）　
　　　　p　+= q　
　　　fmt.Println(p)　
　　　　　　　
　　　//"-=（减法赋值）　
　　　p-=q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　"*=（乘法赋值）　
　　　p*= q　
　　　fmt.Println(p)　
　　　　　　　
　　　//　"/=（除法赋值）　
　　　　p　/= q　
　　　fmt.Println(p)　
　　　　　　
　　　　//　“%=”（求模赋值）　
　　　　p %= q　
　　　fmt.Println(p)　
　　　　　　
}

Saída:

70
140
70
4900
70
0

杂项运算符

• ＆：此运算符返回变量的地址。

• *:此运算符提供指向变量的指针。

• <-:此运算符的名称为接收。它用于从通道接收值。

package main　
　　　　
import "fmt"
　　　　
func main() {　
　　a :=　94
　　　　　
//使用运算符（＆）和
//指针间接（*）运算符
　　b := &a　　
　　fmt.Println(*b)　　
　　*b =　67　
　　fmt.Println(a)　　
}

Saída:

94
67