Operadores de comparación y operadores lógicos en Go

¿Qué es y para qué sirve?

Imagina que estás jugando un videojuego. Para pasar el nivel, necesitas verificar: "¿Tengo suficientes vidas?" o "¿Recogí todas las llaves?". En programación, estas comprobaciones las hacen los operadores de comparación y los operadores lógicos.

Los operadores de comparación son como una balanza. Comparan dos números o valores y dicen: "Sí, es verdad" o "No, es falso". Por ejemplo: "¿5 es mayor que 3?" — sí, es verdad. "¿2 es igual a 10?" — no, es falso.

Los operadores lógicos son como un juez que combina varias comprobaciones. Por ejemplo: "¿Tienes la llave Y sabes la contraseña?" — solo si ambas condiciones son verdaderas, la puerta se abrirá. O: "¿Encontraste el cofre O venciste al dragón?" — si al menos una condición es verdadera, obtienes la recompensa.

¿Para qué sirve esto? Sin ellos, el programa sería como un robot que hace lo mismo sin mirar la situación. Con ellos, puede tomar decisiones: "Si la temperatura supera los 30, enciende el aire acondicionado", "Si el usuario ingresó la contraseña correcta, déjalo entrar a su cuenta personal".

En Go (el lenguaje de programación de Google), estos operadores se ven muy simples y claros. ¡Vamos a entenderlos!

Sintaxis y ejemplos de código

En Go hay 6 operadores de comparación principales y 3 operadores lógicos. Aquí están en la tabla:

Ahora veamos ejemplos prácticos. Imagina que estamos escribiendo un programa para verificar la edad de entrada al cine.

package main

import "fmt"

func main() {
    // Ejemplo 1: verificación de edad
    age := 16
    fmt.Println("Edad:", age)
    
    // ¿Puede ver una película con clasificación 18+?
    canWatch := age >= 18
    fmt.Println("¿Puede ver 18+?", canWatch) // false, porque 16 es menor que 18
    
    // Ejemplo 2: verificación de descuento para estudiantes
    isStudent := true
    age = 20
    
    // Se da descuento si eres estudiante Y tu edad es menor de 25
    hasDiscount := isStudent && (age < 25)
    fmt.Println("¿Tiene descuento?", hasDiscount) // true, porque ambas condiciones son verdaderas
    
    // Ejemplo 3: verificación de entrada al club
    age = 17
    hasParent := true
    
    // Se permite la entrada al club si tienes 18+ O si estás con tus padres
    canEnter := (age >= 18) || hasParent
    fmt.Println("¿Puede entrar al club?", canEnter) // true, porque hasParent = true
    
    // Ejemplo 4: verificar que un número no es cero
    score := 0
    isNotZero := score != 0
    fmt.Println("¿La puntuación no es cero?", isNotZero) // false, porque score = 0
    
    // Ejemplo 5: condición compleja con negación
    isWeekend := false
    isHoliday := true
    
    // No es necesario ir a la escuela si hoy es fin de semana O festivo
    // Pero queremos verificar lo contrario: "¿Es necesario ir a la escuela?"
    mustGoToSchool := !(isWeekend || isHoliday)
    fmt.Println("¿Es necesario ir a la escuela?", mustGoToSchool) // false, porque isHoliday = true
}

Observa: en Go, el resultado de una comparación es siempre true (verdadero) o false (falso). Este es un tipo de dato especial llamado bool (nombrado en honor al matemático Boole).

Los operadores lógicos funcionan así:

• && (Y) — da true solo si ambas condiciones son true. Si al menos una es false, el resultado es false.
• || (O) — da true si al menos una condición es true. Si ambas son false, el resultado es false.
• ! (NO) — invierte el valor: true se convierte en false, false se convierte en true.

Aquí hay otro ejemplo que muestra cómo funciona esto en un programa real:

package main

import "fmt"

func main() {
    // Verificación: ¿se puede comprar un boleto para la atracción?
    height := 140  // altura en centímetros
    age := 10      // edad
    
    // Condición: altura de 120 a 190 Y edad de 8 a 16
    canRide := (height >= 120) && (height <= 190) && (age >= 8) && (age <= 16)
    fmt.Println("¿Puede montar?", canRide) // true, todas las condiciones se cumplen
    
    // ¿Y si la altura es 110?
    height = 110
    canRide = (height >= 120) && (height <= 190) && (age >= 8) && (age <= 16)
    fmt.Println("¿Puede montar con altura 110?", canRide) // false, la altura es demasiado baja
}

Comparación con Python

Si ya has probado Python, notarás que la idea es la misma, pero hay pequeñas diferencias. Comparemos: