Operadores del lenguaje Go

Los operadores son la base de cualquier lenguaje de programación. Por lo tanto, el lenguaje Go no es completo sin operadores. Los operadores permiten realizar diferentes tipos de operaciones en operandos. En Go, se pueden clasificar según las diferentes funciones de los operadores:

• Operadores aritméticos

• Operadores de relación

• Operadores lógicos

• operadores bit a bit

• Operadores de asignación

• 杂项运算符

Operadores aritméticos

Estas se utilizan para realizar operaciones aritméticas en operandos de Go/Operaciones matemáticas:

• Suma: " +El operador ' ' suma dos operandos. Por ejemplo, x + y.

• Resta: "-El operador ' ' resta dos operandos. Por ejemplo, x-y.

• Multiplicación: '*El operador ' ' multiplica dos operandos. Por ejemplo, x * y.

• División: '/El operador ' ' divide el primer operando por el segundo. Por ejemplo, x / y.

• Módulo:Cuando el primer operando se divide por el segundo operando, el operador '%' devuelve el residuo. Por ejemplo, x％y.

Nota: -,+, !, &*, <-Y ^ también se conoce como operador unario, y los operadores unarios tienen una prioridad más alta.++Y el operador de suma también se conoce como operador unario, y tiene una prioridad más alta que los operadores binarios.

package main
import "fmt"
func main() {
　　　　p :=　34
　　　　q :=　20
　　　　//　Suma
　　　　result1　:= p　+　q
　　　　fmt.Printf("Resultado de la calculación p　+　q = %d", result1)
　　　　//　Resta
　　　　result2　:= p　-　q
　　　　fmt.Printf("\nResultado de la calculación p　-　q = %d", result2)
　　　　//　Multiplicación
　　　　result3　:= p　*　q
　　　　fmt.Printf("\nResultado de la calculación p　*　q = %d", result3)
　　　　//　División
　　　　result4　:= p　/　q
　　　　fmt.Printf("\nResultado de la calculación p　/　q = %d", result4)
　　　　//　Módulo
　　　　result5　:= p % q
　　　　fmt.Printf("\nCalcular el resultado p %% q = %d", result5)
}

Salida:

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

Operadores de relación

Los operadores de relación se utilizan para comparar dos valores. Vamos a verlos uno por uno:

• ‘==’ (igual)El operador verifica si dos operandos dados son iguales. Si son iguales, devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo:5 == 5devolverá verdadero.

• ‘!=’ (no igual)El operador verifica si dos operandos dados son iguales. Si no son iguales, devuelve verdadero. De lo contrario, devuelve falso. Es el complemento booleano exacto del operador ‘==’. Por ejemplo:5!= 5devolverá falso.

• ‘>’ (mayor que)El operador verifica si el primer operando es mayor que el segundo operando. Si es mayor, devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo:6> 5devolverá verdadero.

• ‘<’ (menor que)El operador verifica si el primer operando es menor que el segundo operando. Si es menor, devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo:6 <5devolverá falso.

• El operador verifica si el primer operando es mayor o igual que el segundo operando. Si es mayor o igual, devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo:5>= 5devolverá verdadero.

• “<=” (menor o igual que)El operador verifica si el primer operando es menor o igual que el segundo operando. Si es menor o igual, devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo:5 <= 5también devolverá verdadero.

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

Salida:

falso
verdadero
falso
verdadero
verdadero
falso

Operadores lógicos

• AND lógico:Cuando se cumplen ambas condiciones consideradas, el operador "&&" devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo, cuando a y b son verdaderos (es decir, no cero), a && b devuelve verdadero.

• O lógico: Cuando se cumple una de las condiciones (o ambas), el operador "||" devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo, si uno de a o b es verdadero (es decir, no cero), || b devuelve verdadero. Por supuesto, cuando a y b son verdaderos, devuelve verdadero.

