Operadores de Go

1 Visión general de los operadores en Golang

En el lenguaje Go, los operadores se utilizan para realizar operaciones de código de programa, que incluyen operaciones aritméticas, comparaciones relacionales, operaciones lógicas y más. Diferentes operadores corresponden a diferentes funcionalidades y escenarios de uso. Comprender y dominar estos operadores es la base para una programación efectiva.

2 Operadores aritméticos

El lenguaje Go proporciona un conjunto de operadores aritméticos:

• Adición (+): operación de suma
• Sustracción (-): operación de resta
• Multiplicación (*): operación de multiplicación
• División (/): operación de división
• Resto (%): operación de módulo

Ejemplos:

package main

import "fmt"

func main() {
    // Operación de suma
    sum := 10 + 5
    fmt.Println("10 + 5 =", sum) // Muestra 15

    // Operación de resta
    diff := 10 - 5
    fmt.Println("10 - 5 =", diff) // Muestra 5

    // Operación de multiplicación
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // Muestra 50

    // Operación de división
    quot := 10 / 5
    fmt.Println("10 / 5 =", quot) // Muestra 2

    // Operación de módulo
    rem := 10 % 5
    fmt.Println("10 % 5 =", rem) // Muestra 0
}

3 Operadores lógicos

Los operadores lógicos en el lenguaje Go se utilizan para conectar múltiples condiciones (generalmente utilizadas para valores booleanos). Incluye tres tipos: Y (&&), O (||) y NO (!).

3.1 Y (&&)

Cuando todas las condiciones son verdaderas, el resultado de la operación "Y" es verdadero.

Ejemplos:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // Muestra verdadero
    fmt.Println(true && false)  // Muestra falso
    fmt.Println(false && false) // Muestra falso
    // El resultado es verdadero solo cuando ambas condiciones son verdaderas
}

3.2 O (||)

Si al menos una condición es verdadera, el resultado de la operación "O" es verdadero.

Ejemplos:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // Muestra verdadero
    fmt.Println(true || false)  // Muestra verdadero
    fmt.Println(false || false) // Muestra falso
    // El resultado es verdadero si al menos una condición es verdadera
}

3.3 NO (!)

Se utiliza para invertir el valor booleano de una condición.

Ejemplos:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // Muestra falso
    fmt.Println(!false) // Muestra verdadero
    // Invierte el valor booleano
}

4 Operadores de comparación

Los operadores de comparación en el lenguaje Go se utilizan para comparar dos variables o valores:

• Igual a (==)
• No igual a (!=)
• Mayor que (>)
• Menor que (<)
• Mayor o igual que (>=)
• Menor o igual que (<=)

El resultado de las operaciones de comparación es un valor booleano: true o falso.

5 Operadores bit a bit

En Go, los operadores bit a bit nos permiten manipular directamente los bits binarios de los datos:

• Bitwise AND (&)
• Bitwise OR (|)
• Bitwise XOR (^)
• Desplazamiento a la izquierda (<<)
• Desplazamiento a la derecha (>>)

Los operadores bit a bit se utilizan principalmente en la programación a nivel bajo, como operaciones directas de hardware, cifrado y otros escenarios.

6 Operadores de asignación

Los operadores de asignación se utilizan para asignar valores a variables. En el lenguaje Go, existen múltiples formas de operadores de asignación:

• Asignación simple (=)
• Asignación de suma (+=)
• Asignación de resta (-=)
• Asignación de multiplicación (*=)
• Asignación de división (/=)
• Asignación de módulo (%=)

Estos operadores hacen que el código sea más conciso. Por ejemplo, x += 1 es equivalente a x = x + 1.

7 Operadores especiales

7.1 Operadores de incremento (++) y decremento (--)

El operador de incremento (++) y el operador de decremento (--) se utilizan para sumar 1 y restar 1 al valor de una variable, respectivamente. Son los únicos operadores en el lenguaje Go que pueden actuar directamente sobre la variable misma (no en una expresión).

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // Muestra 2
    
    y := 10
    y--
    fmt.Println("y-- =", y) // Muestra 9
}

Es importante tener en cuenta que en el lenguaje Go, x++ o x-- no pueden formar parte de una expresión. Por ejemplo, z := x++ no está permitido.

7.2 Conversión de tipos

El lenguaje Go es de tipado estático, lo que significa que una vez que se declara una variable, su tipo no puede cambiar. Por lo tanto, a veces es necesario convertir una variable de un tipo a otro. Go no tiene conversión automática de tipo; se requiere una conversión explícita.

Ejemplo:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // Convertir int a float64

	var f float64 = 3.14
	fmt.Println(int(f)) // Convertir float64 a int, la parte decimal será descartada
}

Al realizar la conversión de tipos, es importante asegurarse de que los datos estén seguros durante el proceso de conversión, como la posible pérdida de precisión al convertir un número de punto flotante a un entero.