Mario Macías Lloret - Programación en Go

Go permite comparar expresiones numéricas ( Figura 2.2). El resultado de una comparación será un bool (true o false). Cuando se mezclan con las operaciones numéricas del apartado anterior, las operaciones de comparación son las de menor precedencia.

Figura 2.2Operadores de comparación.

El operador + aplicado entre string, retorna un nuevo string con las cadenas concatenadas:

a := "el cocherito" b := "leré" concat := a + “ " + b

En el ejemplo anterior, la variable concat contendría la cadena "el cocherito leré".

Los operadores de comparación también pueden usarse para comparar cadenas de texto.

INFORMACIÓN:Go hará distinción entre mayúsculas y minúsculas, por lo que "HOLA" == "hola" retornará false y "ZZZ" < "aaa" también retornará false, ya que el valor numérico de la Z mayúscula es menor al de la a minúscula.

Cualquier variable o expresión que retorne un bool puede combinarse con otros booleanos mediante los siguientes operadores lógicos ( Figura 2.3), resultando en otros valores booleanos. Cuando se mezclan con las operaciones de comparación del apartado anterior, las operaciones de lógica son las de menor precedencia.

Figura 2.3Operadores lógicos.

Las variables numéricas también pueden verse como agrupaciones de dígitos binarios (bits) con los que podemos realizar las siguientes operaciones, que se aplican tras comparar los bits de igual posición en dos operandos ( Figura 2.4).

Figura 2.4Operadores lógicos a nivel de bit.

El paquete fmt, del cual pudo ver una pequeña muestra en el capítulo anterior, permite mostrar datos en su terminal de línea de comandos (también llamado salida estándar)mediante las siguientes funciones:

fmt.Print fmt.Println fmt.Printf

fmt.Print y fmt.Println enviarán a la salida estándar los datos que sitúe entre paréntesis, y separados por comas, a continuación del nombre de la función. Para los datos que no sean cadenas de texto, Go hará una conversión genérica a texto antes de enviarlos a la salida estándar. Go, además, añadirá un espacio entre los diferentes datos dentro de una misma invocación a fmt.Print o fmt.Println.

Ejemplo:

x := 33 fmt.Println("Hola, número", x, "!")

Salida estándar:

Hola, número 33 !

La diferencia entre fmt.Print y fmt.Println es que fmt.Println añade un salto de línea al final. Es decir, sucesivas invocaciones a fmt.Print serían mostradas una detrás de otra, en la misma línea; mientras que sucesivas invocaciones a fmt.Println serían mostradas en diferentes líneas, una debajo de otra.

Cuando requiera un control más exhaustivo de cómo se deben mostrar los datos, la función fmt.Printf admite una cadena de texto en la que puede colocar unas “marcas de formato”, conocidas como verbos.A continuación, separados por comas, se colocan los datos que Go debe introducir en el lugar de cada uno de los verbos.

Por ejemplo, el siguiente ejemplo intercala los verbos %v, que muestran el valor de una variable, y que serán substituidos por las variables a continuación del texto de formato, en orden de aparición:

cosa := "depósito" x := 36 y := 84 fmt.Printf("Coordenadas de %v: (%v, %v)\n", cosa, x, y)

Salida estándar:

Coordenadas de depósito: (36, 84)

Observe que fmt.Printf no añade ninguna nueva línea al final, por lo que si necesita que el siguiente texto aparezca en la línea siguiente, debe finalizar la cadena de formato con el carácter especial de nueva línea: '\n'.

La tabla de la Figura 2.5muestra algunos otros verbos útiles aceptados por fmt.Printf. Para más detalles, visite la documentación del paquete fmt a través del comando godoc que se introdujo en el capítulo anterior.

Figura 2.5Algunos verbos útiles para fmt.Printf.

La entrada estándarpermite a un programa de Go obtener datos desde el exterior, a través del teclado en la línea de comandos.

Go proporciona dos funciones para obtener datos desde la entrada estándar:

fmt.Scan fmt.Scanf

fmt.Scan lee los datos del teclado y los guarda en las variables pasadas en la invocación. Cada variable debe ir precedida por el símbolo ampersand, & (sabrá el por qué cuando llegue al capítulo 4, sobre apuntadores). Por ejemplo:

varedad int fmt.Print("Edad? ") fmt.Scan(&edad) fmt.Println("Tienes", edad, "años")

Ejemplo de entrada y salida estándar:

Edad? 36 Tienes 36 años

En el ejemplo anterior, si los datos introducidos no fueran un número entero válido, ignoraría la entrada:

Edad? manuel Tienes 0 años

fmt.Scanf permite especificar con más detalle el formato de la entrada, tomando como primer parámetro una cadena de texto en la que se pueden introducir los diversos verbos (como los de la tabla de la Figura 2.5), que se colocarían en sus respectivas variables, ya que tanto fmt.Scan como fmt.Scanf aceptan múltiples variables:

varhora, minuto, segundo int fmt.Print("HH:MM:SS? ") fmt.Scanf("%d:%d:%d", &hora, &minuto, &segundo) fmt.Printf("%d horas, %d minutos, %d segundos", hora, minuto, segundo)

Ejemplo de entrada y salida estándar:

HH:MM:SS? 12:34:56 12 horas, 34 minutos, 56 segundos

Los programas de ejemplo mostrados hasta ahora seguían un “flujo secuencial”: las operaciones se ejecutan una a una, según su orden descendiente de escritura.

Como en los demás lenguajes de programación, Go permite alterar el flujo secuencial mediante los bloques de control de flujo, que se agrupan en dos tipos:

• Condicionales.Permiten que un bloque de instrucciones se ejecute o no, dependiendo de si se cumple una condición en el programa.

• Iterativos.Permiten que un bloque de instrucciones se ejecute repetidamente mientras se dé una condición.

Por “condición” entendemos cualquier expresión booleana que retorne true o false, como las mostradas en el capítulo anterior.

El bloque if permite agrupar un conjunto de instrucciones que se ejecutarán si —y solo si— su condición asociada es true. Su estructura es: