Aprenda todo sobre Golang para bucles codificando varios ejemplos útiles.
Recientemente, los lenguajes de programación como Rust, Golang y TypeScript se han vuelto muy populares entre los desarrolladores. Si está interesado en el desarrollo de back-end y DevOps, ¡debería considerar aprender Golang es una excelente opción!
Si es un principiante que aprende los fundamentos de un lenguaje de programación, las construcciones de bucle son uno de los primeros conceptos que debe comprender.
Golang proporciona solo la construcción de bucle for. Y aprenderemos sobre bucles for y también cómo emular otros bucles usando el bucle for.
¡Vamos a empezar!
Tabla de contenido
Sintaxis de Golang For Loop
En Golang, puede crear un bucle for usando la siguiente sintaxis:
for initialization; condition; update {
// do something
}
Aquí,
- initialization denota la inicialización de la variable de bucle.
- condition es la condición de bucle que determina la ejecución del cuerpo del bucle. Siempre que la condición del bucle se evalúe como verdadera, se ejecutarán las declaraciones en el cuerpo del bucle. Y cuando la condición se vuelve falsa, el control sale del ciclo.
- update denota la actualización de la variable de bucle, generalmente un incremento o una disminución.
💡 Observe cómo esto es similar al ciclo C for solo sin los paréntesis.
Aquí está el flujo de control en Golang para bucles:
¡Es hora de codificar algunos ejemplos!⏰ Para codificar, puede usar una instalación local de Golang o ejecutar los ejemplos en Go Playground.
Ejemplos de bucle For de Golang
Usemos la sintaxis que acabamos de aprender para escribir nuestro primer ciclo for. Aquí hay un bucle for simple que imprime los números del 1 al 5 en pasos de uno.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
}
Inicializamos la variable de bucle i a 1, establecemos la condición en i <= 5 e incrementamos la variable de bucle en uno después de cada iteración. Y aquí está la salida:
//Output For loop: 1 2 3 4 5
Escribamos otro bucle for. Este ciclo comienza desde 5 y cuenta hacia atrás hasta 1; continúa hasta que la variable de bucle es mayor o igual a 1. Así que decrementamos la variable de bucle en uno después de cada iteración.
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := num; i >= 1; i-- {
fmt.Println(i)
}
}
Y obtenemos el resultado esperado:
//Output For loop: 5 4 3 2 1
¿Cuál es el alcance de la variable de bucle?
El alcance de la variable de bucle se limita al bloque de bucle for y no es accesible fuera del bucle.
Para verificar esto, intentemos acceder al valor de la variable de bucle i fuera del bucle:
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
fmt.Println(i)
}
fmt.Println(i)
}
Como era de esperar, nos encontramos con un error que indica que i no está definido (y su alcance está restringido al bucle for):
// Output ./prog.go:11:14: undefined: i
Bucle for infinito en Golang
¿Podemos tener bucles for infinitos en Go? ¡Sí, seguro que podemos!
Si observa el flujo de control de bucle for:
- El cuerpo del bucle continuará ejecutándose mientras la condición se evalúe como verdadera.
- Cuando la condición se vuelve falsa, el control sale del bucle.
- Entonces, si la condición nunca se vuelve falsa (o siempre es verdadera), tenemos un bucle infinito.
Pero también puede usar el bucle for sin la inicialización, la condición y la actualización, sin encontrarse con errores de sintaxis. Entonces, si puede hacer que el ciclo se ejecute infinitamente incluso usando una construcción de ciclo for como esta:
package main
import "fmt"
func main() {
for {
fmt.Println("running...")
}
}
//Output running... running... running... running... running... //and it goes on forever!
En este ejemplo, establecemos la variable num en 5. Y la condición del ciclo es num >= 5. Por lo tanto, el ciclo se ejecuta siempre que num sea mayor o igual a cero.
package main
import "fmt"
func main() {
num := 5
for num > 0 {
fmt.Println(num)
}
}
Debido a que el valor de num nunca cambia, la condición siempre se evalúa como verdadera, ¡y el ciclo se ejecuta para siempre!
//Output 5 5 5 5 5 5 //and it goes on forever!
Todo Golang tiene solo la construcción de bucle for, podemos intentar emular los bucles while y do-while usando bucles for. ¡Así que aprendamos cómo hacerlo!
Emulando un ciclo while usando un ciclo for
El ciclo while generalmente toma la siguiente forma:
// initialize looping var
while (condition){
// do something
// update looping var
}
Si recuerdas, en el primer ciclo for infinito escribimos: usamos el siguiente ciclo for, sin la inicialización, la condición y la actualización.
for {
// the simplest infinite loop
}
Entonces podemos modificar el ciclo for para que contenga solo la condición (en la siguiente forma) para emular el ciclo while:
//initialize looping var
for condition {
// do something
// update looping var
}
Aquí está el ciclo while equivalente al primer ciclo for que escribimos:
package main
import "fmt"
func main() {
fmt.Println("Emulating while loop")
num := 5
for num > 0 {
fmt.Println(num)
num--
}
}
//Output Emulating while loop 5 4 3 2 1
Emulando Do-While Loop usando For Loop
Si ha codificado en un lenguaje como C, sabe que la construcción del ciclo do-while toma la siguiente forma:
// initialize looping var
do {
//something
// update looping var
} while(condition);
La diferencia clave entre el ciclo while y do while es que el ciclo while verifica la condición al ingresar al ciclo. El bucle do-while, por otro lado, comprueba la condición al salir del bucle.
Entonces, en un ciclo while, si la condición se evalúa como falsa, el cuerpo del ciclo nunca se ejecuta. Sin embargo, en un ciclo do-while, el cuerpo del ciclo se ejecuta incluso si la condición se evalúa como falsa.
Usando esta información, podemos emular el comportamiento de un bucle do-while:
- Escribir un bucle for infinito
- Use una declaración condicional if con la condición correcta para salir del bucle
Digamos que desea escribir un ciclo do-while donde la condición para que se ejecute el cuerpo del ciclo es num < 0. Entonces puede escribir un ciclo for y salir del ciclo si num >= 0.
package main
import "fmt"
func main() {
fmt.Println("Emulating do-while loop")
num := 5
for {
fmt.Println("loop runs...")
if num >= 0 {
break
}
}
}
💡 Tenga en cuenta que ejecutar el bucle si num < 0 y salir del bucle si num >= 0 son condiciones equivalentes.
Aunque la condición num > 0 es inicialmente falsa (num es 5), el cuerpo del bucle se ejecuta una vez, emulando un bucle do-while.
//Output Emulating do-while loop loop runs...
Bucle a través de arreglos usando For Loop
Al recorrer matrices en Golang usando un bucle for y un rango, puede acceder tanto a los índices como a los elementos. Esto funciona de manera similar a la función de enumeración en Python.
Aquí, creamos numArray, una matriz de enteros. Y recorrerlo usando un bucle for:
package main
import "fmt"
func main() {
fmt.Println("Looping through an array")
numArray := []int{3, 7, 0, 10, 8, 9}
for idx, num := range numArray {
fmt.Println("At index", idx, ": ", num)
}
}
Como se ve, podemos acceder tanto al índice como al elemento en cada índice simultáneamente:
//Output Looping through an array At index 0 : 3 At index 1 : 7 At index 2 : 0 At index 3 : 10 At index 4 : 8 At index 5 : 9
Usando diferir en Golang For Loop
En Golang, puede usar la palabra clave aplazar para aplazar las llamadas a funciones.
Aunque se usa en aplicaciones como la limpieza de recursos y el manejo de errores, puede ser útil comprender cómo usar defer dentro de un bucle for. Veamos qué sucede cuando usamos diferir dentro del bucle for para diferir las llamadas a la función Println().
package main
import "fmt"
func main() {
fmt.Println("For loop:")
num := 5
for i := 1; i <= num; i++ {
defer fmt.Println(i)
}
}
💬 Cuando se difiere una llamada de función, la llamada de función se coloca en la pila y se ejecuta en orden LIFO. Esta ejecución ocurre solo después de que regresa la función que rodea a la instrucción diferida.
Entonces fmt.Println(5) se ejecuta primero y fmt.Println(1) se ejecuta en último lugar:
//Output For loop: 5 4 3 2 1
Conclusión
Aquí hay un resumen de lo que has aprendido en este tutorial:
- En Golang, puede crear bucles for con la sintaxis: for initialization; condición; actualizar { //cuerpo del bucle}.
- El flujo de control del bucle for es bastante simple. La variable de bucle se inicializa una vez, la condición de búsqueda determina si se ejecuta o no el cuerpo del bucle, y la actualización se refiere a la actualización de la variable de bucle después de cada iteración.
- El alcance de la variable de bucle se limita al cuerpo del bucle y no es accesible fuera del bucle.
- Aunque Golang solo proporciona la construcción de bucle for, puede emular comportamientos de bucle while y do-while usando bucles for.
- Algunas otras aplicaciones del bucle for incluyen el bucle a través de matrices y el aplazamiento de llamadas a funciones dentro del cuerpo del bucle for.
A continuación, aprenda a usar bucles for en Python. ¡Feliz aprendizaje!🎉