Mario Macías Lloret - Programación en Go

Un bucle es un conjunto de órdenes que se repite. El bucle más sencillo que Go permite especificar es:

El bucle anterior es un “bucle infinito”. Si un programa llega a ese punto, el programa jamás continuará más allá del bucle for, a no ser que el bucle se rompa con la instrucción break:

El ejemplo anterior repite un bucle en el que el programa pide un carácter al usuario, y se repite hasta que el usuario introduce el carácter 'S' o 's' , momento en el que el bucle se rompe mediante la instrucción break.

La instrucción continue rompe el flujo de cada iteración de un for. En este caso, el flujo del programa salta de nuevo al inicio del bucle, sin ejecutar las instrucciones restantes de la iteración en que se invoca.

El ejemplo anterior se comportaría de la siguiente manera:

Salir? (s/n): a carácter no reconocido Salir? (s/n): n Salir? (s/n): s adiós!

De acuerdo con el código del ejemplo:

• Si el usuario introduce 'N' o 'n', se ejecutará la instrucción continue, por lo que la ejecución volverá al inicio del for.

• Si el usuario introduce 'S' o 's', se ejecutará la instrucción break, por lo que el for finaliza y la ejecución continúa por el mensaje adiós!

• Solo en el caso de que el usuario introdujera cualquier otro carácter, se mostraría el mensaje carácter no reconocido.

A pesar de lo que promulgan algunas escuelas de programación de corte académico, las órdenes break y continue son totalmente válidas y aceptadas en las convenciones sobre estilo de Go. Sin embargo, a menudo resulta más limpia y útil la forma condicional de for:

Por ejemplo:

El programa anterior repetirá el código dentro del bucle mientras el usuario no introduzca 'S' ni 's'.

El lector que esté familiarizado con otros lenguajes de programación, se habrá dado cuenta de que esta forma de for “condicional” suele llamarse while en otros lenguajes de programación. Los diseñadores de Go decidieron que el código resultaría mucho más simple y legible si cualquier bucle usaba la misma orden for.

Hay una tercera forma de describir un for; la más similar al bucle for de los demás lenguajes:

Este tipo de for:

1. Ejecuta la orden de inicio una sola vez, antes de ejecutar la primera iteración.

2. Antes de cada iteración, se comprobará si la condición es cierta; en caso de que no lo sea, el bucle acabará.

3. Después de cada iteración, antes de volver a comprobar si la condición sigue siendo cierta, se ejecutará la orden de actualización.

Por ejemplo, el siguiente bucle for mostrará una cuenta del 1 al 10:

fori := 1; i <= 10; i++ { fmt.Println(i) }

4. La variable i se inicia al valor 1 (observe que el alcance de esta se limita al bucle).

5. Se muestra el valor de la variable i.

6. Se incrementa la variable i.

7. Se comprueba si el valor de i es menor o igual que 10. Si es el caso, se vuelve al paso 2. Si no es el caso, se sale del bucle for.

En el capítulo 6, sobre estructuras de datos lineales, se mostrará otro uso del bucle for, comúnmente conocido como for-each, que facilita el recorrido por los valores de diferentes colecciones de datos.

En cada instrucción condicional o cada bucle, cada vez que se define un nuevo contexto entre un par de llaves { y } es posible definir nuevas variables cuya vida y visibilidad se limitarán a ese contexto:

Si, en el ejemplo anterior, intentara mostrar el contenido de la variable i desde fuera del bloque if donde ha sido definida, el compilador le mostraría un mensaje de error.

Una característica de Go, que puede ser útil pero también puede ser una fuente de problemas, es el poder definir nuevas variables con nombres que ya existen en los contextos más globales. A pesar de tener el mismo nombre, serán variables distintas. Este concepto es conocido como “ocultación” o, en inglés, shadowing.

Ejemplo:

En un despiste, se podría pensar que la salida estándar de este programa sería a = 2, b = 2. Sin embargo, es a = 0, b = 2, ya que la variable a ha sido redeclarada y ocultada (eclipsada) dentro de la condición (observe el sutil detalle del operador de declaración := usado con a, frente al de asignación = usado con b). Por tanto, la variable a mostrada en fmt.Printf no ha sido modificada en ningún momento.

La memoria de un ordenador podría abstraerse, como si fuera un conjunto de cajones colocados en una gigantesca estantería. Cada cajón tiene un número identificativo único, que permite al ordenador referirse a él a la hora de ir a buscar o guardar datos. Dicho número identificativo se conoce como “dirección de memoria”.

Los apuntadores (o punteros) son variables que no guardan valores útiles como tales, sino las direcciones de memoria donde se encuentran dichos valores. Su nombre hace referencia al hecho de que no guardan una variable sino que “apuntan” a su dirección.

En Go, los apuntadores tienen un tipo asociado, es decir, solo pueden apuntar a variables de un tipo en concreto: un puntero a int solo podrá guardar la dirección de memoria de una variable del tipo int, un puntero a bool solo podrá guardar la dirección de memoria de un bool, etc.

Un apuntador se define como una variable, añadiendo un asterisco delante del tipo de datos al que este apuntador puede apuntar:

varpi *int // apuntador a ints varpb *bool // apuntador a bools

Los apuntadores definidos en la sección anterior no han sido inicializados a ningún valor. Apuntan al valor nil, que podría interpretarse como “a ninguna parte”.