Cómo usar operadores en Golang

Los operadores son la base de todo lenguaje de programación. Por lo tanto, la funcionalidad del lenguaje Golang está incompleta sin el uso de operadores. Los operadores nos permiten realizar diferentes tipos de operaciones sobre los operandos. En el lenguaje Go, los operadores se pueden clasificar en función de sus diferentes funciones .

Operadores aritméticos

Estos operadores se utilizan para realizar operaciones sobre operandos en el lenguaje Go:

• Suma: '+' agrega dos operandos. Por ejemplo: x+y.
• Resta: '-' resta dos operandos. Ejemplo: xy.
• Multiplicación: '*' multiplica dos operandos. Por ejemplo: x*y.
• División: '/' divide el primer operando por el segundo operando. Por ejemplo: x/y.
• Resto: El operador '%' devuelve el resto cuando el primer operando se divide por el segundo operando. Por ejemplo: x%y.

 Nota: -, +, !, &, *, <- y ^ también se denominan operadores unarios y la precedencia de los operadores unarios es mayor. Los operadores ++ y — provienen de declaraciones, no son expresiones, por lo que se encuentran fuera de la jerarquía de operadores.

Por ejemplo:

//Minh họa chương trình Go dùng toán tử số học
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// Phép cộng
result1:= p + q 
fmt.Printf("Result of p + q = %d", result1) 
	
// Phép trừ
result2:= p - q 
fmt.Printf("\nResult of p - q = %d", result2) 
	
// Phép nhân
result3:= p * q 
fmt.Printf("\nResult of p * q = %d", result3) 
	
// Division 
result4:= p / q 
fmt.Printf("\nResult of p / q = %d", result4) 
	
// Modulus 
result5:= p % q 
fmt.Printf("\nResult of p %% q = %d", result5) 
} 

Resultado:

Kết quả của p + q = 54
Kết quả của p - q = 14
Kết quả của p * q = 680
Kết quả của p / q = 1
Kết quả của p % q = 14

Operadores relacionales

Los operadores relacionales se utilizan para comparar dos valores. Veamos cada operador uno por uno:

• El operador '==' (Igual) verifica si los dos operandos dados son iguales o no. Si es igual, devuelve verdadero. De lo contrario, devuelve falso. Por ejemplo, 5==5 devolverá verdadero.
• El operador '!='(No igual a) verifica si los dos operandos dados son iguales o no. De lo contrario, devuelve verdadero. De lo contrario, devuelve falso. Este es el complemento booleano exacto del operador '=='. Por ejemplo, 5!=5 devolverá falso.
• El operador ">"(Mayor que) verifica si el primer operando es mayor que el segundo operando. Si es mayor, devuelve verdadero. Si es menor, devuelve falso. Por ejemplo, 6>5 devolverá verdadero.
• El operador '<' (menor que) verifica si el primer operando es menor que el segundo operando. Si es menor, devuelve verdadero. En caso contrario devuelve falso. Por ejemplo, <5 retornará
• El operador ">="(Mayor que igual) verifica si el primer operando es mayor o igual que el segundo operando. Si es mayor o igual, devuelve verdadero. Si es menor o igual, devuelve falso. Por ejemplo: 5>=5 devolverá verdadero.
• El operador '<=' (menor o igual que) verifica si el primer operando es menor o igual que el segundo operando. Si es mayor o igual, devuelve verdadero. Si es menor o igual, devuelve falso. Por ejemplo: <=5 también retornará

Por ejemplo:

// Minh họa chương trình Go dùng toán tử quan hệ
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// ‘=='(Equal To) 
result1:= p == q 
fmt.Println(result1) 
	
// ‘!='(Not Equal To) 
result2:= p != q 
fmt.Println(result2) 
	
// ‘<‘(less than)="" result3:="p">< q="" fmt.println(result3)="" ‘="">'(Greater Than) 
result4:= p > q 
fmt.Println(result4) 
	
