Primeros pasos con Go

Lección 1 de 8. En veinte minutos vas a tener Go instalado, un programa funcionando y una idea clara de por qué el compilador te va a regañar más de lo que esperas. Esto último no es un defecto: es el rasgo que más define al lenguaje.

El programa más pequeño que existe

Crea una carpeta vacía y dentro un archivo main.go:

package main

import "fmt"

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

Tres piezas, y las tres son obligatorias:

Antes de ejecutar: el módulo

Go necesita saber cómo se llama lo que estás construyendo. Eso se declara una sola vez, al principio:

go mod init ejemplo/saludo

salidago: creating new go.mod: module ejemplo/saludo

Aparece un archivo go.mod de dos líneas con ese nombre y la versión de Go. Un módulo es simplemente una carpeta con un go.mod dentro: a partir de ahí, todo lo que cuelgue es tu proyecto, y ahí se irán anotando las dependencias si algún día usas alguna.

El nombre puede ser cualquiera mientras el proyecto sea tuyo y local. Si algún día lo publicas, se usa la ruta del repositorio, como github.com/usuario/saludo, porque es así como lo encontrarán los demás.

Ejecutarlo

Hay dos maneras y conviene saber cuándo usar cada una.

go run .

salidaHola, Go

go run compila y ejecuta en un paso, dejando el binario en una carpeta temporal. Es lo que vas a usar mientras aprendes y mientras pruebas cosas.

go build -o hola .
./hola

salidaHola, Go

go build deja el ejecutable en el disco. Ese archivo pesa un par de megas y no depende de nada: puedes copiarlo a otra máquina con el mismo sistema y funciona, sin instalar Go allí.

Lo que más sorprende al principio: el compilador no perdona

Go considera errores de compilación dos cosas que en otros lenguajes son, como mucho, un aviso. La primera, importar algo y no usarlo:

import (
	"fmt"
	"os"      // importado y nunca usado
)

no compila./main.go:5:2: "os" imported and not used

La segunda, declarar una variable local y no leerla nunca:

func main() {
	total := 10      // declarada y nunca usada
	fmt.Println("hola")
}

no compila./main.go:6:2: declared and not used: total

La primera vez irrita. Después se agradece: esos dos avisos son la firma del código a medio terminar, y al convertirlos en errores el lenguaje garantiza que lo que compila está, al menos, completo. Si de verdad necesitas una variable que no usas, el guion bajo le dice al compilador «ya lo sé, déjalo pasar»: _ = total.

El formato no se discute

Go trae un formateador, gofmt, y define un único estilo correcto. No es configurable, y esa es justamente la idea: nadie discute dónde van las llaves porque no hay nada que discutir. Escribe esto, con el formato que quieras:

package main

import "fmt"
func main(){
x:=3
fmt.Println( x )
}

Y pásale el formateador:

gofmt feo.go

salidapackage main

import "fmt"

func main() {
	x := 3
	fmt.Println(x)
}

Tabuladores para indentar, espacio tras las comas, línea en blanco entre bloques. Casi todos los editores lo ejecutan al guardar; si usas Visual Studio Code con la extensión oficial de Go, ya viene activado. Déjalo así y no vuelvas a pensar en el formato.

La caja de herramientas, de un vistazo

Lo que hay que llevarse

Un archivo con package main y una func main(), un go.mod al lado y go run . para probar. Con eso ya puedes escribir cualquier cosa de la lección siguiente. Y una idea de fondo que va a repetirse en todo el curso: cuando Go te parezca estricto o escaso, casi siempre es a propósito.

Todo el código de esta lección se compiló y ejecutó con Go 1.25 antes de publicarla, incluidos los dos errores: están provocados a propósito y los mensajes son los que devuelve el compilador, copiados literalmente.