• Negación lógica: Si no se cumple con las condiciones consideradas, el operador "!" devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo, si a es falso, es decir, a = 0, entonces !a devuelve verdadero.

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

Salida:

True
True
True

operadores bit a bit

En el lenguaje Go, hay6Los operadores bit a bit pueden operar bit a bit o utilizarse para operaciones bit a bit. A continuación se muestra una lista de operadores bit a bit:

• ＆（bitwise AND）：TomaDos números como operandos, y realiza la operación de AND en cada bit de los dos números. Solo cuando ambos bits son1，el resultado de AND solo es1.

• | （bitwise OR）：TomaDos números como operandos, y realiza la operación de OR en cada bit de los dos números. Si cualquier bit de los dos es1，el resultado de OR es1.

• ^（bitwise XOR）：TomaDos números como operandos, y realiza XOR en cada bit de los dos números. Si los dos bits son diferentes, el resultado de XOR es1.

• <<（left shift）：Toma dos números, desplaza el bit del primer operando a la izquierda, el segundo operando determina la cantidad de bits a desplazar.

• >>（right shift）：Toma dos números, desplaza el bit del primer operando a la derecha, el segundo operando determina la cantidad de bits a desplazar.

• ＆^（AND NOT）：Operadores de borrado bit a bit, la operación real de este operador es &(^).

package main
import "fmt"
func main() {
　　　　p :=　134
　　　　q :=　320
　　　　//　& (AND)
　　　　result1　:= p & q
　　　　fmt.Printf("Resultado de la operación p & q = %d", result1)
　　　　//　| (OR)
　　　　result2　:= p | q
　　　　fmt.Printf("\nResultado de la operación p | q = %d", result2)
　　　　//　^ (XOR)
　　　　result3　:= p ^ q
　　　　fmt.Printf("\nResultado de la operación p ^ q = %d", result3)
　　　　//　<< (left shift)
　　　　result4　:= p <<　1
　　　　fmt.Printf("\nResultado de la operación p <<　1　= %d", result4)
　　　　//　>> (right shift)
　　　　result5　:= p >>　1
　　　　fmt.Printf("\nResultado de la operación p >>　1　= %d", result5)
　　　　//　&^ (AND NOT)
　　　　result6　:= p &^ q
　　　　fmt.Printf("\nResultado de la operación p &^ q = %d", result6)
}

Salida:

Resultado de la operación p & q = 0
Resultado de la operación p | q =　454
Resultado de la operación p ^ q =　454
Resultado de la operación p <<　1　=　268
Resultado de la operación p >>　1　=　67
Resultado de la operación p &^ q =　134

Operadores de asignación

Los operadores de asignación se utilizan para asignar valores a variables. El operando izquierdo del operador de asignación es una variable, mientras que el operando derecho es un valor. El valor derecho debe tener el mismo tipo de datos que la variable izquierda, de lo contrario, el compilador lanzará un error. Los operadores de asignación de diferentes tipos se muestran a continuación:

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

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

• "-“+”和'='运算符的组合。该运算符首先将左侧变量的当前值添加到右侧的值，然后将结果分配给左侧的变量。此运算符是-“-”和'='运算符的组合。该运算符首先将左侧变量的当前值添加到右侧的值，然后将结果分配给左侧的变量。

• " * “-”和'='运算符的组合。该运算符首先从右侧的值中减去左侧变量的当前值，然后将结果分配给左侧的变量。此运算符是*“*”和'='运算符的组合。该运算符首先将左侧变量的当前值乘以右侧值，然后将结果分配给左侧变量。

• " / “/”和'='运算符的组合。该运算符首先将左侧变量的当前值乘以右侧值，然后将结果分配给左侧变量。此运算符是/此运算符是'/和'='运算符的组合。该运算符首先将左侧变量的当前值除以右侧值，然后将结果分配给左侧变量。

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

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

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

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

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)　
　　　　　　
}

Salida:

70
140
70
4900
70
0

杂项运算符

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

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

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

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

Salida:

94
67