Operadores del lenguaje Go

Los operadores se utilizan para realizar operaciones matemáticas o lógicas durante la ejecución del programa.

Los operadores integrados en el lenguaje Go son:

Operadores aritméticos
Operadores relacionales
Operadores lógicos
Operadores de bits
Operadores de asignación
Otros operadores

A continuación, veamos en detalle la introducción de cada operador.

Operadores aritméticos

La siguiente tabla enumera todos los operadores aritméticos de Go. Supongamos que A vale 10 y B vale 20.

Operador	Descripción	Ejemplo
+	Suma	A + B da como resultado 30
-	Resta	A - B da como resultado -10
*	Multiplicación	A * B da como resultado 200
/	División	B / A da como resultado 2
%	Módulo	B % A da como resultado 0
++	Incremento	A++ da como resultado 11
--	Decremento	A-- da como resultado 9

El siguiente ejemplo demuestra el uso de cada operador aritmético:

Ejemplo

package main

import "fmt"

func main() {

var a int = 21
var b int = 10
var c int

c = a + b
fmt.Printf("Primera línea - el valor de c es %d\n", c )
c = a - b
fmt.Printf("Segunda línea - el valor de c es %d\n", c )
c = a * b
fmt.Printf("Tercera línea - el valor de c es %d\n", c )
c = a / b
fmt.Printf("Cuarta línea - el valor de c es %d\n", c )
c = a % b
fmt.Printf("Quinta línea - el valor de c es %d\n", c )
a++
fmt.Printf("Sexta línea - el valor de a es %d\n", a )
a=21 // Para facilitar las pruebas, aquí se reasigna a a con el valor 21
a--
fmt.Printf("Séptima línea - el valor de a es %d\n", a )
}

El resultado de ejecución del ejemplo anterior es:

第一行 - c 的值为 31
第二行 - c 的值为 11
第三行 - c 的值为 210
第四行 - c 的值为 2
第五行 - c 的值为 1
第六行 - a 的值为 22
第七行 - a 的值为 20

Operadores relacionales

La siguiente tabla enumera todos los operadores relacionales de Go. Supongamos que A vale 10 y B vale 20.

Operador	Descripción	Ejemplo
==	Comprueba si dos valores son iguales. Si son iguales devuelve True, de lo contrario devuelve False.	(A == B) es False
!=	Comprueba si dos valores no son iguales. Si no son iguales devuelve True, de lo contrario devuelve False.	(A != B) es True
>	Comprueba si el valor de la izquierda es mayor que el de la derecha. Si es así, devuelve True; de lo contrario, devuelve False.	(A > B) es False
<	Comprueba si el valor de la izquierda es menor que el de la derecha. Si es así, devuelve True; de lo contrario, devuelve False.	(A < B) es True
>=	Comprueba si el valor de la izquierda es mayor o igual que el de la derecha. Si es así, devuelve True; de lo contrario, devuelve False.	(A >= B) es False
<=	Comprueba si el valor de la izquierda es menor o igual que el de la derecha. Si es así, devuelve True; de lo contrario, devuelve False.	(A <= B) es True

El siguiente ejemplo demuestra el uso de los operadores relacionales:

Ejemplo

package main

import "fmt"

func main() {
var a int = 21
var b int = 10

if( a == b ) {
fmt.Printf("Primera línea - a es igual a b\n" )
} else {
fmt.Printf("Primera línea - a no es igual a b\n" )
}
if ( a < b ) {
fmt.Printf("Segunda línea - a es menor que b\n" )
} else {
fmt.Printf("Segunda línea - a no es menor que b\n" )
}

if ( a > b ) {
fmt.Printf("Tercera línea - a es mayor que b\n" )
} else {
fmt.Printf("Tercera línea - a no es mayor que b\n" )
}
/* Lets change value of a and b */
a = 5
b = 20
if ( a <= b ) {
fmt.Printf("Cuarta línea - a es menor o igual que b\n" )
}
if ( b >= a ) {
fmt.Printf("Quinta línea - b es mayor o igual que a\n" )
}
}

El resultado de ejecución del ejemplo anterior es:

第一行 - a 不等于 b
第二行 - a 不小于 b
第三行 - a 大于 b
第四行 - a 小于等于 b
第五行 - b 大于等于 a

Operadores lógicos

La siguiente tabla enumera todos los operadores lógicos de Go. Supongamos que A es True y B es False.

Operador	Descripción	Ejemplo
&&	Operador lógico AND. Si los dos operandos son True, la condición es True; de lo contrario, es False.	(A && B) es False
\|\|	Operador lógico OR. Si al menos uno de los operandos es True, la condición es True; de lo contrario, es False.	(A \|\| B) es True
!	Operador lógico NOT. Si la condición es True, la condición NOT lógico es False; de lo contrario, es True.	!(A && B) es True

