Cómo usar variables y constantes en Go

Las variables son un concepto de programación que es importante dominar. Son símbolos que sustituyen valores que se usan en un programa.

En este tutorial, se abarcarán algunos aspectos básicos de variables y las prácticas recomendadas para utilizarlos en los programas de Go que cree.

Información sobre variables

En términos técnicos, una variable asigna una ubicación de almacenamiento a un valor vinculado a un nombre o identificador simbólico. Usamos el nombre de variable para hacer referencia a ese valor almacenado en un programa informático.

Podemos concebir una variable como una etiqueta con nombre, que se vincula a un valor.

Supongamos que tenemos un número entero, 103204948, y queremos almacenar esta larga cifra en una variable en lugar de volver a escribirla una y otra vez. Para hacerlo, podemos usar un nombre fácil recordar, como la variable i. Para almacenar un valor en una variable, usaremos la siguiente sintaxis:

i := 1032049348

Podemos imaginar esta variable como una etiqueta que está vinculada al valor.

La etiqueta tiene escrito el nombre de una variable i y está vinculada al valor entero 1032049348.

La frase i := 1032049348 es una instrucción de declaración y asignación que consta de algunas partes:

• el nombre de la variable (i)
• la instrucción de declaración de variable corta (​​​​​​:=​​​​​​)
• el valor vinculado al nombre de la variable (1032049348)
• el tipo de datos inferido por Go (int)

Más adelante, veremos la manera de establecer el tipo de forma explícita en la siguiente sección.

Juntas, estas partes conforman la instrucción que establece que la variable i es igual al valor del número entero 1032049348.

En el momento en que se establece una variable igual a un valor, se inicia o se crea esa variable. Una vez que lo hagamos, estaremos listos para usar la variable en lugar del valor.

Una vez que establezcamos que i es igual al valor 1032049348, podremos usar i en lugar del número entero, por lo que lo imprimiremos:

package main

import "fmt"

func main() {
	i := 1032049348
	fmt.Println(i)
}

Output
1032049348

Mediante variables también se pueden realizar cálculos de forma rápida y sencilla. Con i := 1032049348, podemos restar el valor entero 813 con la siguiente sintaxis:

fmt.Println(i - 813)

Output
1032048535

En este ejemplo, Go hace los cálculos por nosotros y resta 813 a la variable i para mostrar la suma 1032048535.

Ya que mencionamos los cálculos, las variables pueden configurarse de modo que sean iguales al resultado de una ecuación matemática. También puede añadir dos números juntos y almacenar el valor de la suma en la variable x:

x := 76 + 145

Posiblemente haya observado que este ejemplo se asemeja a uno de álgebra. Así como usamos letras y otros símbolos para representar números y cantidades en fórmulas y ecuaciones, las variables son nombres simbólicos que representan el valor de un tipo de datos. Para corregir la sintaxis de Go, deberá asegurarse que su variable esté en el lado izquierdo de cualquier ecuación.

Imprimiremos x:

package main

import "fmt"

func main() {
	x := 76 + 145
	fmt.Println(x)
}

Output
221

Go mostró el valor 221 porque la variable x se estableció en un valor igual a la suma de 76 y 145.

Las variables pueden representar cualquier tipo de datos, no solo números enteros:

s := "Hello, World!"
f := 45.06
b := 5 > 9 // A Boolean value will return either true or false
array := [4]string{"item_1", "item_2", "item_3", "item_4"}
slice := []string{"one", "two", "three"}
m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}

Si imprime cualquiera de estas variables, Go mostrará lo que es equivalente a esa variable. Trabajar con la instrucción de asignación para el tipo de datos slice de cadena:

package main

import "fmt"

func main() {
	slice := []string{"one", "two", "three"}
	fmt.Println(slice)
}

Output
[one two three]

Asignamos el valor de slice de []string{"one", "two", "three"} a la variable slice y luego usamos la función fmt.Println para imprimir ese valor llamando a slice.

Las variables funcionan quitando una área pequeña de memoria de su computadora que acepta valores especificados, los cuales luego se asocian con ese espacio.

Declarar variables

En Go, hay varias formas de declarar una variable y, en algunos casos, más de una forma de declarar exactamente la variable y el valor idénticos.

Podemos declarar una variable llamada i del tipo de datos int sin iniciarla. Esto significa que declararemos un espacio para ubicar un valor, pero no le daremos un valor inicial:

var i int

Esto crea una variable del tipo de datos int declarada como i.

