Lendo o arquivo inteiro em Go: velocidade e otimização

Por que ler um arquivo inteiro em uma string em Go e como fazer isso corretamente?

Imagine: você está escrevendo um servidor em Go que processa arquivos de configuração, logs ou modelos HTML. Mais cedo ou mais tarde surge a tarefa — ler um arquivo inteiro em uma única variável de string. Parece simples, não é? Mas nem tudo é tão óbvio. Em Go, existem várias maneiras de fazer isso, e cada uma delas — com suas próprias nuances de desempenho, memória e conveniência.

Se você veio do Python ou JavaScript, está acostumado com linhas únicas como open("file").read(). Em Go, a filosofia é diferente: aqui o controle sobre os recursos é parte da cultura. Portanto, não apenas "lemos o arquivo", mas escolhemos conscientemente a ferramenta: os.ReadFile, ioutil.ReadFile (obsoleto), bufio ou um reader personalizado.

Neste artigo, vamos analisar todas as abordagens populares, medir seu desempenho e descobrir qual delas vale a pena usar em projetos reais. E o principal — entenderemos por que em Go não há necessidade de ter medo de ler arquivos inteiros, se feito com inteligência.

Por que essa pergunta é tão popular no Stack Overflow?

A pergunta "How can I read a whole file into a string variable" acumulou centenas de milhares de visualizações. A razão está na aparente simplicidade, por trás da qual se escondem armadilhas: codificações, tamanho do arquivo, vazamentos de memória, tratamento de erros. Os desenvolvedores não querem apenas "código funcional", mas uma solução ideal para seu cenário.

Método 1: os.ReadFile (padrão moderno)

A partir do Go 1.16, o pacote ioutil foi declarado obsoleto e suas funções foram movidas para os. Agora, a principal maneira de ler um arquivo é os.ReadFile. Ele retorna []byte, que é facilmente convertido em string.

package main\n\nimport (\n    "fmt"\n    "os"\n)\n\nfunc main() {\n    data, err := os.ReadFile("example.txt")\n    if err != nil {\n        panic(err)\n    }\n    content := string(data)\n    fmt.Println(content)\n}\n

Vantagens:

\n
• Mínimo de código — uma linha para leitura.
\n
• Gerenciamento automático de memória — o arquivo é fechado após a leitura.
\n
• Ideal para arquivos de até 100 MB (dependendo do sistema).
\n

Desvantagens:

\n
• Carrega todo o arquivo na memória. Para logs gigantescos (gigabytes) — não é uma opção.
\n
• Cópia de dados ao converter []byte para string — consumo duplo de memória.
\n

Método 2: ioutil.ReadFile (antigo, mas ainda funciona)

Antes do Go 1.16, usava-se ioutil.ReadFile. O código é quase idêntico, mas agora os linters reclamarão. Não o recomendamos para novos projetos, mas se você está mantendo código legado — ele ainda existe.

import "io/ioutil"\n\ndata, _ := ioutil.ReadFile("file.txt") // apenas para exemplo, não ignore erros!\n

Em termos de desempenho, é idêntico ao os.ReadFile — internamente é o mesmo código. A diferença está apenas no pacote.

Método 3: bufio.Reader para leitura em fluxo

Se você quiser controlar o processo e ler o arquivo em partes (por exemplo, para dados grandes), use bufio. Esta abordagem permite ler linha por linha ou em blocos.

package main\n\nimport (\n    "bufio"\n    "fmt"\n    "os"\n    "strings"\n)\n\nfunc main() {\n    file, err := os.Open("bigfile.log")\n    if err != nil {\n        panic(err)\n    }\n    defer file.Close()\n\n    var sb strings.Builder\n    scanner := bufio.NewScanner(file)\n    for scanner.Scan() {\n        sb.WriteString(scanner.Text())\n        sb.WriteString("\\n")\n    }\n    result := sb.String()\n    fmt.Println("Length:", len(result))\n}\n

Quando isso é útil?

\n
• O arquivo é tão grande que não cabe na memória RAM.
\n
• É necessário processar as linhas à medida que são lidas (filtro
\n