Introducción a las variables de Go

Introducción

¿Por qué necesitamos variables en los lenguajes de programación? Esta es una pregunta muy antigua. Del mismo modo que podemos recordar que la URL de LabEx es labex.io, los programas también necesitan recordar algunos datos para utilizarlos.

El propósito de las variables es representar un dato. En esta sección, explorará cómo se utilizan las variables en el lenguaje Go.

Conceptos clave:

Declaración de variables
Inicialización de variables
Uso de variables
Ciclo de vida de las variables
Constantes

¿Qué es una variable?

En este paso, aprenderá qué representan las variables y cómo Go restringe sus nombres y tipos.

¿Qué es una variable? En términos sencillos, una variable es un contenedor que se utiliza para almacenar y guardar un dato mutable.

En los lenguajes compilados, como Go, el tipo de una variable es fijo.

¿Qué significa que el tipo de una variable sea fijo?

Significa que una variable solo puede contener un tipo de dato. En otras palabras, los elementos almacenados en el contenedor de la variable son de un tipo fijo.

Si una variable se utiliza para almacenar frutas, solo debe contener frutas. Una vez que el contenedor ha almacenado frutas, no puede utilizarse para guardar galletas. En el código, esto significa que una variable no puede recibir datos de dos tipos diferentes.

Mutabilidad de las variables

Como indica su nombre, el valor de una variable puede cambiar, siempre que el cambio no supere el intervalo permitido por su tipo.

El lenguaje Go aplica las siguientes reglas a las variables:

El nombre debe estar compuesto por letras, dígitos y guiones bajos.
El identificador de la variable no puede comenzar por un dígito.
El identificador no puede ser una palabra clave reservada. Consulte las palabras clave reservadas
Los nombres de variables distinguen entre mayúsculas y minúsculas, pero no se recomienda utilizar distintas mayúsculas para diferenciar dos variables con el mismo nombre.

Método de declaración general

En este paso, aprenderá a declarar una variable con tipo mediante la palabra clave var.

En Go, la palabra clave utilizada para declarar variables mediante el método general es var.

La forma de declaración es var identifier type, lo que significa:

var variableName variableType.

¿Cuáles son los tipos de variables más comunes en Go?

Palabra clave	Explicación
`int`	Entero. El tipo de dato más común, que se enseña en las matemáticas de primaria.
`string`	Cadena. Una secuencia de caracteres entre comillas dobles, por ejemplo: `"hello,world"`
`bool`	Booleano. Representa verdadero o falso, con dos valores posibles: `true` o `false`

Como los tipos de variables no son el objetivo principal de esta sección, solo se enumeran los tres tipos más comunes.

En los cursos siguientes se explicarán más tipos.

¿Cómo declaramos una variable?

Ahora declare una variable entera llamada a.

var a int

¿Cómo puede recordarlo? Puede decirse mentalmente:

Define a variable named `a`, which is of type int.

A diferencia de muchos lenguajes de programación tradicionales, en Go el tipo de la variable se coloca después del nombre de la variable.

Esta forma de declarar variables facilita la lectura del código de izquierda a derecha y evita la lógica de lectura en espiral del lenguaje C. Para obtener más información, consulte la documentación oficial.

¿Qué nombre debemos dar a una variable?

Un buen nombre de variable debe indicar claramente el significado de la variable.

Al nombrar variables, debe prestar atención a su expresividad y evitar las abreviaturas.

A continuación se presenta brevemente el método básico para nombrar variables: la convención de nombres Camel Case.

La convención Camel Case utiliza letras en mayúsculas y minúsculas combinadas para representar una variable. La primera palabra comienza con minúscula y la primera letra de cada palabra posterior se escribe en mayúscula.

Por ejemplo: currentDate. La primera palabra, current, comienza con minúscula y la segunda palabra, Date, comienza con mayúscula.

De esta forma, se entiende fácilmente que la variable representa la fecha actual.

