Go – Variables

Introducción

Cualquier lenguaje de programación utiliza lo que se denominan variables.

Se trata de una parte esencial o básica dentro del propio lenguaje de programación, sea cual sea.

A continuación, veremos algunas cosas importantes sobre el uso de variables en Go, y de como declararlas y utilizarlas.

Aspectos a tener en cuenta

La declaración de variables dentro de nuestro código de Go, asume el uso de las variables declaradas.

Dicho de otra manera. Si declaras una variable y no la usas, tu aplicación de Go no va a compilar. Así de sencillo.

Recordemos también, que una de las características de Go es que se trata de un lenguaje tipado, sin embargo, cuando declaramos una variable podemos tiparla explícitamente o no.

Si no tipamos una variable, el propio Go será el encargado de hacerlo por nosotros siempre en tiempo de compilación, por lo que una de las recomendaciones generales es tiparla para evitar posibles problemas.

Y obviamente, una variable delarada previamente no podrá ser cambiada ni re-declarada.

Uno de los beneficios indirectos que obtenemos en el tipado de variables, es la obtención de un mejor rendimiento, ya que al contrario de los lenguajes interpretados, el compilador no necesita identificar el tipo de variable en tiempo de ejecución.

Declación de un variable en Go

Cualquier variable que declaremos explícitamente en Go se realizará a través de la palabra reservada var.

Aunque ojo, no es completamente obligatorio utilizar var como veremos más adelante.

En Go no podemos declarar una variable sin tipar como por ejemplo:

var age

Pero sí podríamos declararla inicializándola, y por lo tanto, tipándola en tiempo de compilación.

Como por ejemplo:

var age = 21

En este caso, no estaremos tipando explícitamente la variable age, pero al inicializarla, sí la estaremos tipando indirectamente. O mejor dicho, estaremos dejado que Go infiera su tipo.

Remarco lo de dejar a Go que infiera su tipo pues es algo a destacar e importante, ya que al ser Go quien infiere el tipo, podríamos encontrarnos con que esperamos un tipo de dato concreto, y luego en nuestro código, tratar de convertir o trabajar con ese dato, y tener algún problema. Es por lo tanto, algo muy cómodo, pero sobre lo que tenemos que prestar especial atención.

Pero también podemos inferir el tipo de dato de otra forma como veremos a continuación.

Antes indicaba que a la hora de declarar variables no es completamente obligatorio utilizar la palabra reservada var.

Esto lo lograremos omitiendo simplemente var y usando los caracteres := en la asignación del valor junto al valor en sí:

<name> := <value>

Por ejemplo:

department := "Administration"

Aquí también estaremos dejando a Go la responsabilidad de inferir el tipo.

Pero lo más habitual, será declarar nuestras variables tipándolas de forma regular, e indicando un valor por defecto o bien directamente como tal.

Es decir, hacerlo de esta forma:

var <name> <type>

O bien de esta otra manera:

var <name> <type> = <value>

Veamos un ejemplo de estos dos usos:

var name string = "Jorge"
var surname string
surname = "Serrano"
fmt.Printf("%v %v\n", name, surname)

Pero también podríamos encontrarnos con la necesidad de declarar varias variables del mismo tipo y al mismo tiempo, algo que Go nos permite.

Sería algo así:

var <name>, <name>, <name> <type> = <value>

Como por ejemplo:

var address, city, country string
address = "Main Street 1"
city = "Madrid"
country = "Spain"
fmt.Printf("%v - %v (%v)\n", address, city, country)

E igualmente podríamos inicializarlas, por lo que en el ejemplo anterior, el código compatible inicializando las variables quedaría de la siguiente manera:

var address, city, country string = "Main Street 1", "Madrid", "Spain"
fmt.Printf("%v - %v (%v)\n", address, city, country)

Ahora bien, puede ser que tengamos que declarar bastantes variables dentro de nuestro código, por lo que también existe la posibilidad de utilizar var anidando la declaración de todas las variables dentro de dos paréntesis.

Es decir, de esta forma:

var (
    <name> <type> = <value>
    <name> <type> = <value>
    <name> <type> = <value>
)

Como por ejemplo:

var (
    teacher string = "John"
    class string = "6A"
)

Nuestro ejemplo completo (de todo lo hablado y visto hasta ahora) quedará de esta forma:

package main

import "fmt"

func main() {
    var age = 21
    fmt.Printf("%v years old\n", age)

    department := "Administration"
    fmt.Printf("%v\n", department)

    var name string = "Jorge"
    var surname string 
    surname = "Serrano"
    fmt.Printf("%v %v\n", name, surname)
    
    var address, city, country string
    address = "Main Street 1"
    city = "Madrid"
    country = "Spain"
    //var address, city, country string = "Main Street 1", "Madrid", "Spain"
    fmt.Printf("%v - %v (%v)\n", address, city, country)

    var (
        teacher string = "John"
        class string = "6A"
    )
    fmt.Printf("%v (%v)\n", teacher, class)
}

Podrás ver y ejecutar el código del ejemplo en este enlace que te llevará a Go Playground directamente.

Aspectos avanzados sobre las variables en Go

Ahora bien, cuando hablamos de variables debemos tener en cuenta que las variables las podemos declarar dentro de una función o fuera de ella, dentro de la declaración de un flujo de código o fuera de él, etc.

La primera regla fundamental de Go es que si declaramos nuestras variables al nivel de la declaración de package, esta variable será accedida en todo el código declarado dentro del fichero del que forma parte, pero hay una particularidad especial que debemos conocer.

Si esa variable empieza por letra minúscula, entonces tendrá un alcance sólo a nivel del paquete en el que está declarado.

Pero si esa variable empieza por letra mayúscula, el alcance tendrán un alcance global, y será visible por otro paquete que acceda a éste.

Otro aspecto a destacar es el valor por defecto de inicialización en Go. Si declaramos una variable de tipo bool sin indicar valor alguno, ésta quedará inicializada a false. Si es una variable de tipo string, quedará inicializada a una cadena vacía, y si lo hacemos a un valor numérico, su valor por defecto es 0. Es decir, nuestras variables tendrán todas un valor por defecto.

Podrás encontrar el ejemplo completo de lo hablado en esta entrada, en mi repositorio de GitHub.

Happy Coding!