Podemos inicializar el valor usando el operador igual (=), como en el siguiente ejemplo:

var i int = 1

En Go, las dos formas de instrucción se denominan declaraciones variables largas.

También podemos usar una declaración variable corta:

i := 1

En este caso, contamos con una variable llamada i y un tipo de datos int. Cuando no especifiquemos un tipo de datos, Go lo inferirá.

Con las tres formas de declarar variables, la comunidad de Go adoptó los siguientes idiomas:

• Utilice únicamente una forma larga, var i int, cuando no inicialice la variable.

• Utilice la forma corta, i := 1, en la declaración y el inicio.

• Si no desea que Go infiera su tipo de datos, pero de todos modos quiere usar una declaración variable corta, puede ajustar su valor en el tipo que desee con la siguiente sintaxis:

i := int64(1)

No se considera idiomático en Go el uso del formulario de instrucción variable larga cuando se inicia el valor:

var i int = 1

Es recomendable mantenerse al corriente sobre la manera en que la comunidad de Go declara variables para que otros puedan leer sus programas sin problemas.

Valores cero

Todos los tipos incorporados tienen un valor cero. Cualquier variable asignada se puede usar incluso cuando nunca tenga un valor asignado. Podemos ver los valores cero para los siguientes tipos:

package main

import "fmt"

func main() {
	var a int
	var b string
	var c float64
	var d bool

	fmt.Printf("var a %T = %+v\n", a, a)
	fmt.Printf("var b %T = %q\n", b, b)
	fmt.Printf("var c %T = %+v\n", c, c)
	fmt.Printf("var d %T = %+v\n\n", d, d)
}

Output
var a int =  0
var b string = ""
var c float64 = 0
var d bool = false

Usamos el verbo %T en la instrucción fmt.Printf. Esto indica a la función que imprima el data type de la variable.

En Go, debido a que todos los valores tienen un valor zero, no puede haber valores undefined como en otros lenguajes. Por ejemplo, un boolean en algunos lenguajes podría ser undefined, true o false, lo que permite tres estados para la variable. En Go, no podemos exceder el valor de estados two para un valor boolean.

Nombrar variables: reglas y estilos

La asignación de nombres a variables es bastante flexible, pero hay reglas que se deben tener en cuenta:

• Los nombres de variables solo deben constar de una palabra (no deben llevar espacios).
• Deben contener solo letras, números y guiones bajos (_).
• No pueden comenzar con un número.

Siguiendo estas reglas, observaremos los nombres de variables válidos y no válidos:

Además, al asignar nombres a variables tenga en cuenta que se distinguen mayúsculas y minúsculas. Estos nombres ​​​1​​​userName​​​1​​​, ​​​2​​​USERNAME​​​2​​​, ​​​3​​​UserName​​​3​​​ y ​​​4​​​uSERnAME​​​4​​​ son variables completamente diferentes. Es recomendable evitar usar nombres de variables similares en un programa para garantizar que tanto usted como sus colaboradores, actuales y futuros, puedan mantener sus variables de forma correcta.

Si bien para las variables se distinguen mayúsculas y minúsculas, el caso de la primera letra de una variable tiene un significado especial en Go. Si una variable comienza con una letra mayúscula, se puede acceder a dicha variable fuera del paquete en el que se declaró (o recibió el valor exported). Si una variable comienza con una letra minúscula, solo está disponible dentro del paquete en el que se declara.

var Email string
var password string

Email comienza con una letra mayúscula y otros paquetes pueden acceder a él. password comienza con minúscula y el acceso a ella solo es posible dentro del paquete en el que se declara.

En Go, es común utilizar nombres de variables muy concisos (o cortos). Dada la opción entre userName y user para una variable, sería idiomático elegir user.

El ámbito también desempeña un papel en la unidad del nombre de variable. La regla es que cuanto más pequeño es el ámbito de la variable, más pequeño es el nombre de esta:

names := []string{"Mary", "John", "Bob", "Anna"}
for i, n := range names {
	fmt.Printf("index: %d = %q\n", i, n)
}

Utilizamos la variable names en un ámbito más amplio, por lo que sería normal darle un nombre más significativo para ayudar a recordar lo que representa en el programa. Sin embargo, usamos las variables i y n inmediatamente en la siguiente línea de código, y luego no las volvemos a usar. Debido a esto, no confundirá a alguien que lea el código respecto de dónde se usan las variables o qué significan.

A continuación, veremos algunas notas sobre el estilo de las variables. El estilo consiste en usar MixedCaps o mixedCaps en lugar de guiones bajos para nombres de varias palabras.

