Introducción a las variables en Go

Introducción

¿Por qué necesitamos variables en los lenguajes de programación de computadoras? Esta es una pregunta antigua. Así como podemos recordar que la URL de LabEx es labex.io, los programas de computadora también necesitan recordar algunos datos para su uso.

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

Puntos de conocimiento:

• Declaración de variables
• Inicialización de variables
• Uso de variables
• Tiempo de vida de las variables
• Constantes

Skills Graph

¿Qué es una variable?

¿Qué es una variable? En términos simples, una variable es un contenedor utilizado para almacenar un dato mutable.

En 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 fijos.

Si una variable se utiliza para contener frutas, solo debe contener frutas. Una vez que el contenedor ha almacenado frutas, no se puede utilizar para contener galletas. Esto se refleja en el código como una variable no puede ser asignada con dos tipos diferentes de datos.

Mutabilidad de las variables

Como su nombre indica, el valor de una variable puede cambiar, siempre y cuando el cambio no exceda el rango permitido por su tipo.

El lenguaje Go tiene las siguientes reglas para las variables:

• El nombre debe consistir en letras, dígitos y guiones bajos.
• El identificador de la variable no puede comenzar con un dígito.
• El identificador no puede ser una palabra clave reservada. Ver palabras clave reservadas
• Los nombres de las variables distinguen entre mayúsculas y minúsculas, pero no se recomienda utilizar diferentes mayúsculas y minúsculas para distinguir entre dos variables con el mismo nombre.

Método general de declaración

En el lenguaje Go, la palabra clave utilizada para declarar variables de forma general es var.

La forma de declaración es: var identificador tipo, lo que significa:

var nombreVariable tipoVariable.

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

Dado que los tipos de variables no son el foco de esta sección, solo se enumeran los tres tipos más comunes.

Más tipos se explicarán en los siguientes cursos.

¿Cómo declaramos una variable?

Ahora declaremos una variable entera llamada a.

var a int

¿Cómo recordarlo? Puedes decir en silencio en tu mente:

Define una variable llamada `a`, que es de tipo int.

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

Esta forma de declarar variables hace que el código sea más fácil de leer de izquierda a derecha y evita la lógica de lectura en espiral del lenguaje C. Para más detalles, 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, debemos prestar atención a su expresividad y evitar el uso de abreviaturas.

Aquí presentaremos brevemente el método básico de nomenclatura de variables: Convención de nomenclatura en Camel Case.

La convención de nomenclatura en Camel Case utiliza letras en mayúsculas y minúsculas para representar una variable. La primera palabra está en minúsculas y la primera letra de cada palabra subsiguiente está en mayúsculas.

Por ejemplo: currentDate. La primera palabra, current, está en minúsculas y la segunda palabra, Date, comienza con una letra mayúscula.

De esta manera, una variable que representa la fecha actual es fácil de entender.

Esta convención de nomenclatura se utiliza generalmente para variables importantes y comúnmente utilizadas, mientras que las variables temporales se pueden simplificar siempre que no causen duplicación.

Método de declaración por lotes

Ahora declaremos 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 observadores habrán notado que las tres variables, a, b, c, son de tipo int.

En ese caso, podemos usar 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é pasa 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

Parece que nos encontramos en una situación similar cuando importamos paquetes. Se necesitan importar juntos muchos paquetes con diferentes nombres, así que podemos usar un método de escritura similar:

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 por defecto

En Go, todas las variables reciben valores iniciales cuando se declaran. ¡Exploremos cuáles son los valores iniciales de las variables!

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

touch ~/project/varExercise.go

Escribe 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)
}

Puedes probar a ejecutarlo tú mismo y ver si coincide con la tabla siguiente.

go run varExercise.go

Los tipos de valores iniciales se resumen como sigue:

Inicialización estándar

Dado que el tipo de una variable se puede determinar por su valor inicial, ¿podemos cambiar el valor predeterminado o el 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 necesitamos agregar = después de declarar la variable, seguida de un valor inicial que sea compatible con el tipo de la variable. Si quieres cambiar el valor, simplemente usa el nombre de la variable seguido de = y otro valor del mismo tipo.

Modifica 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, la salida es la siguiente:

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

Puedes probar a ejecutarlo tú mismo y modificar los valores iniciales.

Acabamos de mencionar que el valor inicial asignado a una variable debe ser del mismo tipo que la declaración de la variable. ¿Qué pasará si son diferentes?

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

package main

import "fmt"

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