// ‘>='(Greater Than Equal To) 
result5:= p >= q 
fmt.Println(result5) 
	
// ‘<='(less than="" equal="" to)="" result6:="p"><= q="" fmt.println(result6)="" }="">

Resultado:

false
true
false
true
true
false

Operadores lógicos

Se utilizan para combinar dos o más condiciones/restricciones o para complementar la evaluación de la condición inicial considerada.

• Y: El operador '&&' devuelve verdadero cuando se cumplen ambas condiciones bajo consideración. De lo contrario, devuelve falso. Por ejemplo, a && b devuelve verdadero cuando tanto a como b son verdaderos (es decir, distintos de cero).
• OR: Operador '||' Devuelve verdadero cuando se cumple una (o ambas) de las condiciones consideradas. De lo contrario, devuelve falso. Por ejemplo: a || b devuelve verdadero si a o b son verdaderos (es decir, distintos de cero). Por supuesto, devuelve verdadero cuando tanto a como b son verdaderos.
• NO lógico: El '!' operador Devuelve verdadero cuando la condición bajo consideración no se cumple. De lo contrario, devuelve falso. Por ejemplo: !a devuelve verdadero si a es falso, es decir, cuando a = 0.

Por ejemplo:

// Minh họa chương trình Go dùng toán tử logic
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" ||=""><=q){ fmt.println("true")="" }="" if(!(p="=q)){" fmt.println("true")="" }="" }="">

Resultado:

True
True
True

Operadores bit a bit

En el lenguaje Go, hay 6 operadores bit a bit que operan a nivel de bit o se utilizan para realizar operaciones bit a bit. Los siguientes son los operadores bit a bit:

• & (AND bit a bit): toma dos números como operandos y realiza AND en cada bit de los dos números. El resultado de AND solo es 1 si ambos bits son 1.
• | (OR bit a bit): toma dos números como operandos y realiza OR en cada bit de los dos números. El resultado de OR es 1 si cualquiera de los dos bits es 1.
• ^ (XOR bit a bit): toma dos números como operandos y realiza XOR en cada bit de los dos números. El resultado de XOR es 1 si los dos bits son diferentes.
• < (desplazamiento a la izquierda): toma dos números, desplaza los bits del primer operando a la izquierda, el segundo operando determina el número de posiciones a desplazar
• >> (desplazar a la derecha): tomar dos números, desplazar los bits del primer operando a la derecha, el segundo operando determina la cantidad de posiciones a desplazar.
• &^ (Y NO): Este es un operador bit a bit explícito.

Por ejemplo:

// Minh họa chương trình Go dùng toán tử bitwise
package main 

import "fmt"

func main() { 
p:= 34
q:= 20
	
// & (bitwise AND) 
result1:= p & q 
fmt.Printf("Result of p & q = %d", result1) 
	
// | (bitwise OR) 
result2:= p | q 
fmt.Printf("\nResult of p | q = %d", result2) 
	
// ^ (bitwise XOR) 
result3:= p ^ q 
fmt.Printf("\nResult of p ^ q = %d", result3) 
	
// < (left="" shift)="" result4:="p">< 1="" fmt.printf("\nresult="" of="" p="">< 1="%d" ,"="" result4)="">> (right shift) 
result5:= p >> 1
fmt.Printf("\nResult of p >> 1 = %d", result5) 
	
// &^ (AND NOT) 
result6:= p &^ q 
fmt.Printf("\nResult of p &^ q = %d", result6) 
	
	
} 

Resultado:

Kết quả của p & q = 0
Kết quả của p | q = 54
Kết quả của p ^ q = 54
Kết quả của p < 1="68" kết="" quả="" của="" p="">> 1 = 17
Kết quả của p &^ q = 34

Operador de asignación

El operador de asignación se utiliza para asignar un valor a una variable. El operando izquierdo del operador de asignación es una variable y el operando derecho del operador de asignación es un valor. El valor de la derecha debe tener el mismo tipo de datos que la variable de la izquierda, de lo contrario el compilador devolverá un error. A continuación se muestran los diferentes tipos de operadores de asignación:

• “="(Asignación simple): Este es el operador de asignación más simple. Este operador se utiliza para asignar el valor de la derecha a la variable de la izquierda.
• “+="(Asignación adicional): Este operador es una combinación de los operadores '+' y '='. Este operador primero agrega el valor actual de la variable izquierda al valor de la derecha y luego asigna el resultado a la variable izquierda.
• “-="(Asignación menos): Este operador es una combinación de los operadores '-' y '='. Este operador primero resta el valor actual de la variable izquierda del valor de la derecha y luego asigna el resultado a la variable izquierda.
• “*="(Asignación de multiplicación): Este operador es una combinación de los operadores '*' y '='. Este operador primero multiplica el valor actual de la variable izquierda por el valor de la derecha y luego asigna el resultado a la variable izquierda.
• “/=”(Asignación de división): Este operador es una combinación de los operadores '/' y '='. Este operador primero divide el valor actual de la variable izquierda por el valor de la derecha y luego asigna el resultado a la variable izquierda.
• “%="(Asignación de resto): este operador es una combinación de los operadores '%' y '='. Este operador primero toma el resto del valor actual de la variable izquierda dado el valor de la derecha y luego asigna el resultado a la variable izquierda.
• “&="(AND bit a bit): Este operador es una combinación de los operadores '&' y '='. Este operador primero realiza una operación AND bit a bit del valor actual de la variable izquierda con el valor de la derecha y luego asigna el resultado a la variable izquierda.
• “^="(OR exclusivo bit a bit): Este operador es una combinación de los operadores '^' y '='. Este operador primero realiza un “OR exclusivo bit a bit” del valor actual de la variable izquierda por el valor de la derecha y luego asigna el resultado a la variable izquierda.
• “|="(OR inclusivo bit a bit): Este operador es una combinación del '|' operadores y '='. Este operador primero realiza un “OR inclusivo bit a bit” del valor actual de la variable izquierda por el valor de la derecha y luego asigna el resultado a la variable izquierda.
• “<=: Este operador es una combinación de los operadores < ' y '="'." Este operador primero “desplaza” el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la derecha.
• “>>=": Este operador es una combinación de los operadores ">>" y "=". Este operador primero “desplaza a la derecha AND” el valor actual de la variable izquierda con el valor de la derecha y luego asigna el resultado a la variable izquierda.

Por ejemplo:

// Minh họa chương trình Go dùng toán tử gán
package main 
	
import "fmt"
	
func main() { 
var p int = 45
	var q int = 50
	
// “=”(Simple Assignment) 
p = q 
fmt.Println(p) 
	
// “+=”(Add Assignment) 
	p += q 
fmt.Println(p) 
	
//“-=”(Subtract Assignment) 
p-=q 
fmt.Println(p) 
	
// “*=”(Multiply Assignment) 
p*= q 
fmt.Println(p) 
	
// “/=”(Division Assignment) 
	p /= q 
fmt.Println(p) 
	
	// “%=”(Modulus Assignment) 
	p %= q 
fmt.Println(p) 
	
} 

Resultado:

50
100
50
2500
50
0

Otros operadores

• &: Este operador devuelve la dirección de una variable.
• *: Este operador proporciona un puntero a una variable.
• <-: El nombre de este operador es recibir. Se utiliza para recibir un valor de

// Minh họa chương trình sử dụng toán tử khác
package main 
	
import "fmt"
	
func main() { 
a := 4
	
// Dùng địa chỉ của toán tử (&) toán tử trỏ gián tiếp (*)

b := &a 
fmt.Println(*b) 
*b = 7
fmt.Println(a) 
} 

Resultado:

4
7