Esta convención de nombres se utiliza generalmente para variables importantes y de uso frecuente. Las variables temporales pueden simplificarse siempre que no provoquen duplicaciones.

Método de declaración por lotes

En este paso, aprenderá a declarar varias variables juntas.

Ahora declare tres variables:

var a int // Declare an integer variable named a
var b int // Declare an integer variable named b
var c int // Declare an integer variable named c

Los estudiantes atentos quizá hayan observado que las tres variables, a, b, c, son de tipo int.

En ese caso, puede utilizar una coma para conectar los nombres de las variables y reducir la cantidad de código.

var a, b, c int // Declare three variables a, b, c as integers

Pero ¿qué ocurre si las tres variables tienen tipos diferentes?

var a int    // Declare an integer variable named a
var b string // Declare a string variable named b
var c bool   // Declare a boolean variable named c

Es posible que haya encontrado una situación similar al importar paquetes. Como es necesario importar juntos muchos paquetes con nombres diferentes, puede utilizar una forma de escritura parecida:

var (
    a int
    b string
    c bool
)

Tenga en cuenta que este tipo de declaración, similar a la importación de paquetes, se utiliza generalmente para definir variables globales.

Inicialización predeterminada

En este paso, examinará los valores predeterminados que Go asigna a las variables.

En Go, todas las variables reciben valores iniciales cuando se declaran. ¡Explore cuáles son esos valores iniciales!

Cree un archivo llamado varExercise.go en el directorio ~/project.

touch ~/project/varExercise.go

Escriba el siguiente código en el archivo:

package main

import "fmt"

