Presentación de Go

Capítulo 4. Estructuras de control

Este trabajo se ha traducido utilizando IA. Agradecemos tus opiniones y comentarios: [e-mail]

Ahora que sabes utilizar variables, es hora de empezar a escribir programas útiles. En primer lugar, vamos a escribir un programa que cuente hasta 10, empezando por 1, con cada número en su propia línea. Utilizando lo que has aprendido hasta ahora, podrías escribir esto:

package main

import "fmt"

func main() {
    fmt.Println(1)
    fmt.Println(2)
    fmt.Println(3)
    fmt.Println(4)
    fmt.Println(5)
    fmt.Println(6)
    fmt.Println(7)
    fmt.Println(8)
    fmt.Println(9)
    fmt.Println(10)
}

O esto:

package main
import "fmt"

func main() {
  fmt.Println(`1
2
3
4
5
6
7
8
9
10`)
}

Pero ambos programas son bastante tediosos de escribir. Lo que necesitamos es una forma de hacer algo varias veces.

La Declaración for

La sentencia for nos permite repetir una lista de sentencias (un bloque) varias veces. Reescribir nuestro programa anterior utilizando una sentencia for tiene el siguiente aspecto:

package main

import "fmt"

func main() {
    i := 1
    for i <= 10 {
        fmt.Println(i)
        i = i + 1
    }
}

En primer lugar, creamos una variable llamada i que utilizamos para almacenar el número que queremos imprimir. A continuación, creamos un bucle for utilizando la palabra clave for, proporcionando una expresión condicional que sea true o false y, por último, proporcionando un bloque para ejecutar. El bucle for funciona así:

1. Evaluamos (ejecutamos) la expresión i <= 10 ("i menor o igual que 10"). Si el resultado es verdadero, ejecutamos las sentencias del bloque. En caso contrario, saltamos a la siguiente línea de nuestro programa después del bloque (en este caso, no hay nada después del bucle for, así que salimos del programa).

2. Después de ejecutar las sentencias dentro del bloque, volvemos al principio de la sentencia for y repetimos el paso 1.

La línea i = i + 1 es extremadamente importante, porque sin ella, i <= 10 siempre se evaluaría a true y nuestro programa nunca se detendría (cuando esto ocurre, se denomina bucle infinito).

Como ejercicio, vamos a recorrer el programa como lo haría un ordenador:

1. Crea una variable llamada i con el valor 1.

2. ¿Es i <= 10? Sí.

3. Imprimir i.

4. Ajusta i a i + 1 (i ahora es igual a 2).

5. ¿Es i <= 10? Sí.

6. Imprimir i.

7. Ajusta i a i + 1 (i ahora es igual a 3).

8. ...

9. Pon i en i + 1 (i es ahora igual a 11).

10. ¿Es i <= 10? No.

11. No queda nada por hacer, así que sal.

Otros lenguajes de programación tienen muchos tipos diferentes de bucles (while, do, until, foreach, ...) pero Go sólo tiene uno que se puede utilizar de muchas formas diferentes. El programa anterior también podría haberse escrito así:

func main() {
    for i := 1; i <= 10; i++ {
        fmt.Println(i)
    }
}

Ahora la expresión condicional también contiene otras dos declaraciones con punto y coma entre ellas. En primer lugar, tenemos la inicialización de la variable, después tenemos la condición a comprobar cada vez y, por último, incrementamos la variable . Sumar 1 a una variable es tan común que tenemos un operador especial (++); del mismo modo, restar 1 puede hacerse con --.

Veremos otras formas de utilizar el bucle for en capítulos posteriores.

La declaración if

Modifiquemos el programa que acabamos de escribir para que, en lugar de limitarse a imprimir los números del 1 al 10 en cada línea, especifique también si el número es par o impar:

1 odd
2 even
3 odd
4 even
5 odd
6 even
7 odd
8 even
9 odd
10 even

En primer lugar, necesitamos una forma de determinar si un número es par o impar. Una forma fácil de saberlo es dividir el número por 2. Si no te queda nada, entonces el número es par; de lo contrario, es impar. Entonces, ¿cómo hallamos el resto tras la división en Go? Utilizamos el operador %. 1 % 2 es igual a 1, 2 % 2 es igual a 0, 3 % 2 es igual a 1, y así sucesivamente.

A continuación, necesitamos una forma de elegir hacer cosas diferentes en función de una condición. Para ello, utilizamos la sentencia if:

if i % 2 == 0 {
    // even
} else {
    // odd
}

Una sentencia if es similar a una sentencia for en que tiene una condición seguida de un bloque. Las sentencias if también tienen una parte opcional else. Si la condición se evalúa como verdadera, se ejecuta el bloque que sigue a la condición; en caso contrario, se omite el bloque o, si el bloque else está presente, se ejecuta ese bloque.

if Las declaraciones también pueden tener partes else if:

if i % 2 == 0 {
    // divisible by 2
} else if i % 3 == 0 {
    // divisible by 3
} else if i % 4 == 0 {
    // divisible by 4
}

Las condiciones se comprueban de arriba abajo y el bloque asociado al primero que resulte verdadero se ejecutará. Ninguno de los otros bloques se ejecutará, aunque sus condiciones también se cumplan (así, por ejemplo, el número 8 es divisible por 4 y por 2, pero el bloque // divisible by 4 nunca se ejecutará porque el bloque // divisible by 2 se ejecuta primero).

Juntándolo todo, tenemos

func main() {
    for i := 1; i <= 10; i++ {
        if i % 2 == 0 {
            fmt.Println(i, "even")
        } else {
            fmt.Println(i, "odd")
        }
    }
}

Recorramos este programa:

1. Crea una variable i de tipo int y dale el valor 1.

2. ¿Es i menor o igual que 10? Sí: salta al bloque if.

3. ¿Es el resto de i ÷ 2 igual a 0? No: salta al bloque else.

4. Imprime i seguido de odd.

5. Incrementa i (la declaración después de la condición).

6. ¿Es i menor o igual que 10? Sí: salta al bloque if.

7. ¿Es el resto de i ÷ 2 igual a 0? Sí: salta al bloque if.

8. Imprime i seguido de even, y así sucesivamente hasta que i sea igual a 11.

9. ...

El operador resto, aunque rara vez se ve fuera de la escuela primaria, resulta ser realmente útil al programar. Lo verás aparecer en todas partes, desde las tablas de bandas de cebra hasta la partición de conjuntos de datos.

if son bastante útiles, pero en ocasiones pueden ser bastante verbosas, por lo que Go incluye una sentencia relacionada: la switch.

La Declaración del interruptor

Supón que quieres escribir un programa que imprima los nombres en inglés de los números. Utilizando lo que has aprendido hasta ahora, podrías empezar haciendo lo siguiente:

if i == 0 {
    fmt.Println("Zero")
} else if i == 1 {
    fmt.Println("One")
} else if i == 2 {
    fmt.Println("Two")
} else if i == 3 {
    fmt.Println("Three")
} else if i == 4 {
    fmt.Println("Four")
} else if i == 5 {
    fmt.Println("Five")
}

Escribir un programa de esta forma sería bastante tedioso, así que otra forma de conseguir el mismo resultado es utilizar la sentencia switch. Podemos reescribir nuestro programa de la siguiente manera:

switch i {
case 0: fmt.Println("Zero")
case 1: fmt.Println("One")
case 2: fmt.Println("Two")
case 3: fmt.Println("Three")
case 4: fmt.Println("Four")
case 5: fmt.Println("Five")
default: fmt.Println("Unknown Number")
}

Una sentencia switch comienza con la palabra clave switch seguida de una expresión (en este caso, i) y, a continuación, una serie de cases. El valor de la expresión se compara con la expresión que sigue a cada palabra clave case. Si son equivalentes, se ejecutan las sentencias que siguen a la :.

Al igual que una sentencia if, cada caso se comprueba de arriba abajo y se elige el primero que tenga éxito. Un conmutador también admite un caso por defecto que ocurrirá si ninguno de los casos coincide con el valor (de forma similar a como funciona else en una sentencia if ).

for, if, y switchson las principales sentencias de flujo de control. En capítulos posteriores se estudiarán otras sentencias.

Ejercicios

1. ¿Qué imprime el siguiente programa?

   i := 10
   if i > 10 {
       fmt.Println("Big")
   } else {
       fmt.Println("Small")
   }

2. Escribe un programa que imprima todos los números entre 1 y 100 que sean divisibles por 3 (es decir, 3, 6, 9, etc.).

3. Escribe un programa que imprima los números del 1 al 100, pero para los múltiplos de tres, imprima "Fizz" en lugar del número, y para los múltiplos de cinco, imprima "Buzz". Para los números que sean múltiplos tanto de tres como de cinco, imprime "FizzBuzz".