En Go, si declaras una variable o importas un paquete y no lo utilizas, el compilador no te dará un simple aviso o warning; te lanzará un error de compilación que detendrá el proceso por completo. Esto significa que el programa simplemente no se ejecutará hasta que limpies ese código sobrante.
Esta decisión de diseño responde a la filosofía de mantener un código siempre limpio y eficiente. El compilador te obliga a ser intencional: si algo no se usa, no debería estar en el código. Esto evita la acumulación de “código muerto” y reduce la deuda técnica desde el primer segundo, asegurando que las dependencias en el binario final sean estrictamente las necesarias. Si dejas una variable sin usar, lo único que romperá es tu flujo de trabajo (go build), impidiéndote generar el ejecutable hasta que resuelvas la inconsistencia.
¿Cuándo es realmente necesario saltarse esta regla? Solo cuando quieras ignorar explícitamente un valor o cuando necesites que un paquete ejecute sus funciones de configuración automática (efectos secundarios) sin llamar a ninguna de sus funciones directamente. Para ello, utilizamos el identificador en blanco _, que le dice al compilador: “Soy consciente de esto, pero no quiero usarlo”.
package main
import (
"fmt"
// Usamos '_' para importar un paquete solo por sus efectos secundarios
// (como registrar un driver de base de datos), evitando el error de "no usado".
_ "math/cmplx"
)
func main() {
// 1. Variable declarada y usada correctamente
mensaje := "Sistema listo"
fmt.Println(mensaje)
// 2. Una función que devuelve dos valores: el resultado y un error.
// Si solo nos interesa el resultado, usamos '_' para descartar el error.
// Si no usáramos '_', el compilador nos obligaría a manejar el error o a usarlo.
valor, _ := realizarOperacion()
fmt.Printf("El valor procesado es: %d\n", valor)
// 3. El uso del blank identifier para descartar valores explícitamente.
// Esto es útil cuando una función te devuelve algo que no necesitas en este contexto.
_ = "Este valor se descarta para satisfacer al compilador"
fmt.Println("Proceso finalizado con éxito")
}
// realizarOperacion simula una función que devuelve un valor y un posible error.
func realizarOperacion() (int, error) {
return 100, nil
}
En el código anterior, observa cómo manejamos la rigidez del compilador. Primero, la variable mensaje se usa directamente en fmt.Println, por lo que todo es correcto. Cuando llamamos a realizarOperacion, esta función devuelve dos valores: un entero y un error. Para evitar el error de “variable no usada” con el segundo valor, empleamos _ en la asignación valor, _ := .... Esto le comunica al runtime que el segundo parámetro es irrelevante para nosotros en este punto.
También verás _ "math/cmplx". En Go, muchos paquetes se importan de esta manera para ejecutar su función init() (que configura drivers o registros internos) sin necesidad de llamar a ninguna de sus constantes o funciones. Sin ese guion bajo, el compilador se quejaría de que el paquete math/cmplx ha sido importado pero no utilizado. Finalmente, la línea _ = "..." es la forma de decirle al compilador: “Sé que esta cadena no se está usando, pero quiero que el código sea válido”.
El error frecuente
Un error muy común cuando se está empezando es dejar variables “olvidadas” durante el proceso de desarrollo.
package main
import "fmt"
func main() {
x := 10 // Declaras x
// fmt.Println(x) // Si comentas esta línea mientras pruebas, el build fallará
fmt.Println("Hola")
}
Si comentas la línea donde se usa x, al intentar ejecutar go run main.go, verás un error similar a: x declared and not used. Esto puede ser frustrante si estás haciendo pruebas rápidas, pero es lo que garantiza que tu código de producción no tenga basura acumulada.
N° 16