Go: ciclos for, break, continue, defer, if y else

Esta entrada tratará sobre los bucles en el lenguaje de programación go.

¡Hola! ¿Ya sabes que tengo un tutorial completo del lenguaje de programación Go completamente gratis?, puedes encontrarlo directamente en la barra del menú superior o haciendo clic en este panel

Go maneja los bucles un poco diferente a lo que estás acostumbrado. Si ya dominas algún otro lenguaje de programación, probablemente recuerdes que hay bucles while, do while y for. Y si vienes de Python o Javascript, recordarás lo útil que son los bucles for x in o for x of

Bien, pues en el lenguaje de programación go no existen más que los bucles for. Sí, no hay while ni do while. ¿Pero entonces como hago para usar el resto de los bucles? Sigue leyendo y te explico, empezaré por explicar if y else y posteriormente los bucles.

Si no sabes nada sobre Go y quieres empezar por lo básico visita mi entrada Golang: introducción, variables y tipos de datos .

Si actualmente usas Python y quieres ver como es diferente de Go, visita mi entrada de python vs go .

If y else

If y else te permiten ejecutar bloques de código de manera condicional y guardan la misma sintaxis que en casi todos los lenguajes.

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

else if

Y por supuesto que go también cuenta con un else if.

edad := 18
if edad < 18 {
	fmt.Println("Menor de edad")
} else if edad > 18 {
	fmt.Println("Mayor de edad")
} else {
	fmt.Println("Tiene 18 exactamente")
}

Bucles for en go

En go existen varios tipos de bucles for: con contador, con condicional, range y el infinito.

Bucles con contador

Este es el clásico bucle que ya conoces de Javascript, C++, etc. En el que se declara una variable, se especifica una condición y se realizan cambios a la variables.

Declaramos “i” igual a 0, mientras “i” sea menor que 10, ejecuta el siguiente bloque y, posteriormente, incrementa “i” en uno, cada instrucción separada por un punto y coma.

for i:= 0; i < 10; i++ {
    // ...
}

Bucle con condicional

En este tipo de bucle se evalúa una condición, si el resultado es true, se ejecuta el bloque, si no, se brinca ese bloque de código. Este tipo de bucle for sería el equivalente del bucle while.

counter := 0
for counter < 10 {
    counter ++
}

Bucle con range

Range nos permite recorrer una estructura iterable de principio a fin y nos permite acceder al respectivo índice y elemento. Es ideal para recorrer arrays, strings, slices, maps, channels y cualquier estructura que pueda recorrerse.

	HolaMundo := "Hola mundo"
	for index, letra := range HolaMundo {
		fmt.Printf("%d %c \n", index, letra)
	}
/*
0 H 
1 o 
2 l 
3 a 
4   
5 m 
6 u 
7 n 
8 d 
9 o*/

Bucle infinito

Un bucle for sin condición va a ejecutarse por siempre.

La única manera de salir de un bucle for infinito es con un break.

counterForever := 0
for {
    counterForever++
}

break

Como acabo de mencionar, break rompe un bucle y continua la ejecución del código.

counterForever := 0
for {
    counterForever++
    fmt.Println(counterForever)
    if counterForever > 5 {
        fmt.Println("Aquí se rompe el bucle")
        break
}
}
// 1
// 2
// 3
// 4
// 5
// 6
// Aquí se rompe el bucle

Break en bucles con nombre en go

En otros lenguajes de programación, como en Python, break rompería el bucle inmediato, es decir, el bucle inmediato en el que se encuentra. ¿No sería genial poder parar al bucle exterior desde el interior? En go es posible de manera sencilla

while True:
    while True:
        break
    fmt.Println("El bucle principal continua ejecutándose")
# El bucle principal continua ejecutándose
# El bucle principal continua ejecutándose
# El bucle principal continua ejecutándose

Go nos permite asignarle nombres a los bucles, ¿para qué? Para hacer referencia a bucles específicos y ser capaz de romperlos usando break. Mira este ejemplo:

loop:
	for {
		for {
			fmt.Println("Rompiendo el bucle externo")
			break loop
		}
		fmt.Println("Esto nunca se imprimirá en pantalla")
	}

Nombramos a nuestro bucle como loop y ahora ejecutamos un bucle infinito que tendrá un bucle infinito en su interior. Este último bucle va a romper el bucle externo, de nombre loop, por lo que la segunda sentencia nunca va a imprimirse en pantalla.

continue

Continue detiene la iteración actual del bucle y continua su ejecución en la siguiente iteración.

counter := 0
for counter < 10 {
    counter ++
    if counter == 3 {
        fmt.Println("Nos brincamos el 3")
        continue
    }
    fmt.Println(counter)
}
//1
//2
//Nos brincamos el 3
//4

defer

Defer retrasa la ejecución de una linea de código hasta el final. del código. Es bastante similar a lo que hace el atributo defer con etiqueta script de HTML.

	defer fmt.Println("Esto se va a ejecutar hasta el final")
	fmt.Println("Esto se va a ejecutar primero")
	fmt.Println("Esto se va a ejecutar después")
// Esto se va a ejecutar primero
// Esto se va a ejecutar después
// Y esto se va a ejecutar hasta el final

¿Y eso para qué? Pues es ideal para cerrar conexiones a base de datos, archivos o realizar algún tipo de limpieza a los objetos de nuestro código.

const conexionBaseDeDatos := abreBaseDeDatos()
defer cierraBaseDeDatos()
queryBaseDeDatos()
otraQuery()

Para la siguiente entrada de Go voy a hablar lo básico sobre slices, arrays y maps.

Recuerda que puedes visitar la documentación oficial de go si hay algo que desees profundizar.