Lenguaje Go: qué es Golang, para qué sirve y ejemplos

Go es un lenguaje de programación compilado y de tipado estático creado en Google. Produce un único binario nativo, compila en segundos, tiene recolección de basura y trae la concurrencia integrada en el lenguaje mediante goroutines y channels. Su terreno principal es el software de servidor: APIs, servicios de red y las herramientas de línea de comandos y de la nube que los hacen funcionar.

Aquí tienes un programa Go completo. Pulsa Run.

package main

import (
	"fmt"
	"strings"
)

func main() {
	languages := []string{"Go", "Python", "Rust"}

	for i, name := range languages {
		fmt.Printf("%d: %s has %d letters\n", i, name, len(name))
	}

	fmt.Println(strings.ToUpper("compiled, typed, garbage collected"))
}

Todo programa Go empieza en package main, en func main(). := declara una variable e infiere su tipo (aquí []string, un slice de strings). range recorre el slice y te da un índice y un valor. fmt y strings vienen de la librería estándar, que es lo bastante amplia como para que muchos programas no importen nada más.

Go frente a Golang: el nombre

El lenguaje se llama Go. "Golang" es un apodo que viene del primer sitio web del proyecto, golang.org (ahora el sitio está en go.dev). La gente lo siguió usando porque buscar "go" en la web devuelve de todo menos el lenguaje. La documentación oficial dice "Go", pero "golang" es el término que casi todo el mundo escribe en un buscador, y los dos significan lo mismo. No existe un producto ni un dialecto "Golang" aparte.

Quién creó Go y por qué

Robert Griesemer, Rob Pike y Ken Thompson empezaron a diseñar Go en Google en 2007. Se publicó como código abierto en noviembre de 2009, y Go 1.0 salió en marzo de 2012.

La motivación fue práctica. Las grandes bases de código en C++ y Java de Google tardaban mucho en compilar, los grafos de dependencias eran difíciles de gestionar, y las máquinas multinúcleo y los servicios en red eran lo normal, pero escribir código concurrente era propenso a errores. El diseño de Go responde directamente a esos problemas:

• Compilación rápida. Los imports son explícitos, un import sin usar es un error de compilación y el compilador no vuelve a analizar cabeceras, así que los programas grandes compilan en segundos.
• Un lenguaje sencillo. Pocas palabras clave, un solo bucle (for), sin herencia, sin excepciones. El código escrito por personas distintas tiende a parecerse, lo que ayuda en las revisiones de un equipo grande.
• La concurrencia como característica del lenguaje. Lanzar una tarea concurrente es una palabra clave, go, y los channels permiten que las tareas se comuniquen.
• Despliegue sencillo. El resultado es un binario que copias a un servidor. Normalmente está enlazado de forma estática; con cgo activado, paquetes como net pueden enlazarse con la librería C del sistema, y CGO_ENABLED=0 lo desactiva.

Go 1.0 llegó también con la promesa de compatibilidad de Go 1: los programas escritos para Go 1.0 siguen compilando y ejecutándose con las versiones 1.x posteriores. En la práctica, actualizar la toolchain rara vez rompe tu código, y es una de las grandes razones por las que los equipos confían en Go para servicios de larga vida.

Para qué se usa Golang

Go brilla donde un programa habla con una red, se ejecuta durante mucho tiempo y tiene que ser fácil de distribuir:

Encaja peor en apps de escritorio con interfaz gráfica, apps móviles, front ends de navegador y trabajo numérico o de machine learning, donde otros ecosistemas tienen librerías mucho mejores.

Características clave, con código

Tipos estáticos con inferencia

Cada variable tiene un tipo fijado en tiempo de compilación, pero rara vez lo escribes. := lo infiere:

package main

import "fmt"

func main() {
	count := 3         // int
	price := 9.99      // float64
	name := "keyboard" // string
	inStock := true    // bool

	fmt.Printf("%T %T %T %T\n", count, price, name, inStock)

	total := float64(count) * price
	fmt.Printf("%d x %s = %.2f\n", count, name, total)
}

Go nunca convierte entre tipos numéricos en silencio. count * price no compila, porque uno es int y el otro float64; escribes tú float64(count). Eso descarta los bugs silenciosos de truncado y de precisión.

Los errores son valores

Go no tiene excepciones. Una función que puede fallar devuelve un error como último resultado, y quien la llama lo comprueba:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	inputs := []string{"42", "forty-two"}

	for _, s := range inputs {
		n, err := strconv.Atoi(s)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		fmt.Println("parsed:", n*2)
	}
}

