Sentencias de control en Go: If y Switch

Introducción

Este tutorial pretende ser muy sencillo. Simplemente explica cómo funciona la sentencia if, else y switch. Veremos cómo a veces vamos a preferir switch, y cómo aquí no tenemos que utilizar break cuando lo utilizamos.

If y else

Comencemos con la sentencia if. A diferencia de otros lenguajes, la condición no va entre paréntesis. Y aunque el cuerpo ocupe una línea, debemos encerrarlo entre llaves.

La forma más simple del if y else es esta:

package main

import "fmt"

func main(){
	if true{
		fmt.Println("Verdadero")
	}else{
		fmt.Println("Falso") 
	}
}

Al ejecutar el código, se imprime “Verdadero”:

También puede haber if sin else

En este caso imprimimos sólo si la condición se cumple; en caso de que no, no hacemos nada. Recordemos que un if siempre puede ir sin else.

package main

import "fmt"

func main(){
	edad := 20
	if edad >= 18{
		fmt.Println("Mayor de edad")
	}
}

Podemos hacer negaciones

Recuerdo que cuando inicié a programar (con C) hace algunos años, me ocurrió algo muy gracioso. No sabía cómo hacer un else sin un if. Es decir, dejaba el if (con la condición) vacío, y ejecutaba el código sólo en el bloque del else.

Si tan sólo mis profesores (y no los culpo) me hubieran enseñado que las condiciones se pueden negar con ! las cosas serían distintas. En fin, podemos negar una variable, el resultado de una función, etcétera.

package main

import "fmt"

func main(){
	if !false{
		fmt.Println("Verdadero")
	}
}

En este caso estamos negando a false, lo que da como resultado true.

Utilizar and y or

Dos de las compuertas lógicas básicas: and, en donde todas las condiciones deben cumplirse. Y or, en donde al menos una de ellas debe cumplirse.

package main

import "fmt"

func main(){
	
	if 5 > 0 && 10 > 9{
		// Algo si se cumplen ambas condiciones
		// En este caso se cumplen ambas
		fmt.Println("5 > 0 && 10 > 9")
	}

	if 1 < 2 && 5 > 1{
		// 5 es mayor que 1, pero 1 no es menor que 2, así que no se cumple
		fmt.Println("1 < 2 && 5 > 1")
	}

	if 4 > 9 || 3 < 10{
		// Ejecutar algo si una de las dos condiciones se cumple
		// En este caso se cumplirá 3 < 10, aunque 4 > 9 no
		fmt.Println("4 > 9 || 3 < 10")
	}

	if 50 < 40 || 0 > 5{
		// No se cumple ninguna condición
		fmt.Println("50 < 40 || 0 > 5")
	}
	
}

La salida al ejecutar el programa es la siguiente:

5 > 0 && 10 > 9 1 < 2 && 5 > 1 4 > 9 || 3 < 10

If anidados con else

Podemos crear tantos if y elses como deseemos, aunque en estos casos se prefiere el switch, que veremos más abajo. En fin, así se ve:

package main

import "fmt"

func main(){
	calificacion := 98

	if calificacion >= 90{
		fmt.Println("Excelente")
	}else if calificacion >= 70{
		fmt.Println("Bueno")
	}else if calificacion >= 50{
		fmt.Println("Regular")
	}else if calificacion >= 30{
		fmt.Println("Malo")
	}else if calificacion >= 10{
		fmt.Println("Malísimo")
	}else{
		fmt.Println("Sin palabras")
	}
}

La salida será Excelente. Si la calificación no cumple ninguna condición, el programa irá al else, en donde dirá “Sin palabras”.

If anidados

Puede que deseemos ejecutar múltiples cosas en varios bloques if, así:

package main

import "fmt"

func main() {
	numero := 10

	if numero % 2 == 0{
		fmt.Println("10 es múltiplo de 2")
	}

	if numero % 3 == 0{
		fmt.Println("10 es múltiplo de 3")
	}

	if numero % 5 == 0{
		fmt.Println("10 es múltiplo de 5")
	}
}

En este caso utilizamos el operador módulo, que se encarga de sacar el residuo de una división. Por ejemplo, al dividir 10 entre 3, el residuo es 1; es por ello que sabemos que 10 no es múltiplo de 3. Pero no pasa lo mismo con 5 y 2.

Asignar variables antes de iniciar la condición

A veces es necesario asignar una variable que utilizaremos dentro de la condición. Para ello, podemos hacerlo como en los ejemplos de arriba, en donde asignamos calificación. O podemos hacerlo así:

package main

import "fmt"

func main(){
	if edad := 15; edad < 18 {
		fmt.Println("Menor de edad")
	}else{
		fmt.Println("Mayor de edad")
	}
}

En este caso es un ejemplo sin sentido, pues no utilizamos a edad dentro del if o else, pero ilustra correctamente.

Por favor notar que esta variable sólo vivirá dentro del if (y else, si es que ponemos); ya que si la queremos utilizar fuera de éstos habrá errores.

Asignar variables dependiendo de condición

Para terminar, veremos cómo asignar un valor dependiendo de una condición.

package main

import "fmt"

func main(){
	accesoPermitido := false
	edad := 18
	if edad >= 18{
		accesoPermitido = true
	}

	if accesoPermitido{ // Notar que no es necesario comparar accesoPermitido == true
		fmt.Println("Acceso concedido!")
	}
}

Qué bueno que hice este ejemplo, así también puedo demostrar que si una variable es booleana o devuelve un booleano, no es necesario compararlo con == true o con == false. Es decir, es lo mismo:

if variable == true{} y if variable{}

Así como:

if variable == false{} y if !variable{}

Switch

Esto será sencillo. Switch es como un if, pero más limpio. Permite comparar muchas condiciones, y sólo evalúa una de ellas; cuando se cumple, ya no ejecuta las demás.

Lo que más me gusta de esto es que podemos no sólo comparar números, sino cadenas y resultados de funciones.

Si ninguna condición se ejecuta, se llama a default.

Finalmente quiero hacer que noten que no es necesario el uso de break como en otros lenguajes, ya que el switch se termina cuando una de sus condiciones se cumple.

Evaluando muchas condiciones

Podemos evaluar varias condiciones que se verían confusas con bloques if. Notar por favor que es como si se comparase con ==, y no podemos utilizar >= o <=

package main

import "fmt"

func main(){
	descuento := 50
	switch descuento{
	case 90:
		fmt.Println("Se descuenta el 90 por ciento")
	case 70:
		fmt.Println("Se descuenta el 70 por ciento")
	case 50:
		fmt.Println("Se descuenta el 50 por ciento")
	case 30:
		fmt.Println("Se descuenta el 30 por ciento")
	case 10:
		fmt.Println("Se descuenta el 10 por ciento")
	default:
		fmt.Println("No hay descuento")
	}
}

Comparando cadenas

Podemos comparar tanto cadenas como números enteros. Si queremos hacerlo con cadenas, puede ser así:

package main

import "fmt"

func main(){
	lenguaje := "go"

	switch lenguaje{
	case "c":
		fmt.Println("C")
	case "java":
		fmt.Println("Java")
	case "go":
		fmt.Println("Go!")
	}
}

Y también podemos declarar variables que sólo serán visibles en el ámbito del switch. Por ejemplo, así se vería el ejemplo de arriba:

package main

import "fmt"

func main(){
	switch lenguaje := "go"; lenguaje{
	case "c":
		fmt.Println("C")
	case "java":
		fmt.Println("Java")
	case "go":
		fmt.Println("Go!")
	}
}