El siguiente ejemplo demuestra el uso de los operadores lógicos:

Ejemplo

package main

import "fmt"

func main() {
var a bool = true
var b bool = false
if ( a && b ) {
fmt.Printf("Primera línea - la condición es true\n" )
}
if ( a || b ) {
fmt.Printf("Segunda línea - la condición es true\n" )
}
/* Modifica los valores de a y b */
a = false
b = true
if ( a && b ) {
fmt.Printf("Tercera línea - la condición es true\n" )
} else {
fmt.Printf("Tercera línea - la condición es false\n" )
}
if ( !(a && b) ) {
fmt.Printf("Cuarta línea - la condición es true\n" )
}
}

El resultado de ejecución del ejemplo anterior es:

第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true

Operadores de bits

Los operadores de bits operan sobre los bits binarios de los enteros en la memoria.

La siguiente tabla enumera los cálculos de los operadores de bits &, | y ^:

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Supongamos que A = 60; B = 13; sus números binarios se convierten a:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

Los operadores de bits soportados por el lenguaje Go se muestran en la siguiente tabla. Supongamos que A es 60 y B es 13:

Operador	Descripción	Ejemplo
&	El operador AND bit a bit "&" es un operador binario. Su función es realizar la operación AND en los bits correspondientes de los dos números que participan en la operación.	(A & B) da como resultado 12, en binario 0000 1100
\|	El operador OR bit a bit "\|" es un operador binario. Su función es realizar la operación OR en los bits correspondientes de los dos números que participan en la operación.	(A \| B) da como resultado 61, en binario 0011 1101
^	El operador XOR bit a bit "^" es un operador binario. Su función es realizar la operación XOR en los bits correspondientes de los dos números que participan en la operación. Cuando los dos bits correspondientes son diferentes, el resultado es 1.	(A ^ B) da como resultado 49, en binario 0011 0001
<<	El operador de desplazamiento a la izquierda "<<" es un operador binario. Desplazar n bits a la izquierda equivale a multiplicar por 2 elevado a n. Su función es desplazar todos los bits del operando a la izquierda de "<<" hacia la izquierda cierta cantidad de bits, especificada por el número a la derecha de "<<". Los bits altos se descartan y los bits bajos se rellenan con 0.	A << 2 da como resultado 240, en binario 1111 0000
>>	El operador de desplazamiento a la derecha ">>" es un operador binario. Desplazar n bits a la derecha equivale a dividir entre 2 elevado a n. Su función es desplazar todos los bits del operando a la izquierda de ">>" hacia la derecha cierta cantidad de bits, especificada por el número a la derecha de ">>".	A >> 2 da como resultado 15, en binario 0000 1111

El siguiente ejemplo demuestra el uso de los operadores de bits:

Ejemplo

package main

import "fmt"

func main() {

var a uint = 60 /* 60 = 0011 1100 */
var b uint = 13 /* 13 = 0000 1101 */
var c uint = 0

c = a & b /* 12 = 0000 1100 */
fmt.Printf("Primera línea - el valor de c es %d\n", c )

c = a | b /* 61 = 0011 1101 */
fmt.Printf("Segunda línea - el valor de c es %d\n", c )

c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("Tercera línea - el valor de c es %d\n", c )

c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("Cuarta línea - el valor de c es %d\n", c )

c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("Quinta línea - el valor de c es %d\n", c )
}

El resultado de ejecución del ejemplo anterior es:

第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15

Operadores de asignación

La siguiente tabla enumera todos los operadores de asignación de Go.

Operador	Descripción	Ejemplo
=	Operador de asignación simple: asigna el valor de una expresión a un lvalue.	C = A + B asigna el resultado de la expresión A + B a C
+=	Suma y luego asigna	C += A es igual a C = C + A
-=	Resta y luego asigna	C -= A es igual a C = C - A
*=	Multiplica y luego asigna	C = A es igual a C = C A
/=	Divide y luego asigna	C /= A es igual a C = C / A
%=	Calcula el módulo y luego asigna	C %= A es igual a C = C % A
<<=	Desplaza a la izquierda y luego asigna	C <<= 2 es igual a C = C << 2
>>=	Desplaza a la derecha y luego asigna	C >>= 2 es igual a C = C >> 2
&=	AND bit a bit y luego asigna	C &= 2 es igual a C = C & 2
^=	Asignación después de XOR bit a bit	C ^= 2 equivale a C = C ^ 2
\|=	Asignación después de OR bit a bit	C \|= 2 equivale a C = C \| 2