func main() {
    var a int
    var b string
    var c bool
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

Puede ejecutarlo y comprobar si el resultado coincide con la tabla siguiente.

go run varExercise.go

Los valores iniciales se resumen de la siguiente manera:

Palabra clave	Explicación	Valor inicial
`int`	Entero	0
`string`	Cadena	`""`
`bool`	Booleano	`false`

Inicialización estándar

En este paso, inicializará variables explícitamente y, después, les asignará nuevos valores.

Como Go puede determinar el tipo de una variable a partir de su valor inicial, ¿podemos cambiar el valor predeterminado o el valor de una variable ya declarada?

var a int = 1
var b string = "labex"
var c bool = true

a = 233
b = "labex"
c = false

Como se muestra arriba, solo debe añadir = después de declarar la variable y, a continuación, proporcionar un valor inicial compatible con el tipo de la variable. Si desea cambiar el valor, utilice el nombre de la variable seguido de = y otro valor del mismo tipo.

Modifique el archivo varExercise.go:

package main

import "fmt"

func main() {
    // Declare and initialize
    var a int = 1
    var b string = "labex"
    var c bool = true

    // Print the variables
    fmt.Println("Before modification:")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)

    // Modify the variables
    a = 233
    b = "labex"
    c = false

    // Print the modified variables
    fmt.Println("After modification:")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

Después de ejecutar el código, el resultado es el siguiente:

$ go run varExercise.go
Before modification:
1
labex
true
After modification:
233
labex
false

Puede ejecutarlo y modificar los valores iniciales.

Antes hemos mencionado que el valor inicial asignado a una variable debe tener el mismo tipo que el declarado para la variable. ¿Qué ocurre si son diferentes?

Por ejemplo, asigne "labex" como valor inicial de la variable a:

package main

import "fmt"

func main() {
    var a int = "labex"
    fmt.Println(a)
}

Ejecute el código:

$ go run varExercise.go
## command-line-arguments
./varExercise.go:6:12: cannot use "labex" (type untyped string) as type int in assignment

Como se muestra en el resultado, no podemos asignar una cadena como "labex" a una variable de tipo int. Esto se debe a que Go es un lenguaje compilado y fuertemente tipado, por lo que el código no se puede compilar.

Declaración del tipo mediante inferencia

En este paso, aprenderá a declarar variables locales mediante la inferencia de tipos y el operador :=.

Como Go puede determinar el tipo de una variable a partir de su valor inicial, ¿podemos simplificar la declaración del tipo eliminando el paso de especificarlo explícitamente?

package main

import "fmt"

func main() {
    // var a int = 1
    var a = 1 // Type is inferred
    fmt.Println(a)
}

Ahora ni siquiera necesita utilizar la palabra clave var para definir una variable.

Esta forma de declarar e inicializar una variable también puede combinarse con el método de declaración por lotes:

a, b, c := 0, 0, 0
// Declare variables a, b, c as integers and assign 0 to each variable.

También puede inicializar las variables con valores de tipos diferentes:

a, b, c := 0, "", true
// Declare variables a, b, c as integer, string, and boolean, respectively.

Cada variable situada a la izquierda de := necesita un valor inicial correspondiente a la derecha.

La declaración corta resulta muy cómoda, pero tenga cuidado: := no es una operación de asignación. Es una forma de declarar variables propia de Go, que se utiliza para declarar e inicializar variables locales dentro de una función. El tipo de la variable se infiere automáticamente a partir de la expresión.

A veces escribimos el siguiente código:

func main() {
    a := 1
    println(a)
    a := 2
    println(a)
}

El compilador le indicará que hay un error porque la variable a se ha vuelto a declarar. Sin embargo, si se escribe de la siguiente forma:

func main() {
    a := 1
    if true {
        a := 2
        println(a) // Output: 2
    }
    println(a) // Output: 1
}

El resultado es ese porque la a con valor 1 de arriba y la a con valor 2 de abajo no están en el mismo ámbito de variables, es decir, dentro de las mismas llaves. Por ello, el compilador las trata como dos variables diferentes.

El compilador no señalará el error, pero el resultado será inesperado.

En Go se establece lo siguiente:

Cada instrucción situada fuera de una función debe comenzar con una palabra clave (var, func, etc.).

Por lo tanto, la declaración corta de variables solo puede utilizarse para declarar variables locales y no puede utilizarse para declarar variables globales.

Entonces, ¿qué es una variable global y qué es una variable local?

Esto se relaciona con el concepto de ciclo de vida de las variables, que se explicará en la siguiente sección.

Ámbito de las variables

En este paso, comparará los ámbitos de las variables locales, las variables globales y los parámetros formales.

El ámbito de una variable es el intervalo en el que la variable es válida dentro de un programa, es decir, dónde puede utilizarse.

Seguramente habrá observado que, si declara una variable pero no la utiliza, el código no se compila.

En otras palabras, cuando Go compila el código, comprueba si se ha utilizado cada variable, es decir, si se ha utilizado dentro de su ámbito.

Podemos dividir las variables en tres tipos según la posición en la que se declaran:

Variables definidas dentro de una función, llamadas variables locales
Variables definidas fuera de una función, llamadas variables globales
Variables definidas dentro de la declaración de una función, llamadas parámetros formales

Variables locales

En esta sección, la mayoría de las variables que definimos son variables locales:

package main

import "fmt"

func main() { // Function body
    var a int = 1 // Local variable
    fmt.Println(a)
}

Las variables locales se definen dentro del cuerpo de una función, como a, que se define dentro de la función main. El ámbito de la variable a se limita a la función main.

Además, si la variable no se utiliza en la función main, el compilador generará un error.

Variables globales

Sin embargo, también es posible definir una variable global.

package main

import "fmt"

var a int = 1 // Global variable
func main() { // Function body
    fmt.Println(a)
}

Las variables globales se definen fuera del cuerpo de una función y su ámbito abarca todo el programa. Aunque no se utilicen en ninguna función, el compilador no notificará ningún error.

Piense por qué las variables globales no producen errores aunque no se utilicen.

Respuesta

Esto se debe a que la variable global puede utilizarse desde otro paquete.

Los detalles sobre las variables de parámetros formales se explicarán en cursos posteriores relacionados con las funciones.

Ciclo de vida de las variables

En este paso, aprenderá durante cuánto tiempo permanecen accesibles las variables y por qué una variable no puede volver a declararse en el mismo ámbito.

Los pájaros que vuelan lejos ocultan el arco. Los conejos astutos mueren, y los sabuesos acabarán guisados. - Registros del Gran Historiador

Cuando una variable ha cumplido su propósito, debe destruirse para reducir el uso de memoria.

Variables globales: el ciclo de vida de una variable global coincide con todo el tiempo de ejecución del programa. Cuando el programa deja de ejecutarse, la variable global se elimina de la memoria.
Variables locales: cuando ya no existe ninguna forma de acceder a una variable, se recupera el espacio de memoria que ocupa.

Este diseño es clave para el alto rendimiento de Go y el uso eficiente del espacio.

Durante el ciclo de vida de una variable, esta no puede volver a declararse.

Puede escribir lo siguiente en varExercise.go:

package main

import "fmt"

func main() {
    var a int = 1 // Local variable, lifetime is limited to the entire main function
    var a int = 2 // Redefinition
    fmt.Println(a)
}

Después de ejecutar el código:

go run varExercise.go

Verá el siguiente mensaje de error:

./varExercise.go:7:9: a redeclared in this block
previous declaration at ./varExercise.go:6:9

El compilador indica que a se ha definido de nuevo.

Constantes

En este paso, declarará constantes e identificará qué expresiones son valores constantes válidos.

Muchas cosas de la vida se parecen a las constantes. Podemos percibirlas, pero no podemos cambiarlas.

Si una variable no va a cambiar durante toda la ejecución del programa, debe definirla como una constante.

Las constantes son muy similares a las variables; incluso puede pensar en ellas como variables con valores inmutables.

Al declarar una constante, solo debe sustituir la palabra clave var por la palabra clave const.

const Pi = 3.14159 // Using type inference initialization

Cree un archivo llamado constExercise.go en el directorio ~/project.

touch ~/project/constExercise.go

¿Qué ocurre si intentamos modificar una constante?

package main

import "fmt"

func main() {
    const Pi = 3.14159
    Pi = 2 // Error: cannot assign to Pi
    fmt.Println(Pi)
}

Ejecute el código.

$ go run constExercise.go
## command-line-arguments
./constExercise.go:7:8: cannot assign to Pi

El compilador indica que el valor de Pi no se puede asignar de nuevo.

Al declarar una constante, debe proporcionar un valor inicial.

Además, el valor inicial asignado a una constante debe estar determinado en tiempo de compilación.

En Go, los valores devueltos por funciones definidas por el usuario no se consideran valores fijos.

var a int = 1
// Value is fixed, declaration is valid.
const Pi = 3.14159
// The calculated value is also fixed, the declaration is valid.
const c = 1 / Pi
// Fixed return value from built-in function is valid.
const le = len("labex")
// The return value of the user-defined function is not fixed, the declaration is invalid.
const le = getLen("labby")
// `a` is a variable value that is not fixed, the declaration is invalid.
const k = a

La validez de una declaración de constante puede resumirse en la siguiente tabla:

Tipo de declaración	Válida
Valores fijos y expresiones con valores fijos	Válida
Valores no fijos (variables) y sus expresiones correspondientes	No válida
La función integrada (`len()`) recibe un valor fijo y expresiones con valores fijos	Válida
Funciones definidas por el usuario	No válida

Resumen

Repasemos lo que aprendió en este laboratorio:

Las formas de declarar variables
Las formas de inicializar variables
El concepto de ciclo de vida de las variables
El uso de constantes y la validez de sus declaraciones

En este laboratorio hemos repasado el uso básico de las variables en Go, hemos mostrado distintas formas de declarar y utilizar variables en diferentes situaciones y hemos presentado las constantes.