Publicado por Yo quería pegarlo 100 veces
En la entrada anterior estudiamos los arreglos porque nos serían de utilidad para entender fácilmente este tema. Hay situaciones donde necesitamos ejecutar una sección de código varias veces pero ¡qué flojera copiarlo y pegarlo una y otra vez! Para lograr esa tarea la mayoría de los lenguajes de programación incluyen las sentencias de ciclos.
Los ciclos permiten ejecutar repetidamente una o varias sentencias de forma consecutiva. Pueden ser mezclados con condicionales o, inclusive, con otros ciclos internos para lograr tareas que de otro modo serían casi imposibles.
De verdad quería pegarlo 100 veces
La única sentencia de ciclos existente en Golang (hasta agosto del 2016) es for, contrario a muchos otros lenguajes de programación que permiten algunas como while. La buena noticia es que for abarca todos los posibles usos que podrían tener otras sentencias similares, así que, realmente no se extraña mucho el while.
Sentencia for
La sentencia for controla una sección de código para que se repita una cierta cantidad de veces especificada al escribir el programa o determinada en tiempo de ejecución. La sintaxis es la siguiente:
Sentencia_for = "for" [Condición | Cláusula_for | Rango] Bloque
Sintaxis de Cláusula_for
Cláusula_for = [Inicialización ";" Condición ";" Incremento]
Sintaxis de Rango:
Rango = [Lista_expresiones "=" | Lista_identificadores ":="] "range" Expresión
Sintaxis de Bloque:
Bloque = "{" Lista_sentencias "}"
Nota: Es importante colocar la llave de apertura en la misma línea que la sentencia for.
Desglosando la sintaxis anterior:
- Cuando se especifica una condición, el ciclo se ejecutará mientras esta sea verdadera.
- Si se utiliza la sintaxis (inicialización; condición; incremento) ocurre que:
- La inicialización solamente ocurre una vez y es la primera sentencia que se ejecuta. Se inicializan cualquier cantidad de variables de control del ciclo (aquellas que controlan las repeticiones del ciclo), aunque no es necesario hacerlo siempre y cuando aparezca el punto y coma después de donde debería de estar la inicialización.
- La condición se evalúa en seguida de la inicialización y antes de repetir cada nuevo ciclo. Si es verdadera entonces el cuerpo se ejecuta, de lo contrario simplemente se salta todo el ciclo.
- Después de que se ejecuta el cuerpo, se realiza el incremento. Este actualiza cualesquiera variables de control para de ese modo no incurrir en ciclos infinitos. Esta sección puede ser dejada en blanco siempre y cuando aparezca un punto y coma después de la condición.
- La condición es evaluada nuevamente. Se vuelve al paso 2.
- En cambio, si se escribe un rango de valores, el ciclo se ejecuta para cada uno de los elementos de ese rango.
Ciclo for con una condición de paro
En el siguiente ejemplo se puede apreciar la sintaxis cuando se proporciona solamente una condición para detener el ciclo:
package main
import "fmt"
func main(){
var i = 0
for i < 10 {
fmt.Println("Valor de i:", i)
i++
}
}
Salida:
Ciclo for con inicialización, condición e incremento
El siguiente ejemplo ilustra el funcionamiento de esta clase de ciclos:
package main
import "fmt"
func main(){
var i int
for i=0 ; i < 10; i++ {
fmt.Println("Valor de i:", i)
}
}
Salida:
Ciclo for con un rango
Para comprender el funcionamiento de esta clase de for puede utilizarse el ejemplo siguiente:
package main
import "fmt"
func main(){
arreglo:=[7]int{0,1,4,6,10,9}
for i, j:= range arreglo{
fmt.Printf("Valor de j: %d en vuelta #%d\n", j,i)
}
for i:= range arreglo{
fmt.Printf("Valor de i: %d\n", i)
}
}
Salida:
Sentencia break
Go cuenta con una sentencia break cuyos usos son terminar el ciclo más interno en el que esté situado, o bien terminar un case de un switch.
package main
import "fmt"
func main(){
for i:=0 ; i < 10; i++ {
fmt.Printf("Valor de i: %d", i)
if i == 7{
fmt.Printf(" así que saldremos del ciclo...\n")
break
}
fmt.Printf("\n")
}
}
Salida:
Sentencia continue
La sentencia continue de Go sigue un funcionamiento similar al de break con la diferencia de que continue no termina el ciclo por completo, simplemente termina la iteración actual ignorando el código restante y continúa evaluando la condición de la siguiente iteración.
El siguiente ejemplo ilustra el funcionamiento de la sentencia:
package main
import "fmt"
func main(){
var i = 0
for i < 10 {
fmt.Printf("Valor de i: %d", i)
if i == 6{
fmt.Printf(" sumaremos 3\n")
i = i + 3
continue
}
fmt.Printf("...\n")
i++
}
}
Salida:
Sentencia goto
Una sentencia goto permite el “salto” hasta una etiqueta dentro de la misma función. Una etiqueta es un identificador (regularmente escrito con mayúsculas) seguido de dos puntos, el cual sirve para poner «marcas» o «puntos de referencia» en nuestros programas. Si se utiliza goto, el flujo del programa continúa de forma estructurada a partir de la etiqueta que se especificó.
No es recomendable usar sentencia que permita esta clase de movimientos en el código porque dificultan su comprensión, y siempre existe una forma de escribir cualquier programa que utiliza goto de una forma en que se omita su uso.
El siguiente ejemplo muestra el uso de goto:
package main
import "fmt"
func main() {
var i int = 0
CICLO: for i < 10 {
if i == 6 {
i = i + 3
fmt.Println("Saltando a etiqueta CICLO con i = i + 3")
goto CICLO
}
fmt.Printf("Valor de i: %d\n", i)
i++
}
}
Salida:
Finalizando…
En este capítulo estudiamos los ciclos en Go y cómo estos nos facilitan la programación. En la próxima entrada estudiaremos el uso de las funciones. Espero que te haya servido, nos vemos la próxima.