Noções Básicas de Recursos Avançados de Linguagem

10 exemplos para você começar com Recursos Avançados de Linguagem - 7 básicos e 3 intermediários.

Pré-requisitos

• Go 1.26.x ou posterior e um módulo: go mod init example.com/advlang.
• Crie uma pasta assets/ ao lado de pacotes que usam go:embed.
• Compile com go build / go run .; defina GOOS / GOARCH para exercitar arquivos de plataforma.
• Leia Além da Especificação: Embed, Modos de Compilação e Assembly para ter uma visão geral.

Exemplos Básicos

1. Incorporar um único arquivo como string

Incorpore um arquivo de configuração no binário em tempo de compilação.

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

• //go:embed deve ficar imediatamente acima de uma variável string, []byte ou embed.FS.
• O caminho é relativo ao diretório do arquivo de origem.
• Alterar o arquivo requer uma recompilação; não há hot reload.

Relacionado: //go:embed para Arquivos e Templates - Padrões FS e de template

2. Incorporar um diretório com embed.FS

Sirva vários arquivos de um sistema de arquivos em memória.

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))
}

• Os caminhos de embed.FS usam barras normais e incluem o prefixo do diretório incorporado.
• Use fs.Sub para remover um prefixo para http.FileServer ou template.ParseFS.
• Arquivos ocultos e caminhos .. são rejeitados em tempo de compilação.

3. Restrição de compilação moderna em um arquivo

Compile um arquivo apenas no Linux.

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

• Prefira //go:build em vez de comentários // +build legados em código novo.
• Combine tags com &&, || e ! (por exemplo, linux && amd64).
• Arquivos sem restrições compilam em todas as plataformas.

Relacionado: Restrições de Compilação e Arquivos Específicos de Plataforma - convenções de sufixo

4. Sufixo de arquivo para GOOS

Deixe o toolchain escolher main_windows.go vs main_unix.go automaticamente.

// 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())
}

• Sufixos como _linux.go e _amd64.go implicam restrições sem uma linha explícita.
• Mantenha a lógica compartilhada em arquivos neutros; coloque as diferenças em arquivos com tags.
• Execute go list -f '{{.GoFiles}}' . para ver quais arquivos uma compilação selecionou.

5. Tag personalizada para testes de integração

Cancele testes caros com -tags integration.

//go:build integration
 
package myapp_test
 
import "testing"
 
func TestLiveAPI(t *testing.T) {
    t.Log("executa apenas com -tags integration")
}

• Execute com go test -tags=integration ./....
• A CI pode usar tags padrão localmente e tags de integração em um trabalho noturno.
• Documente as tags necessárias no README ou nos alvos do Makefile.

6. Listar modos de compilação disponíveis

Inspecione o que go tool suporta em sua instalação.

go help buildmode

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

• Modos comuns: exe (padrão), c-archive, c-shared, plugin, shared.
• plugin e alguns modos são limitados por SO/arquitetura.
• Lançamentos de produção devem fixar a linha exata de go build nos logs da CI.

Relacionado: Flags do Linker e Opções de buildmode - guia modo a modo

7. Remover informações de depuração com ldflags

Encolha binários de lançamento omitindo tabelas de símbolos.

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

• -s omite a tabela de símbolos; -w omite informações de depuração DWARF.
• Você perde alguma conveniência de profiling e depuração em binários removidos.
• Emparelhe com compilações de depuração separadas para resposta a incidentes quando necessário.

Exemplos Intermediários

8. Analisar templates HTML incorporados

Carregue templates de embed.FS sem E/S de disco em tempo de execução.

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"})
}

• Os caminhos glob de ParseFS são relativos à raiz do FS que você incorporou.
• Envie partições e layouts na mesma árvore de incorporação para pequenos serviços.
• Para hot reload em desenvolvimento, mantenha um fallback de sistema de arquivos atrás de uma tag de compilação.

9. Declaração Go mais stub de assembly

Chame assembly do Go no mesmo pacote (adição 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

• O protótipo Go deve corresponder à assinatura do assembly; · nomeia o símbolo Go.
• O assembly é específico da arquitetura; forneça fallback Go puro para outras arquiteturas.
• Faça profiling antes de manter arquivos .s; a maior parte do código deve permanecer em Go.

Relacionado: Assembly em Go (*.s files) - convenções de chamada

10. Diretiva do compilador para estabilidade de benchmark

Evite inlining ao medir o overhead de chamada.

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

• //go:noinline é para testes, benchmarks e raros limites de ABI.
• Não espalhe diretivas para "ajudar" o otimizador em produção sem evidências.
• Prefira go test -bench e perfis antes de micro-otimizar.

Relacionado: Diretivas do Compilador: //go:noinline, linkname & go:fix inline - conjunto completo de diretivas

Versões da Pilha: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, modernizadores go fix - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).