Instalación y primer programa de Go

Instalación del entorno de desarrollo

La instalación de Go se realiza descargando el instalador oficial desde go.dev/dl. El sitio ofrece binarios precompilados para los principales sistemas operativos: Linux, macOS y Windows. El proceso de instalación varía según la plataforma, pero en todos los casos el resultado es el mismo: un directorio con el compilador, las herramientas y la biblioteca estándar.

En Linux y macOS, el método más habitual consiste en descargar el archivo comprimido y extraerlo en /usr/local:

# Descargar y extraer
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go<version>.linux-amd64.tar.gz

# Añadir al PATH (en .bashrc, .zshrc o equivalente)
export PATH=$PATH:/usr/local/go/bin

En Windows, el instalador .msi configura automáticamente la variable de entorno PATH. Tras la instalación, basta con abrir una nueva terminal.

Para verificar que la instalación es correcta:

go version

Este comando muestra la versión instalada del compilador. Adicionalmente, go env muestra todas las variables de entorno que Go utiliza, como GOPATH (directorio de trabajo) y GOROOT (ubicación del SDK).

La instalación de Go incluye el compilador, las herramientas de desarrollo (go build, go test, go fmt) y la biblioteca estándar completa. No se necesitan dependencias adicionales para empezar a desarrollar.

Configuración del workspace

Go organiza el código en módulos. Un módulo es un directorio con un archivo go.mod que declara el nombre del módulo y sus dependencias. Para inicializar un nuevo proyecto:

mkdir mi-proyecto
cd mi-proyecto
go mod init ejemplo.com/mi-proyecto

El archivo go.mod generado contiene el nombre del módulo y la versión mínima de Go requerida:

module ejemplo.com/mi-proyecto

go 1.22

Este archivo es la base del sistema de gestión de dependencias de Go. Cualquier paquete externo que se importe se registrará automáticamente aquí.

Estructura básica de un programa Go

Un programa ejecutable en Go requiere tres elementos fundamentales: la declaración del paquete main, las importaciones necesarias y la función main como punto de entrada.

package main

import "fmt"

func main() {
    fmt.Println("Hola, mundo")
}

La declaración package main indica que este archivo forma parte de un programa ejecutable. Todo programa en Go debe tener exactamente un paquete main con una función main. Esta función no recibe parámetros ni devuelve valores.

El paquete fmt (abreviatura de format) pertenece a la biblioteca estándar y proporciona funciones para formatear texto y realizar operaciones de entrada/salida. La función Println imprime una línea de texto seguida de un salto de línea.

Importaciones

Las importaciones se declaran con la palabra clave import. Cuando se necesitan varios paquetes, se agrupan en un bloque con paréntesis:

import (
    "fmt"
    "os"
    "strings"
)

Go es estricto con las importaciones: el compilador produce un error si se importa un paquete que no se utiliza en el código. Esta restricción mantiene el código limpio y evita dependencias innecesarias.

Es posible asignar un alias a una importación para evitar conflictos de nombres o abreviar el uso:

import (
    r "math/rand"
    _ "net/http/pprof"  // Importación por efecto lateral
)

El alias _ se utiliza cuando se necesita ejecutar el código de inicialización (init()) de un paquete sin utilizar directamente sus funciones.

Funciones y múltiples valores de retorno

Las funciones en Go se declaran con la palabra clave func. Una característica destacada es la capacidad de devolver múltiples valores, algo habitual para retornar un resultado junto con un posible error:

func dividir(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("división por cero")
    }
    return a / b, nil
}

func main() {
    resultado, err := dividir(10, 3)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Printf("Resultado: %.2f\n", resultado)
}

Este patrón de retornar (valor, error) es una convención central en Go que se utiliza en toda la biblioteca estándar y en el ecosistema del lenguaje.

Compilación y ejecución

Go proporciona dos comandos principales para transformar código fuente en programas ejecutables: go build y go run.

go run compila y ejecuta el programa en un solo paso. Es ideal durante el desarrollo para probar cambios de forma rápida:

go run main.go

go build genera un binario ejecutable que puede distribuirse y ejecutarse de forma independiente:

go build -o mi-app main.go
./mi-app

El binario generado por go build es autocontenido: incluye todo lo necesario para ejecutarse, sin depender de un runtime o máquina virtual. Esto simplifica el despliegue en servidores y contenedores.

Compilación cruzada

Go soporta compilación cruzada de forma nativa, lo que permite generar binarios para diferentes sistemas operativos y arquitecturas desde una misma máquina. Las variables GOOS y GOARCH controlan la plataforma de destino:

# Compilar para Linux desde cualquier sistema
GOOS=linux GOARCH=amd64 go build -o mi-app-linux main.go

# Compilar para Windows
GOOS=windows GOARCH=amd64 go build -o mi-app.exe main.go

# Compilar para macOS ARM
GOOS=darwin GOARCH=arm64 go build -o mi-app-mac main.go

La compilación cruzada no requiere herramientas adicionales ni cadenas de compilación (toolchains) externas. Go incluye todo lo necesario para compilar a cualquier plataforma soportada.

Gestión de dependencias

El comando go mod tidy sincroniza el archivo go.mod con las importaciones reales del código, añadiendo dependencias necesarias y eliminando las que ya no se usan:

go mod tidy

Para añadir una dependencia externa, basta con importarla en el código y ejecutar go mod tidy, o bien instalarla explícitamente:

go get github.com/gorilla/mux@latest

El paquete main y la función main

El paquete main tiene un papel especial en Go: es el único que genera un programa ejecutable. Cualquier otro nombre de paquete produce una biblioteca reutilizable, no un ejecutable.

Dentro del paquete main, la función main() es el punto de entrada exacto del programa. El runtime de Go la invoca automáticamente al arrancar, y cuando esta función termina, el programa finaliza.

package main

import (
    "fmt"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Uso: programa <nombre>")
        os.Exit(1)
    }
    fmt.Printf("Hola, %s\n", os.Args[1])
}

Algunas reglas importantes sobre main:

• No recibe parámetros: los argumentos de línea de comandos se acceden a través de os.Args.
• No devuelve valores: para indicar un código de salida, se utiliza os.Exit(n).
• Es única: solo puede existir una función main en el paquete main.
• No se puede invocar: el runtime la ejecuta automáticamente al inicio del programa.

La función init

Go permite definir una función especial init() en cualquier archivo fuente. Esta función se ejecuta automáticamente antes de main() y se utiliza para inicializar estado global, validar configuración o registrar recursos:

package main

import "fmt"

var config string

func init() {
    config = "produccion"
    fmt.Println("Inicializando configuración...")
}

func main() {
    fmt.Printf("Entorno: %s\n", config)
}

La función init() no recibe parámetros ni devuelve valores. Un mismo paquete puede tener múltiples funciones init() distribuidas en varios archivos, y Go las ejecuta todas en un orden determinístico basado en el nombre de los archivos.