Tipos Numéricos, Strings, Runes e Fatias de Bytes

Os tipos embutidos do Go separam números de largura fixa, texto UTF-8, pontos de código Unicode (runes) e bytes brutos.

Misturá-los sem conversão é uma fonte comum de erros de "off-by-one" e de codificação.

Resumo

Inteiros e floats têm tamanhos explícitos; constantes sem tipo se adaptam ao contexto.

Strings são sequências de bytes UTF-8 imutáveis.

Uma rune é um alias para int32 representando um ponto de código Unicode.

Use []byte para dados binários e []rune quando precisar de operações de texto indexadas por caractere.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

package main
 
import (
    "fmt"
    "strconv"
    "unicode/utf8"
)
 
func main() {
    s := "café"
    fmt.Println(utf8.RuneCountInString(s)) // contagem de runes: 4
 
    n, err := strconv.Atoi("42")
    if err != nil {
        panic(err)
    }
    fmt.Println(n + 1)
}

Quando usar isso:

• Conte caracteres com utf8.RuneCountInString, não com len(string).
• Analise a entrada do usuário com strconv, não com fmt.Sscanf, para obter erros claros.
• Converta números explicitamente com int64(x) ao aumentar ou diminuir a largura.
• Trate string e []byte como distintos, a menos que esteja copiando para APIs.

Exemplo de Trabalho

package main
 
import (
    "fmt"
    "strconv"
    "unicode/utf8"
)
 
func main() {
    price := "19.99"
    amount, err := strconv.ParseFloat(price, 64)
    if err != nil {
        fmt.Println("erro de parse:", err)
        return
    }
 
    title := "Hello, 世界"
    fmt.Println("bytes:", len(title))
    fmt.Println("runes:", utf8.RuneCountInString(title))
 
    for i, r := range title {
        fmt.Printf("índice de byte %d: %U\n", i, r)
    }
 
    b := []byte(title)
    b[0] = 'h' // modifica a cópia apenas se você reatribuir a string a partir de b
    fmt.Println(string(b))
}

O que isso demonstra:

• strconv.ParseFloat para conversão de string para número com erros.
• len em strings mede bytes UTF-8, não runes.
• range sobre strings decodifica runes e retorna índices de byte.
• []byte(string) aloca uma cópia mutável de bytes.

Mergulho Profundo

Como Funciona

• Tipos numéricos são inteiros com/sem sinal (int, int8..int64, uint, uint8..uint64), floats (float32, float64) e complex64/complex128.
• O tamanho de int e uint depende da plataforma (32 ou 64 bits); prefira tipos com tamanho definido para serialização.
• Strings são somente leitura; converter para []byte copia, a menos que use unsafe (evite).
• UTF-8 codifica runes em 1-4 bytes; UTF-8 inválido é substituído por U+FFFD ao iterar.

Tipos Numéricos em Resumo

String, Rune, Byte

Notas do Go

// strconv é a ponte idiomática entre string e número
i, err := strconv.ParseInt("ff", 16, 64)
f := strconv.FormatFloat(3.5, 'f', 2, 64)
 
// literal de rune vs byte
var letter rune = 'A'   // ponto de código int32
var raw byte = 'A'      // uint8 ASCII

Armadilhas

• Usar len para contagem de caracteres - "é" tem len 2 em UTF-8. Correção: utf8.RuneCountInString ou range.
• Truncar com int32(x) silenciosamente - int64 grande para int32 envolve. Correção: verifique os limites antes da conversão.
• Modificar []byte derivado de string - Seguro para a fatia, mas reatribuir string(b) cria uma nova string; o original não é alterado. Correção: trate a conversão como cópia.
• fmt.Sscanf para parsear - Relatório de erros fraco vs strconv. Correção: prefira as funções strconv.Parse*.
• Comparar floats com == - Problemas com 0.1+0.2. Correção: comparação com epsilon ou inteiros em centavos.
• Indexar string por byte - s[i] é um byte, não uma rune; pode dividir sequências multibyte. Correção: use range ou converta para []rune para indexação.

Alternativas

FAQs

strconv.Itoa(42)
strconv.FormatInt(42, 10)
fmt.Sprintf("%d", 42) // aloca mais; bom para logs

Relacionados

• Arrays, Fatias e Mapas em Resumo - Mecânica de fatias por trás de []byte e []rune
• Valores Zero e Inicialização - Padrões de string vazia e numéricos
• Variáveis, Constantes e Escopo - Constantes tipadas vs. sem tipo
• Noções Básicas de Fundamentos do Go - Exemplo de iteração de string

Links Externos Relacionados

• Especificação da Linguagem Go - A referência formal da linguagem.
• Go by Example - Exemplos práticos anotados de código.
• Documentação da Biblioteca Padrão do Go - Referência completa da biblioteca padrão.
• A Linguagem de Programação Go (ebook) - Donovan & Kernighan.
• Learning Go (2nd Edition, O'Reilly) - Jon Bodner na O'Reilly.

Versões de Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - 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).