Lo más importante respecto del estilo es preservar la uniformidad y que el equipo del que forma parte esté de acuerdo acerca de este.

Volver a asignar variables

Como la plantea la palabra “variable”, podemos cambiar variables de Go. Esto significa que podemos conectar un valor diferente y una variable previamente asignada realizando nuevamente una asignación. Es útil renovar una asignación porque durante el curso de un programa, es posible que debamos aceptar valores generados por los usuarios en variables ya inicializadas. Es posible que también deba cambiar la asignación por algo previamente definido.

Saber que es posible podemos volver a asignar una variable puede ser útil al trabajar en un programa de gran magnitud que alguien más escribió y en el cual no están claras las variables ya definidas.

Asignaremos el valor de 76 a una variable llamada i del tipo int y luego le asignaremos un nuevo valor de 42:

package main

import "fmt"

func main() {
	i := 76
	fmt.Println(i)

	i = 42
	fmt.Println(i)
}

Output
76
42

En este ejemplo se muestra que podemos primero asignar a la variable i el valor de un número entero y luego podemos volver a asignar a esta variable i un valor; esta vez, el 42.

Debido a que Go es un lenguaje typed, no podemos asignar un tipo a otro. Por ejemplo, no podemos asignar el valor “Sammy” a una variable de tipo int:

i := 72
i = "Sammy"

Tratar de asignar diferentes tipos entre sí provocará un error en el tiempo de compilación:

Output
cannot use "Sammy" (type string) as type int in assignment

Go no nos permitirá usar un nombre de variable más de una vez:

var s string
var s string

Output
s redeclared in this block

Si intentamos usar una instrucción variable corta más de una vez para el mismo nombre de variable, también observaremos un error de compilación. Esto puede ocurrir por equivocación, por lo cual entender el mensaje de error es útil:

i := 5
i := 10

Output
no new variables on left side of :=

Casi como en el caso de una declaración de variable, tener en cuenta el nombre de sus variables mejorará la legibilidad de su programa para usted y otros, cuando la vuelva a revisarla en el futuro.

Asignación múltiple

Go también nos permite asignar varios valores a diferentes variables dentro de la misma línea. Cada uno de estos valores puede ser de un tipo de datos diferente:

j, k, l := "shark", 2.05, 15
fmt.Println(j)
fmt.Println(k)
fmt.Println(l)

Output
shark
2.05
15

En este ejemplo, la variable j se asignó a la cadena “shark”, la variable k se asignó al flotante 2.05 y la variable l se asignó al número entero 15.

Este enfoque para asignar varias variables a diferentes valores en una línea puede hacer que la cantidad de líneas de su código se mantenga en un valor bajo. Sin embargo, es importante no comprometer la legibilidad por menos líneas de código.

Variables globales y locales

Al usar variables dentro de un programa, es importante tener en cuenta el ámbito de variable. El ámbito de una variable se refiere a espacios concretos desde los cuales es posible acceder a ella dentro del código de un programa determinado. Esto es decir que no es posible el acceso a todas las variables desde todas las partes de un programa determinado; algunas variables serán globales y algunas locales.

Las variables globales existen fuera de las funciones. Las locales existen dentro de las funciones.

Veamos las variables globales y locales en acción:

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global

Aquí usamos var g = "global"para crear una variable global fuera de la función. Luego definimos la función ​​​1​​​printLocal(). Dentro de la función, se asigna una variable local llamada l que luego se imprime. El programa se cierra llamando a printLocal() e imprimiendo la variable global g.

Debido a que g es una variable global, podemos hacer referencia a ella en printLocal(). Modificaremos el programa anterior para hacerlo:

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
	fmt.Println(g)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global
global

Comenzamos declarando una variable global g, var g = "global". En la función main, llamaremos a la función printLocal, que declara una variable local l e imprime fmt.Println(l). Luego, printLocal imprime la variable global g, fmt.Println(g). Aunque g no se definió en printLocal, podría acceder a ella debido a que se declaró en un alcance global. Por último, la función main imprime g también.

Ahora, intentaremos invocar la variable local fuera de la función:

package main

import "fmt"

var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	fmt.Println(l)
}

Output
undefined: l

No podemos usar una variable local fuera de la función en la que se asigne. Si intenta hacerlo, verá un error undefined cuando realice la compilación.

Veamos otro ejemplo en el que usamos el mismo nombre de variable para una variable global y una local:

package main

import "fmt"

