Fundamentos de Características Avanzadas del Lenguaje

10 ejemplos para empezar con Características Avanzadas del Lenguaje - 7 básicos y 3 intermedios.

Prerrequisitos

• Go 1.26.x o posterior y un módulo: go mod init example.com/advlang.
• Crea una carpeta assets/ junto a los paquetes que usan go:embed.
• Compila con go build / go run .; establece GOOS / GOARCH para ejercitar archivos de plataforma.
• Lee Más allá de la especificación: Embed, Modos de Compilación y Ensamblaje para tener una visión general.

Ejemplos Básicos

1. Incrustar un solo archivo como cadena

Incorpora un archivo de configuración en el binario en tiempo de compilación.

package main
 
import (
    _ "embed"
    "fmt"
)
 
//go:embed assets/version.txt
var version string
 
func main() {
    fmt.Println("version:", version)
}

• //go:embed debe estar inmediatamente encima de una variable string, []byte o embed.FS.
• La ruta es relativa al directorio del archivo fuente.
• Cambiar el archivo requiere una recompilación; no hay recarga en caliente.

Relacionado: //go:embed para Archivos y Plantillas - Patrones FS y de plantillas

2. Incrustar un directorio con embed.FS

Sirve múltiples archivos desde un sistema de archivos en memoria.

package main
 
import (
    "embed"
    "fmt"
    "io/fs"
)
 
//go:embed assets/*
var content embed.FS
 
func main() {
    data, err := fs.ReadFile(content, "assets/hello.txt")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))
}

• Las rutas de embed.FS usan barras inclinadas hacia adelante e incluyen el prefijo del directorio incrustado.
• Usa fs.Sub para eliminar un prefijo para http.FileServer o template.ParseFS.
• Los archivos ocultos y las rutas .. se rechazan en tiempo de compilación.

3. Restricción de compilación moderna en un archivo

Compila un archivo solo en Linux.

//go:build linux
 
package main
 
import "fmt"
 
func platform() string { return "linux" }
 
func main() {
    fmt.Println(platform())
}

• Prefiere //go:build sobre los comentarios heredados // +build en código nuevo.
• Combina tags con &&, || y ! (por ejemplo, linux && amd64).
• Los archivos sin restricciones se compilan en todas las plataformas.

Relacionado: Restricciones de Compilación y Archivos Específicos de Plataforma - convenciones de sufijos

4. Sufijo de archivo para GOOS

Deja que el toolchain elija main_windows.go vs main_unix.go automáticamente.

// main_unix.go
//go:build unix
 
package main
 
func greeting() string { return "unix" }

// main_windows.go
//go:build windows
 
package main
 
func greeting() string { return "windows" }

// main.go
package main
 
import "fmt"
 
func main() {
    fmt.Println(greeting())
}

• Sufijos como _linux.go y _amd64.go implican restricciones sin una línea explícita.
• Mantén la lógica compartida en archivos neutrales; pon las diferencias en archivos etiquetados.
• Ejecuta go list -f '{{.GoFiles}}' . para ver qué archivos seleccionó una compilación.

5. Tag personalizado para pruebas de integración

Controla pruebas costosas con -tags integration.

//go:build integration
 
package myapp_test
 
import "testing"
 
func TestLiveAPI(t *testing.T) {
    t.Log("se ejecuta solo con -tags integration")
}

• Ejecuta con go test -tags=integration ./....
• CI puede usar tags predeterminados localmente y tags de integración en un trabajo nocturno.
• Documenta los tags requeridos en README o en objetivos de Makefile.

6. Listar modos de compilación disponibles

Inspecciona qué soporta go tool en tu instalación.

go help buildmode

go build -buildmode=exe -o bin/app .
file bin/app

• Modos comunes: exe (predeterminado), c-archive, c-shared, plugin, shared.
• plugin y algunos modos están limitados por OS/arch.
• Los lanzamientos de producción deben fijar la línea exacta de go build en los logs de CI.

Relacionado: Flags del Enlazador y Opciones de buildmode - guía modo por modo

7. Eliminar información de depuración con ldflags

Reduce los binarios de lanzamiento omitiendo las tablas de símbolos.

go build -ldflags="-s -w" -o bin/app .
ls -lh bin/app

• -s omite la tabla de símbolos; -w omite la información de depuración DWARF.
• Pierdes algo de conveniencia de perfilado y depuración en binarios eliminados.
• Empareja con compilaciones de depuración separadas para respuesta a incidentes cuando sea necesario.

Ejemplos Intermedios

8. Analizar plantillas HTML incrustadas

Carga plantillas desde embed.FS sin E/S de disco en tiempo de ejecución.

package main
 
import (
    "embed"
    "html/template"
    "os"
)
 
//go:embed templates/*.html
var tplFS embed.FS
 
func main() {
    tpl, err := template.ParseFS(tplFS, "templates/*.html")
    if err != nil {
        panic(err)
    }
    _ = tpl.Execute(os.Stdout, map[string]string{"Name": "Go"})
}

• Las rutas glob de ParseFS son relativas a la raíz del FS que incrustaste.
• Envía parciales y layouts en el mismo árbol de incrustación para servicios pequeños.
• Para recarga en caliente en desarrollo, mantén una alternativa de sistema de archivos detrás de un tag de compilación.

9. Declaración de Go más stub de ensamblaje

Llama a ensamblaje desde Go en el mismo paquete (adición ilustrativa).

// add.go
package main
 
import "fmt"
 
func add(x, y int64) int64
 
func main() {
    fmt.Println(add(3, 4))
}

// add_amd64.s
TEXT ·add(SB), NOSPLIT, $0-24
    MOVQ x+0(FP), AX
    ADDQ y+8(FP), AX
    MOVQ AX, ret+16(FP)
    RET

• El prototipo de Go debe coincidir con la firma de ensamblaje; · nombra el símbolo de Go.
• El ensamblaje es específico de la arquitectura; proporciona una alternativa pura de Go para otras arquitecturas.
• Perfila antes de mantener archivos .s; la mayoría del código debe permanecer en Go.

Relacionado: Ensamblaje en Go (archivos *.s) - convenciones de llamada

10. Directiva del compilador para estabilidad de benchmarks

Evita la inlining al medir la sobrecarga de llamadas.

package bench
 
//go:noinline
func Work() int {
    return 42
}

• //go:noinline es para pruebas, benchmarks y límites de ABI raros.
• No esparzas directivas para "ayudar" al optimizador en producción sin evidencia.
• Prefiere go test -bench y perfiles antes de micro-optimizar.

Relacionado: Directivas del Compilador: //go:noinline, linkname & go:fix inline - conjunto completo de directivas

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