Mario Macías Lloret - Programación en Go

– Cuando se requiera concretar con exactitud el tamaño de una variable, se pueden usar los siguientes tipos: uint8, uinti6, uint32 o uint64.

• byte es el equivalente de uint8.

• rune es un equivalente para int32 y se usa para representar un carácter (letras, números, signos de puntuación, emojis, y un largo etcétera).

• float32 y float64 representan números de coma flotante (también llamados “números reales”) de 32 y 64 bits, respectivamente.

• complex64 y complex128 son números complejos cuyas partes real e imaginaria están representadas por números reales de 32 y 64 bits, respectivamente.

– Un literal de número complejo se escribe como en el siguiente ejemplo: 2.23 + 3i.

Go permite definir cadenas de texto explícitamente, insertando un texto cualquiera entre comillas dobles:

texto := "- Hola, ¿cómo estás?"

Si una cadena ha de contener un texto mostrado en diversas líneas, puede introducir el carácter especial de nueva línea \n allá donde quiera que termine una línea y empiece otra:

texto := "- Hola, ¿cómo estás?\n- Estoy bien, gracias."

Si una cadena ha de contener comillas dobles en su interior, estas deben especificarse como un carácter especial \", para que Go no las confunda como el final de una cadena de texto:

texto := "Podría decirse que estoy \"bien\"..."

Cuando un texto contiene múltiples líneas o comillas dobles, puede resultar más limpio substituir el delimitador de comillas dobles por el de “acento grave”; esto le permitirá escribir cadenas en múltiples líneas, tomando los saltos de línea como literales. El equivalente a la cadena anterior, sería:

texto := `- Hola, ¿cómo estás? - Estoy "bien", gracias.`

No debe confundir los delimitadores de cadenas con la comilla simple ', que sirve para especificar caracteres individuales, del tipo byte o rune.

La manera de definir una variable, dado un nombre y un tipo de dato, es:

var [ = ]

Por ejemplo:

vardias int varmeses int = 12

Las líneas anteriores definirían una variable llamada dias, del tipo int, y otra variable llamada meses, del tipo int, a la que se le asigna un valor inicial de 12.

Si no se provee un valor inicial, las variables serán inicializadas automáticamente con el “valor cero” de cada tipo de dato: 0 para tipos numéricos, false para bool, y la cadena vacía "" para string.

En aras de la brevedad, se puede omitir tanto la palabra var como su tipo si se usa el operador de inicialización :=:

meses := 12

El compilador de Go inferirá el tipo de la variable meses a un int (ya que es un número sin parte decimal), y aunque el valor de la variable cambie, el tipo siempre deberá ser int.

El símbolo := solo se puede usar para definir una variable. Una vez definida, se usará el operador de asignación = si se desea cambiar su valor. Por ejemplo:

paso := 1 // definición de la variable con un valor inicial paso = 2 // cambio del valor de la variable

Las guías de estilo de Go recomiendan declarar variables con el operador : = siempre que se pueda, aunque las variables globales y las que no tengan valor inicial deberán declararse mediante la forma precedida por var.

En Go, al contrario de lo que ocurre en otros lenguajes de tipado estático, si se quiere asignar una variable numérica a otra variable de otro tipo numérico, se deberá explicitar el tipo de destino de la siguiente manera:

varsegundos int8 = 30 varhoras int horas = int(segundos)

En el fragmento anterior, se indica a Go que el valor de la variable segundos, del tipo int8, se va a copiar en otra variable del tipo int. Aunque es obvio que cualquier valor del tipo int8 (8 bits) cabe en una variable del tipo int (32 o 64 bits), Go obliga a hacer explícita esta conversión.

Si la conversión se hace desde un tipo entero de tamaño superior al tipo de destino, se usan los bits menos significativos del tipo de origen que caben en el tipo de destino.

Si la conversión se hace desde un tipo de coma flotante, se trunca la parte con decimales y se asigna la parte entera. Por ejemplo:

distancia := 12.78 kms := int(distancia)

En el ejemplo anterior, la variable kms tomará el valor 12 (eliminando, sin redondeo alguno, el 0.78 de la variable original).

Una constante es un valor literal al que se le asigna un nombre, que no puede cambiar durante la vida del programa. Su definición es similar a la de una variable, pero reemplazando la palabra var por la palabra const. Por ejemplo:

constPi = 3.1416

o

constPi float64 = 3.1416

Cuando se definen múltiples constantes, se pueden agrupar semánticamente bajo la misma directiva const. Por ejemplo:

Además de la comúnmente usada base decimal (en la que cada dígito puede tomar diez valores distintos, del 0 al 9), Go permite usar otros tipos de bases de numeración según el prefijo que añadamos a cada número ( Figura 2.1).

Figura 2.1Bases de numeración en Go.

Cuando queramos agrupar bloques de dígitos, podemos insertar un guión bajo “_” entre estos. Go no lo tendrá en cuenta a la hora de establecer el valor.

Ejemplos:

productoInteriorBruto := 1_419_000_000_000 bitsAgrupados := 0b_1000_1001_0110

Go permite hacer las siguientes operaciones con tipos de datos númericos, por orden de precedencia:

1. Agrupaciones de operaciones, delimitadas por paréntesis.

2. Multiplicaciones, divisiones (operadores * y /), así como el resto de la división entera (o módulo, operador %).

3. Sumas y restas (operadores + y -).

El orden de precedencia hace referencia a qué operaciones se evalúan primero, cuando una expresión compleja engloba múltiples operaciones. Primero, se evalúan las operaciones de mayor precedencia. En caso de múltiples operaciones con la misma precedencia, estas se evalúan según su posición en la expresión, de izquierda a derecha.

Por ejemplo, dada la siguiente expresión:

a := 8 + 3 * (1 + 2) % 5

1. Primero evaluaría la expresión entre paréntesis, ya que es la de mayor precedencia: a := 8 + 3 * 3 % 5

2. Luego evaluaría la multiplicación y el módulo. Al ser de la misma precedencia, primero evaluaría la multiplicación, ya que está más a la izquierda: a := 8 + 9 % 5

3. Y continuaría por el resto de la división entera: a := 8 + 9

4. Siendo la suma la operación de menos precedencia, sería la última en evaluarse: a := 12

Además de los anteriores operadores matemáticos, Go provee los operadores de incremento (++) y decremento (--), que van detrás de una variable que se quiere incrementar o decrementar, respectivamente:

a := 10 b := 20 a++ b--

Después de ejecutar el anterior programa, la variable a contendría el valor 11 y la variable b contendría el valor 19.

A diferencia de otros lenguajes de programación con los que el lector pueda estar familiarizado, los operadores de incremento y decremento no pueden ir dentro de otras expresiones.