go vet & Diagnósticos Comunes del Analizador

go vet inspecciona el código fuente de Go en busca de construcciones que compilan pero probablemente estén mal.

Cada equipo debería ejecutar go vet ./... localmente y en CI, comprender los diagnósticos comunes y saber cuándo los analizadores más profundos añaden valor.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

# Todos los paquetes del módulo
go vet ./...
 
# Paquetes específicos
go vet ./internal/...
 
# Listar analizadores disponibles (Go 1.26+)
go tool vet help
 
# Ejecutar vet a través del harness de pruebas (algunos equipos lo prefieren)
go test -vet=off ./...   # deshabilitar vet durante la prueba cuando se ejecuta por separado

Cuándo usar esto:

• Línea base de CI antes de añadir golangci-lint.
• Depuración de fallos misteriosos de printf o etiquetas JSON.
• Después de actualizar versiones menores de Go (leer las notas de la versión para nuevas verificaciones de vet).
• Enseñar a los juniors por qué el código "compila pero huele mal".

Ejemplo de Trabajo

Controlador con errores:

package api
 
import (
    "encoding/json"
    "fmt"
    "net/http"
)
 
type User struct {
    Name string `json:name` // sintaxis de etiqueta inválida
}
 
func Handler(w http.ResponseWriter, r *http.Request) {
    u := User{Name: "ada"}
    _ = json.NewEncoder(w).Encode(u)
    fmt.Printf("user %d", u.Name) // discrepancia de verbo de formato
}

Ejecutar:

go vet ./...

Salida típica:

api/handler.go:12:2: fmt.Printf format %d has arg u.Name of wrong type string
api/handler.go:8:5: struct field tag `json:name` not compatible with reflect.StructTag.Get: bad syntax for struct tag pair

Código corregido:

type User struct {
    Name string `json:"name"`
}
 
func Handler(w http.ResponseWriter, r *http.Request) {
    u := User{Name: "ada"}
    _ = json.NewEncoder(w).Encode(u)
    fmt.Printf("user %s", u.Name)
}

Lo que esto demuestra:

• Vet detecta errores de verbo de Printf sin ejecutar el programa.
• El analizador structtag valida la sintaxis de las etiquetas de struct antes de sorpresas de marshaling en producción.
• Las correcciones son cambios en el código fuente, no supresiones del linter.

Inmersión Profunda

Cómo Funciona

• Vet carga paquetes utilizando el mismo contexto de compilación que go test.
• Cada analizador es una función registrada con el controlador de vet (muchos construidos sobre go/analysis).
• Los diagnósticos incluyen archivo, línea y un mensaje legible por humanos.
• Las etiquetas de compilación, GOOS y GOARCH afectan qué archivos examina vet.

Analizadores Comunes de Vet (Representativos)

Relación con golangci-lint

El linter govet de golangci-lint envuelve los analizadores de vet y puede habilitar verificaciones adicionales.

Ejecutar go vet solo es más simple en scripts; golangci-lint centraliza la severidad y las exclusiones.

# Extracto de .golangci.yml
linters:
  enable:
    - govet
linters-settings:
  govet:
    enable-all: true

Notas de Go

// Ejemplo de copylocks - vet marca la copia de sync.Mutex
type Bad struct {
    mu sync.Mutex
}
 
func use(b Bad) { // vet: pasa el lock por valor
    b.mu.Lock()
}

Prefiere receptores de puntero o no incrustes locks en structs que se copian.

Cuando Vet No Es Suficiente

Trampas

• Asumir que vet no cambia entre actualizaciones de Go - Las nuevas versiones menores añaden verificaciones; CI puede fallar en código heredado. Solución: Leer las notas de la versión; ejecutar go vet en la rama de actualización temprano.
• Ejecutar vet solo en paquetes main - Los errores se esconden en internal/. Solución: Siempre go vet ./....
• Ignorar copylocks en rutas de acceso rápido - Pasar structs bloqueados copia el estado del mutex. Solución: Usar punteros o rediseñar la API.
• Suprimir advertencias de printf - Casi siempre es un error real. Solución: Corregir el verbo o usar %v deliberadamente con un comentario.
• Etiquetas de compilación desincronizadas entre el editor y CI - Vet omite archivos que CI no ve. Solución: Alinear las etiquetas en la configuración de gopls y las variables de entorno GOFLAGS de CI.
• Usar //nolint:govet de forma generalizada - Oculta futuros problemas reales. Solución: Reducir las supresiones a una sola línea con un ticket de justificación.

Alternativas

Preguntas Frecuentes

Relacionado

• Calidad del Código Go: Opinión por Diseño - resumen de la pila de calidad
• Conceptos Básicos de Calidad del Código - primera invocación de vet
• Configuración de golangci-lint - configuración de govet
• staticcheck & golangci-lint en CI - analizadores más profundos
• Puertas de Calidad de CI: Lint, Test, Race, Vuln - vet en el pipeline

Versiones de la Pila: Esta página fue escrita para Go 1.26.x (GC por defecto Green Tea, modernizadores de go fix - verificar parche en la compilación), chi (última - verificar en la compilación), gin (última - verificar en la compilación), echo (última - verificar en la compilación), google.golang.org/grpc (última - verificar en la compilación), sigs.k8s.io/controller-runtime (última - verificar en la compilación), kubebuilder (última - verificar en la compilación), tinygo (última - verificar objetivos de placa en la compilación), wazero (última - verificar en la compilación), y golangci-lint (última - verificar conjunto de linters en la compilación).