El siguiente ejemplo demuestra el uso de los operadores de asignación:

Ejemplo

package main

import "fmt"

func main() {
var a int = 21
var c int

c = a
fmt.Printf("Línea 1 - Ejemplo del operador =, el valor de c es = %d\n", c )

c += a
fmt.Printf("Línea 2 - Ejemplo del operador +=, el valor de c es = %d\n", c )

c -= a
fmt.Printf("Línea 3 - Ejemplo del operador -=, el valor de c es = %d\n", c )

c *= a
fmt.Printf("Línea 4 - Ejemplo del operador *=, el valor de c es = %d\n", c )

c /= a
fmt.Printf("Línea 5 - Ejemplo del operador /=, el valor de c es = %d\n", c )

c = 200;

c <<= 2
fmt.Printf("Línea 6 - Ejemplo del operador <<=, el valor de c es = %d\n", c )

c >>= 2
fmt.Printf("Línea 7 - Ejemplo del operador >>=, el valor de c es = %d\n", c )

c &= 2
fmt.Printf("Línea 8 - Ejemplo del operador &=, el valor de c es = %d\n", c )

c ^= 2
fmt.Printf("Línea 9 - Ejemplo del operador ^=, el valor de c es = %d\n", c )

c |= 2
fmt.Printf("Línea 10 - Ejemplo del operador |=, el valor de c es = %d\n", c )

}

El resultado de ejecutar el ejemplo anterior es:

第 1 行 - =  运算符实例，c 值为 = 21
第 2 行 - += 运算符实例，c 值为 = 42
第 3 行 - -= 运算符实例，c 值为 = 21
第 4 行 - *= 运算符实例，c 值为 = 441
第 5 行 - /= 运算符实例，c 值为 = 21
第 6行  - <<= 运算符实例，c 值为 = 800
第 7 行 - >>= 运算符实例，c 值为 = 200
第 8 行 - &= 运算符实例，c 值为 = 0
第 9 行 - ^= 运算符实例，c 值为 = 2
第 10 行 - |= 运算符实例，c 值为 = 2

Otros operadores

La siguiente tabla enumera los otros operadores del lenguaje Go.

Operador	Descripción	Ejemplo
&	Devuelve la dirección de almacenamiento de una variable.	&a; dará la dirección real de la variable.
*	Variable puntero.	*a; es una variable puntero.

El siguiente ejemplo demuestra el uso de otros operadores:

Ejemplo

package main

import "fmt"

func main() {
var a int = 4
var b int32
var c float32
var ptr *int

/* Ejemplo de operadores */
fmt.Printf("Línea 1 - El tipo de la variable a es = %T\n", a );
fmt.Printf("Línea 2 - El tipo de la variable b es = %T\n", b );
fmt.Printf("Línea 3 - El tipo de la variable c es = %T\n", c );

/* Ejemplo de los operadores & y * */
ptr = &a /* 'ptr' contiene la dirección de la variable 'a' */
fmt.Printf("El valor de a es %d\n", a);
fmt.Printf("*ptr es %d\n", *ptr);
}

El resultado de ejecutar el ejemplo anterior es:

第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为  4
*ptr 为 4

Precedencia de operadores

Algunos operadores tienen mayor precedencia, y la dirección de evaluación de los operadores binarios es siempre de izquierda a derecha. La siguiente tabla enumera todos los operadores y su precedencia; de arriba a abajo representa la precedencia de mayor a menor:

Precedencia	Operador
5	* / % << >> & &^
4	+ - \| ^
3	== != < <= > >=
2	&&
1	\|\|

Por supuesto, puedes usar paréntesis para aumentar temporalmente la precedencia general de una expresión.

El resultado de ejecutar el ejemplo anterior es:

Ejemplo

package main

import "fmt"

func main() {
var a int = 20
var b int = 10
var c int = 15
var d int = 5
var e int;

e = (a + b) * c / d; // ( 30 * 15 ) / 5
fmt.Printf("El valor de (a + b) * c / d es : %d\n", e );

e = ((a + b) * c) / d; // (30 * 15 ) / 5
fmt.Printf("El valor de ((a + b) * c) / d es : %d\n" , e );

e = (a + b) * (c / d); // (30) * (15/5)
fmt.Printf("El valor de (a + b) * (c / d) es : %d\n", e );

e = a + (b * c) / d; // 20 + (150/5)
fmt.Printf("El valor de a + (b * c) / d es : %d\n" , e );
}

El resultado de ejecutar el ejemplo anterior es:

(a + b) * c / d 的值为 : 90
((a + b) * c) / d 的值为  : 90
(a + b) * (c / d) 的值为  : 90
a + (b * c) / d 的值为  : 50

Otras extensiones