Go – Operadores: Guía completa para desarrolladores

Los operadores en Go son símbolos especiales que indican al compilador realizar operaciones matemáticas, lógicas o de comparación. Son esenciales para construir expresiones y controlar el flujo de ejecución en tus programas. Este artículo ofrece una guía completa sobre los distintos tipos de operadores en Go, con ejemplos detallados para cada uno.

Comprender los operadores es crucial para escribir código legible y eficiente en Go. Cada operador tiene un significado específico y se utiliza para un propósito particular. Dominar su uso te permitirá crear programas robustos y realizar cálculos complejos de forma eficiente.

Operadores Aritméticos

Los operadores aritméticos realizan operaciones matemáticas básicas. En Go, estos operadores son:

• Suma (+): Sube el valor del operando izquierdo por el valor del operando derecho.
• Resta (-): Resta el valor del operando derecho del operando izquierdo.
• Multiplicación (*): Multiplica el valor del operando izquierdo por el valor del operando derecho.
• División (/): Divide el valor del operando izquierdo por el valor del operando derecho.
• Módulo (%): Calcula el resto de la división del operando izquierdo por el operando derecho.

Ejemplo:

«`go
package main

import «fmt»

func main() {
a := 10
b := 3

suma := a + b // suma = 13
resta := a - b // resta = 7
multiplicacion := a * b // multiplicacion = 30
division := a / b // division = 3
modulo := a % b // modulo = 1

fmt.Println("Suma:", suma)
fmt.Println("Resta:", resta)
fmt.Println("Multiplicacion:", multiplicacion)
fmt.Println("Division:", division)
fmt.Println("Modulo:", modulo)

}
«`

Operadores Relacionales

Los operadores relacionales comparan dos operandos y devuelven un valor booleano (verdadero o falso) basado en el resultado de la comparación. En Go, estos operadores son:

• Igual que (==): Devuelve verdadero si ambos operandos son iguales, falso en caso contrario.
• Diferente de (!=): Devuelve verdadero si ambos operandos son diferentes, falso en caso contrario.
• Mayor que (>): Devuelve verdadero si el operando izquierdo es mayor que el derecho, falso en caso contrario.
• Menor que (<): Devuelve verdadero si el operando izquierdo es menor que el derecho, falso en caso contrario.
• Mayor o igual que (>=): Devuelve verdadero si el operando izquierdo es mayor o igual que el derecho, falso en caso contrario.
• Menor o igual que (<=): Devuelve verdadero si el operando izquierdo es menor o igual que el derecho, falso en caso contrario.

Ejemplo:

«`go
package main

import «fmt»

func main() {
a := 10
b := 5

igual := a == b // igual = false
diferente := a != b // diferente = true
mayor := a > b // mayor = true
menor := a < b // menor = false
mayorIgual := a >= b // mayorIgual = true
menorIgual := a <= b // menorIgual = false

fmt.Println("Igual:", igual)
fmt.Println("Diferente:", diferente)
fmt.Println("Mayor:", mayor)
fmt.Println("Menor:", menor)
fmt.Println("Mayor o igual:", mayorIgual)
fmt.Println("Menor o igual:", menorIgual)

}
«`

Operadores Lógicos

Los operadores lógicos se utilizan para combinar expresiones booleanas. En Go, los operadores lógicos son:

• Y lógico (&&): Devuelve verdadero si ambos operandos son verdaderos, falso en caso contrario.
• O lógico (||): Devuelve verdadero si al menos uno de los operandos es verdadero, falso en caso contrario.
• Negación lógica (!): Invierte el valor booleano del operando.

Ejemplo:

«`go
package main

import «fmt»

func main() {
a := true
b := false

yLogico := a && b // yLogico = false
oLogico := a || b // oLogico = true
negacion := !a // negacion = false

fmt.Println("Y lógico:", yLogico)
fmt.Println("O lógico:", oLogico)
fmt.Println("Negación:", negacion)

}
«`

Operadores Bit a Bit

Los operadores bit a bit trabajan a nivel de bits y realizan operaciones sobre los bits individuales de los operandos. En Go, los operadores bit a bit son:

• Y bit a bit (&): Realiza una operación AND bit a bit.
• O bit a bit (|): Realiza una operación OR bit a bit.
• XOR bit a bit (^): Realiza una operación XOR bit a bit.
• Complemento bit a bit (~): Invierte los bits del operando.
• Desplazamiento a la izquierda (<<): Desplaza los bits del operando izquierdo a la izquierda por el número de posiciones indicado por el operando derecho.
• Desplazamiento a la derecha (>>): Desplaza los bits del operando izquierdo a la derecha por el número de posiciones indicado por el operando derecho.

Ejemplo:

«`go
package main

import «fmt»

func main() {
a := 10 // 1010 en binario
b := 5 // 0101 en binario

yBit := a & b // yBit = 0 (0000 en binario)
oBit := a | b // oBit = 15 (1111 en binario)
xorBit := a ^ b // xorBit = 15 (1111 en binario)
complemento := ^a // complemento = -11 (1010 en binario, complemento a dos)
desplazamientoIzquierda := a << 2 // desplazamientoIzquierda = 40 (101000 en binario)
desplazamientoDerecha := a >> 1 // desplazamientoDerecha = 5 (0101 en binario)

fmt.Println("Y bit a bit:", yBit)
fmt.Println("O bit a bit:", oBit)
fmt.Println("XOR bit a bit:", xorBit)
fmt.Println("Complemento bit a bit:", complemento)
fmt.Println("Desplazamiento a la izquierda:", desplazamientoIzquierda)
fmt.Println("Desplazamiento a la derecha:", desplazamientoDerecha)

}
«`