El patrón if err != nil es la línea más reconocible del código Go. Es verboso, y esa es la idea: cada sitio donde un programa puede fallar se ve allí donde ocurre. Consulta manejo de errores para envolver e inspeccionar errores.

Goroutines y channels

Una goroutine es una función que se ejecuta de forma concurrente con el resto del programa. Cuesta unos pocos kilobytes de pila, así que ejecutar miles es normal. Los channels pasan valores entre goroutines de forma segura:

package main

import "fmt"

func square(n int, results chan<- string) {
	results <- fmt.Sprintf("%d squared is %d", n, n*n)
}

func main() {
	results := make(chan string)

	for n := 1; n <= 3; n++ {
		go square(n, results)
	}

	for range 3 {
		fmt.Println(<-results)
	}
}

Las tres goroutines se ejecutan de forma concurrente, así que las tres líneas pueden imprimirse en cualquier orden. Ejecútalo varias veces y puede que veas órdenes distintos. main recibe exactamente tres valores, así que espera a todos antes de terminar.

Interfaces sin "implements"

Un tipo cumple una interfaz simplemente por tener los métodos adecuados. No existe la palabra clave implements:

package main

import (
	"fmt"
	"math"
)

type Shape interface {
	Area() float64
}

type Rect struct{ W, H float64 }
type Circle struct{ R float64 }

func (r Rect) Area() float64   { return r.W * r.H }
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }

func main() {
	shapes := []Shape{Rect{W: 3, H: 4}, Circle{R: 1}}
	for _, s := range shapes {
		fmt.Printf("%T area: %.2f\n", s, s.Area())
	}
}

Rect y Circle nunca mencionan Shape, y aun así los dos pueden guardarse en un []Shape. Esto te permite definir una interfaz en el paquete que la usa, mucho después de que se escribieran los tipos concretos.

Una sola toolchain

El comando go lo hace todo: go run compila y ejecuta, go build crea un binario, go test ejecuta los tests, go fmt formatea el código, go vet detecta construcciones sospechosas y go mod gestiona las dependencias. Hay un único estilo de formato oficial, impuesto por gofmt, así que en los proyectos Go nadie discute sobre llaves ni sangrías.

Lo que Go deja fuera a propósito

Algunas características habituales en otros lenguajes faltan a propósito:

• Sin clases ni herencia. Usas structs, métodos, interfaces y embedding.
• Sin excepciones. Los errores son valores devueltos. panic existe, pero es para bugs, no para fallos normales.
• Sin operador ternario. Escribes un if/else.
• Sin la palabra clave while. for cubre todos los bucles.
• Sin sobrecarga de funciones ni argumentos por defecto.
• Genéricos solo desde Go 1.18, y deliberadamente limitados en comparación con las plantillas de C++ o los genéricos de Java.

Contrapartidas, sin rodeos

Verbosidad. Las comprobaciones explícitas de errores y la falta de atajos como el operador ternario hacen que el código Go sea más largo que su equivalente en Python o Kotlin. Leerlo es fácil; escribirlo lleva más líneas.

Recolección de basura. El recolector de Go tiene pausas cortas, pero sigue siendo un recolector de basura. Para sistemas de tiempo real estricto o código donde importa cada reserva de memoria, C, C++ o Rust te dan más control.

Valores nil. Go tiene punteros, maps, slices e interfaces nil. Desreferenciar un puntero nil es un panic en tiempo de ejecución, y el compilador no lo impide como hace el sistema de tipos de Rust.

Un sistema de tipos pequeño. Sin tipos suma, sin enums (los construyes con constantes e iota) y con unos genéricos que cubren los casos habituales pero no la programación avanzada a nivel de tipos.

Huecos en el ecosistema. Las librerías para servicios web, bases de datos y APIs de la nube son excelentes. Para interfaces gráficas, computación científica y machine learning, Python, C++ o Julia tienen mucho más.

Go comparado con otros lenguajes

Elige Go cuando quieras el rendimiento de un lenguaje compilado y un despliegue sencillo sin la curva de aprendizaje de Rust ni la ceremonia de Java.

¿Merece la pena aprender Go?

Si escribes servicios de backend, herramientas de línea de comandos o cualquier cosa del mundo de la infraestructura en la nube, sí. Buena parte de ese ecosistema está escrita en Go, y leer su código fuente forma parte del trabajo. El lenguaje es pequeño, así que la inversión es modesta: la sintaxis básica lleva días, y la concurrencia y el manejo de errores idiomáticos, unas semanas de práctica.

Para empezar a escribir Go en local, instala Go y luego sigue la página de hola mundo, que explica cada línea de un primer programa.