Variables y constantes en Go con inferencia de tipos

Una variable en Go es un nombre asociado a un valor de un tipo concreto. Una constante representa un valor que puede determinarse al compilar y que no cambia durante la ejecución.

En el artículo anterior vimos la estructura básica de un programa. Hoy vamos a bajar al barro para hablar de los ladrillos con los que construimos el software: las variables y las constantes.

Go es un lenguaje de tipado estático. Esto significa que, a diferencia de JavaScript o Python, una vez que defines que una caja contiene zapatos (un int), no puedes intentar meter una bufanda (un string) más tarde. El compilador te gritará y no generará el ejecutable.

Sin embargo, no siempre tenemos que escribir el tipo. Para eso están la inferencia de tipos y la declaración corta con :=.

Cuándo usar cada declaración

Declaración estándar con var

La forma más explícita y “clásica” de declarar una variable en Go es usando la palabra clave var.

La sintaxis es: var nombreVariable tipo.

package main

import "fmt"

func main() {
    var edad int = 35
    var nombre string = "Luis"

    fmt.Println(nombre, "tiene", edad, "años")
}

Fíjate en algo curioso: el tipo va al final. En C# diríamos int edad. En Go decimos var edad int. Esto se hace para mejorar la legibilidad cuando las declaraciones se vuelven complejas (como punteros a funciones).

Inferencia de tipos

Go es inteligente. Si inicializas la variable con un valor, el compilador ya sabe de qué tipo es. No hace falta que lo escribas explícitamente.

var edad = 35       // Go deduce que es int
var precio = 10.5   // Go deduce que es float64
var activo = true   // Go deduce que es bool

La declaración corta :=

Dentro de una función, Go permite omitir la palabra var y el tipo usando el operador de asignación corta :=.

func main() {
    // Declaramos e inicializamos en un solo paso
    mensaje := "Hola mundo"
    contador := 10

    fmt.Println(mensaje, contador)
}

Restricciones de :=

El operador corto tiene dos restricciones que suelen frustrar a los principiantes:

1. Solo funciona DENTRO de funciones. No puedes usarlo a nivel de paquete (variables globales). Ahí fuera debes usar var.
2. Debe declarar al menos una variable nueva. Si la variable ya existe, no puedes volver a usar :=, tienes que usar = normal.

x := 10
x := 20 // ERROR: no new variables on left side of :=
x = 20  // Correcto: simple asignación

Valores cero

En lenguajes como C o C++, si declaras una variable pero no le das valor (int a;), esa variable contiene “basura” (lo que hubiera en esa dirección de memoria). Eso es peligroso. En Java, te obliga a inicializar o te da error de compilación.

Go toma un camino diferente: los valores cero.

Cualquier variable declarada sin valor inicial se inicializa automáticamente a su valor cero predeterminado.

• int ➔ 0
• float ➔ 0.0
• bool ➔ false
• string ➔ "" (cadena vacía)
• Punteros, interfaces, funciones ➔ nil

var contador int
var mensaje string
var encendido bool

fmt.Printf("Entero: %v, String: %q, Bool: %v\n", contador, mensaje, encendido)
// Salida: Entero: 0, String: "", Bool: false

Declaración múltiple y bloques

Al igual que vimos con los imports, a Go le gusta agrupar cosas. Podemos declarar múltiples variables usando un bloque var (...). Esto es muy común para variables globales o de configuración.

var (
    nombreCurso = "Curso de Go"
    duracion    = 10
    activo      = true
)

También podemos declarar varias variables en una sola línea (paralelismo):

x, y := 10, 20
nombre, apellido := "Luis", "Llamas"

Esto último es clave porque Go permite que las funciones devuelvan múltiples valores, y los capturaremos así.

Constantes

Las constantes se declaran con const. Son valores que no pueden cambiar durante la ejecución del programa.

const Pi = 3.14159
const URLBase = "https://luisllamas.es"

Características de las constantes en Go

Las constantes en Go son un poco especiales comparadas con otros lenguajes:

1. Deben poder calcularse en tiempo de compilación. No puedes asignar a una constante el resultado de una función como math.Sqrt(4), porque eso ocurre al ejecutar el programa.
2. Tienen tipos flexibles. Una constante numérica “sin tipo” puede actuar como int o float dependiendo de dónde la uses, hasta que se le fuerza un contexto.

const maximo = 100 // Constante sin tipo explícito

func main() {
    var entero int = maximo * 10      // Funciona, maximo actúa como int
    var flotante float64 = maximo * 0.5 // Funciona, maximo actúa como float
}