Ejecuta 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 la figura, no podemos asignar un tipo de cadena como "labex" a una variable de tipo int. Esto se debe a que Go es un lenguaje compilado de tipado fuerte y no se puede compilar.

Declaración de tipo por inferencia

Dado que Go puede determinar el tipo de una variable por su valor inicial, ¿podemos simplificar el proceso de declaración de tipo eliminando el paso de especificar explícitamente el tipo?

package main

import "fmt"

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

Ahora ni siquiera necesitas usar la palabra clave var para definir una variable.

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

a, b, c := 0
// Declare variables a, b, c as integers and assign an initial value of 0
a, b, c := 0, "", true
// Declare variables a, b, c as integer, string, and boolean, respectively

La declaración corta es muy conveniente, pero ten cuidado de que := no es una operación de asignación. Es una forma de declarar variables y es exclusiva de Go, utilizada para declarar e inicializar variables locales dentro de una función. El tipo de la variable se inferirá automáticamente en función de la expresión.

A veces escribimos el siguiente código:

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

El compilador te dirá que hay un error en el código porque la variable a ha sido redeclarada. Sin embargo, si se escribe de la siguiente manera:

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

Hay tal salida porque la a con valor 1 de arriba y la a con valor 2 de abajo no están en el mismo ámbito de variable (dentro de las mismas llaves), por lo que el compilador las trata como dos variables diferentes.

El compilador no te señalará el error, pero habrá una salida inesperada.

En Go, se establece que:

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

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

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

Esto involucra el concepto de tiempo de vida de las variables, que se explicará en la siguiente sección.

Ámbito de las variables

El ámbito de una variable se refiere al rango en el que una variable en un programa es efectiva, es decir, cómo se puede utilizar.

Seguramente habrás notado que si declaras una variable pero no la usas, el código no se compilará.

En otras palabras, cuando Go se compila, verifica si cada variable ha sido utilizada, es decir, si se ha utilizado dentro de su ámbito.

Podemos dividir simplemente las variables en tres tipos según su posición de declaración:

• 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 definició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 la función, como a definida dentro de la función main. El ámbito de la variable a se limita a dentro de la función main.

Al mismo tiempo, si la variable no se utiliza en la función main, el compilador arrojará 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 la función y su ámbito abarca todo el programa. Incluso si no se llaman en ninguna función, el compilador no reportará un error.

Puedes pensar en por qué las variables globales no producen errores incluso si no se llaman.

Los detalles sobre las variables de parámetros formales se explicarán en los próximos cursos relacionados con las funciones.

Tiempo de vida de las variables

"Las aves que se alejan ocultan su vuelo. Los conejos astutos mueren y los sabuesos se cocinan." - Registros del Gran Historiador

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

• Variables globales: El tiempo de vida de una variable global es consistente con el tiempo de ejecución de todo el programa. Cuando el programa deja de ejecutarse, la variable global se elimina de la memoria.
• Variables locales: Cuando no hay forma de acceder a una variable, su espacio de memoria será recuperado.

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

Durante el tiempo de vida de una variable, no se puede redeclarar.

Puedes 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ás el siguiente mensaje de error:

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

El compilador nos dice que a se define nuevamente.

Constantes

Muchas cosas en la vida son como constantes. Podemos percibirlas pero no cambiarlas.

Si una variable no cambiará durante todo el tiempo de ejecución del programa, entonces debemos definirla como una constante.

Las constantes son muy similares a las variables, e incluso puedes pensar en ellas como variables con valores inmutables.

Al declarar una constante, solo necesitamos reemplazar la palabra clave var por la palabra clave const.

const Pi = 3.14159 // Using type inference initialization

¿Qué pasará 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)
}

Ejecuta el código.

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

El compilador nos dice que el valor de Pi no se puede reasignar.

Al declarar una constante, debemos proporcionar un valor inicial.

Y el valor inicial asignado a una constante debe ser fijo en tiempo de compilación.

En Go, los valores de retorno de funciones definidas por el usuario no se consideran 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

Si una declaración de constante es válida se puede resumir en la siguiente tabla:

Resumen

Repasemos lo que aprendimos en este laboratorio:

• Las formas de declarar variables
• Las formas de inicializar variables
• El concepto de tiempo de vida de las variables
• El uso de constantes y si sus declaraciones son válidas

En este laboratorio, hemos repasado el uso básico de las variables en Go, demostrado las formas de declarar y usar variables en diferentes situaciones e introducido las constantes.