Variables y tipos en Go: var, declaración corta := y zero values

Go es un lenguaje de tipado estático: cada variable tiene un tipo concreto en tiempo de compilación y no hay conversiones implícitas entre tipos incompatibles. Esto puede sorprender al principio, pero elimina toda una categoría de errores en producción. Esta guía cubre la declaración de variables, los tipos básicos y los zero values que Go asigna cuando no inicializas un valor.

Dos formas de declarar variables

La forma explícita usa la palabra clave var:

var edad int = 30
var nombre string = "Ana"
var activo bool = true

La declaración corta con := infiere el tipo automáticamente y solo puede usarse dentro de funciones:

package main

import "fmt"

func main() {
    edad := 30
    nombre := "Ana"
    activo := true

    fmt.Println(edad, nombre, activo) // 30 Ana true
}

Fuera de una función solo funciona var. Usar := a nivel de paquete produce un error de compilación.

Tipos básicos

Go distingue entre tipos de entero con y sin signo, y entre floats de precisión simple y doble:

• int, int8, int16, int32, int64 — enteros con signo
• uint, uint8, uint16, uint32, uint64 — enteros sin signo
• float32, float64 — punto flotante (prefiere siempre float64)
• bool — verdadero o falso, sin conversión desde entero
• string — secuencia inmutable de bytes UTF-8
• byte — alias de uint8, un octeto
• rune — alias de int32, un punto de código Unicode

Zero values: Go nunca deja una variable sin inicializar

Si declaras una variable sin asignarle valor, Go le asigna el zero value de su tipo:

var i int       // 0
var f float64   // 0.0
var b bool      // false
var s string    // "" (cadena vacía)
var p *int      // nil

Esto hace que leer una variable no inicializada sea siempre seguro. En otros lenguajes podrías leer basura de memoria; en Go lees el valor neutro del tipo.

Sin conversiones implícitas

Go obliga a convertir tipos explícitamente aunque parezcan compatibles:

var x int = 10
var y float64 = 3.14

// suma := x + y // ERROR: mismatched types int and float64

suma := float64(x) + y // conversión explícita
fmt.Println(suma)      // 13.14

El error del compilador es:

invalid operation: x + y (mismatched types int and float64)

Constantes y el enumerador iota

Las constantes se declaran con const. Su valor debe ser conocido en tiempo de compilación:

const Pi = 3.14159
const Mensaje = "hola"

Dentro de un bloque const, el identificador especial iota genera secuencias numéricas automáticas. Se reinicia a 0 en cada bloque y aumenta en uno por cada constante:

type DiaSemana int

const (
    Lunes DiaSemana = iota + 1 // 1
    Martes                     // 2
    Miercoles                  // 3
    Jueves                     // 4
    Viernes                    // 5
    Sabado                     // 6
    Domingo                    // 7
)

fmt.Println(Lunes, Miercoles, Domingo) // 1 3 7

Puedes usar expresiones con iota para crear máscaras de bits o potencias de dos:

const (
    KB = 1 << (10 * (iota + 1)) // 1024
    MB                            // 1048576
    GB                            // 1073741824
)

Declaración múltiple con var

Cuando necesitas declarar varias variables relacionadas, el bloque var es más limpio que repetir la palabra clave:

var (
    host     = "localhost"
    puerto   = 5432
    timeout  = 30
    debug    = false
)