Operadores de Asignación

Los operadores de asignación se utilizan para asignar un valor a una variable. En Go, el operador de asignación básico es el signo igual (=).

• Asignación (=): Asigna el valor del operando derecho al operando izquierdo.

Además del operador de asignación básica, Go ofrece operadores de asignación combinados para simplificar expresiones que combinan una operación aritmética con una asignación. Estos operadores son:

• Suma y asignación (+=): Suma el valor del operando derecho al izquierdo y asigna el resultado al operando izquierdo.
• Resta y asignación (-=): Resta el valor del operando derecho al izquierdo y asigna el resultado al operando izquierdo.
• Multiplicación y asignación (*=): Multiplica el valor del operando derecho por el izquierdo y asigna el resultado al operando izquierdo.
• División y asignación (/=): Divide el valor del operando izquierdo por el derecho y asigna el resultado al operando izquierdo.
• Módulo y asignación (%=): Calcula el resto de la división del operando izquierdo por el derecho y asigna el resultado al operando izquierdo.
• Y bit a bit y asignación (&=): Realiza una operación AND bit a bit y asigna el resultado al operando izquierdo.
• O bit a bit y asignación (|=): Realiza una operación OR bit a bit y asigna el resultado al operando izquierdo.
• XOR bit a bit y asignación (^=): Realiza una operación XOR bit a bit y asigna el resultado al operando izquierdo.
• Desplazamiento a la izquierda y asignación (<<=): Desplaza los bits del operando izquierdo a la izquierda y asigna el resultado al operando izquierdo.
• Desplazamiento a la derecha y asignación (>>=): Desplaza los bits del operando izquierdo a la derecha y asigna el resultado al operando izquierdo.

Ejemplo:

«`go
package main

import «fmt»

func main() {
a := 10

a += 5 // a = 15
a -= 2 // a = 13
a *= 3 // a = 39
a /= 2 // a = 19
a %= 5 // a = 4

fmt.Println("a:", a)

}
«`

Otros Operadores

Además de los operadores mencionados anteriormente, Go tiene otros operadores importantes:

• Operador de coma (,): Evalúa los operandos de izquierda a derecha y devuelve el valor del último operando.
• Operador condicional (?:): Evalúa la expresión booleana de la izquierda. Si la expresión es verdadera, devuelve el valor del operando intermedio. Si la expresión es falsa, devuelve el valor del operando derecho.

Ejemplo:

«`go
package main

import «fmt»

func main() {
a := 10
b := 5

c := (a > b, a) // c = 10
d := (a < b, a, b) // d = 5

fmt.Println("c:", c)
fmt.Println("d:", d)

e := (a > b ? a : b) // e = 10
f := (a < b ? a : b) // f = 5

fmt.Println("e:", e)
fmt.Println("f:", f)

}
«`

Precedencia de Operadores

La precedencia de operadores determina el orden en que se evalúan las operaciones en una expresión. Los operadores con mayor precedencia se evalúan antes que los operadores con menor precedencia. En Go, la precedencia de operadores se define como sigue, de mayor a menor:

1. Operadores unarios: Negación lógica (!), complemento bit a bit (~), incremento (++) y decremento (–).
2. Multiplicativo: Multiplicación (*), división (/), módulo (%).
3. Aditivo: Suma (+), resta (-).
4. Desplazamiento bit a bit: Desplazamiento a la izquierda (<<), desplazamiento a la derecha (>>).
5. Relacional: Igual que (==), diferente de (!=), mayor que (>), menor que (<), mayor o igual que (>=), menor o igual que (<=).
6. Y bit a bit: Y bit a bit (&).
7. XOR bit a bit: XOR bit a bit (^).
8. O bit a bit: O bit a bit (|).
9. Y lógico: Y lógico (&&).
10. O lógico: O lógico (||).
11. Asignación: Asignación (=), suma y asignación (+=), resta y asignación (-=), multiplicación y asignación (*=), división y asignación (/=)
    módulo y asignación (%=), Y bit a bit y asignación (&=), O bit a bit y asignación (|=), XOR bit a bit y asignación (^=),
    desplazamiento a la izquierda y asignación (<<=), desplazamiento a la derecha y asignación (>>=).
12. Operador de coma (,): Operador de coma (,).

Ejemplo:

«`go
package main

import «fmt»

func main() {
a := 10
b := 5
c := 2

resultado := a + b * c // resultado = 20

// La expresión se evalúa de la siguiente manera:
// 1. b * c = 10 (multiplicación tiene mayor precedencia que la suma)
// 2. a + 10 = 20 

fmt.Println("resultado:", resultado)

}
«`

Conclusión

Los operadores son una parte fundamental del lenguaje Go. Comprender los distintos tipos de operadores y su precedencia es esencial para escribir código legible, eficiente y correcto. Este artículo te ha proporcionado una guía completa sobre los operadores en Go, con ejemplos detallados para cada uno.

Utilizando los operadores de forma efectiva, podrás construir programas complejos y realizar cálculos precisos, aprovechando al máximo las posibilidades que ofrece el lenguaje.