var num1 = 5

func printNumbers() {
	num1 := 10
	num2 := 7  

	fmt.Println(num1)
	fmt.Println(num2)
}

func main() {
	printNumbers()
	fmt.Println(num1)
}

Output
10
7
5

En este programa, declaramos la variable num1 dos veces. Primero, declaramos num1 en el ámbito global, var num1 = 5, y otra vez dentro del alcance local de la función printNumbers, num1 := 10. Cuando imprimimos num1 desde el programa main, vemos el valor 5 impreso. Esto se debe a que main solo detecta la declaración de variable global. Sin embargo, cuando imprimimos num1 de la función printNumbers, esta detecta la instrucción local e imprime el valor 10. Aunque printNumbers crea una nueva variable llamada num1 y le asigna un valor de 10, esto no afecta a la instancia global de num1 con el valor 5.

Al trabajar con variables, también deberá tener en cuenta las partes de su programa que necesitarán acceso a cada variable y adoptar una variable global o local correspondiente. En diferentes programas de Go, verá que las variables locales son normalmente más comunes.

Constantes

Las constantes son como variables, con la excepción de que no pueden modificarse una vez declaradas. Las constantes son útiles para definir un valor que se usará más de una vez en su programa, pero que no debería poder cambiar.

Por ejemplo, si queremos declarar la tasa impositiva para un sistema de carritos de compras, podríamos usar una constante y luego calcular los impuestos en diferentes áreas de nuestro programa. En algún momento del futuro, si el impuesto se modifica solo deberemos cambiar ese valor en un punto de nuestro programa. Si usamos una variable, es posible que cambiemos el valor accidentalmente en algún lugar de nuestro programa, lo que provocaría un cálculo inadecuado.

Para declarar una constante, podemos usar la siguiente sintaxis:

const shark = "Sammy"
fmt.Println(shark)

Output
Sammy

Si intentamos modificar una constante después de que se declare, veremos un error en tiempo de compilación:

Output
cannot assign to shark

Es posibe que las constantes no tengan el valor untyped. Esto puede ser útil al trabajar con números como los datos de tipo entero. Si la constante tiene el valor untyped, se convierte de forma explícita. esto no es posible en el caso de las constantes con el valor typed. Veamos la forma de usar constantes:

package main

import "fmt"

const (
	year     = 365
	leapYear = int32(366)
)

func main() {
	hours := 24
	minutes := int32(60)
	fmt.Println(hours * year)    
	fmt.Println(minutes * year)   
	fmt.Println(minutes * leapYear)
}

Output
8760
21900
21960

Si declara una constante con un tipo, se tratará de ese tipo exacto. Aquí, cuando declaramos la constante leapYear la definimos como elemento del tipo de datos int32. Por lo tanto, es una constante typed. Esto significa que solo puede funcionar con tipos de datos int32. Declaramos la constante year sin tipo, por lo que se considera untyped. Debido a esto, puede utilizarla con cualquier tipo de datos de números enteros.

Cuando se definió hours, infirió que era de tipo int porque no le asignamos de forma explícita un tipo, hours := 24. Cuando declaramos minutes, la declaramos de forma explícita como int32, minutes := int32(60).

Ahora, revisaremos cada cálculo y la razón por la que funciona:

hours * year

En este caso, hours es int y years es untyped. Cuando el programa realiza la compilación, de forma explícita convierte years en int, lo cual permite que la operación de multiplicación tenga éxito.

minutes * year

En este caso, minutes es int32 y year es untyped. Cuando el programa realiza la compilación, de forma explícita convierte years en int32, lo cual permite que la operación de multiplicación tenga éxito.

minutes * leapYear

En este caso, minutes es int32 y leapYear es una constante typed de int32. En este caso, el compilador no deberá intervenir debido a que ambas variables ya son del mismo tipo.

Si intentamos multiplicar dos tipos typed que no son compatibles, el programa no realizará la compilación:

fmt.Println(hours * leapYear)

Output
invalid operation: hours * leapYear (mismatched types int and int32)

En este caso, hours se infirió como int y leapYear se declaró explícitamente como int Debido a que Go es un lenguaje “typed”, int y un int32 no son compatibles para operaciones matemáticas. Para multiplicarlos, necesitaría convertir uno a int32 o int.

Conclusión

A lo largo de este tutorial, revisamos algunos de los casos de uso común de variables dentro de Go. Las variables son un componente importante de la programación y sirven como símbolos que reemplazan valores de tipos de datos que usamos en un programa.