Go Academy · Aula

Leitores com buffer

Leia com eficiência usando bufio

Leitores com buffer é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Por que usar memória intermediária nas leituras

Ler um byte por vez de um arquivo ou da rede aciona uma chamada ao sistema todas as vezes. Isso é lento.

O pacote bufio envolve um leitor e lê grandes blocos em uma memória intermediária na memória, atendendo às suas pequenas leituras a partir dela.

Menos chamadas ao sistema
Muito mais rápido para muitas leituras pequenas

Criando um bufio.Reader

Envolva qualquer io.Reader com bufio.NewReader. Aqui, envolvemos um strings.Reader.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("Hello, Go!"))
	fmt.Printf("buffered reader ready: %T\n", r)
}

Lendo Bytes

ReadByte retorna o próximo byte individual. Ele é fornecido pela memória intermediária, sem uma nova chamada ao sistema.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("Go"))
	b1, _ := r.ReadByte()
	b2, _ := r.ReadByte()
	fmt.Printf("%c%c\n", b1, b2)
}

ReadString até um delimitador

ReadString(delim) lê até a primeira ocorrência do byte delimitador, retornando tudo incluindo o delimitador.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("first,second,third"))
	part, _ := r.ReadString(',')
	fmt.Printf("%q\n", part)
}

Espiando adiante

Peek(n) retorna os próximos n bytes sem consumi-los. É ótimo para decidir como analisar os dados antes de confirmar a decisão.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("HTTP/1.1"))
	head, _ := r.Peek(4)
	fmt.Printf("starts with: %s\n", head)
}

Tamanho da memória intermediária

bufio.NewReaderSize(r, size) define a capacidade da memória intermediária. Uma memória intermediária maior significa menos leituras da fonte subjacente, mas mais uso de memória.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReaderSize(strings.NewReader("data"), 4096)
	fmt.Println("buffer size:", r.Size())
}

ReadLine versus ReadString

ReadString('\n') mantém o caractere de nova linha; muitos analisadores preferem removê-lo. O Scanner (na próxima lição) faz isso automaticamente.

Use ReadString quando precisar de controle total sobre os delimitadores.

Lidando com io.EOF

Quando o fluxo subjacente se esgota, os métodos de leitura retornam io.EOF. Verifique-o sempre para saber quando parar.

package main

import (
	"bufio"
	"fmt"
	"io"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("ab"))
	for {
		c, err := r.ReadByte()
		if err == io.EOF {
			break
		}
		fmt.Printf("%c", c)
	}
	fmt.Println()
}

ReadRune para Unicode

ReadRune decodifica uma runa UTF-8 completa, que pode ocupar vários bytes. Use-o para textos com caracteres que não sejam ASCII.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("héllo"))
	for {
		ru, _, err := r.ReadRune()
		if err != nil {
			break
		}
		fmt.Printf("%c ", ru)
	}
	fmt.Println()
}

Lendo até terminar

Um padrão comum: faça um laço com ReadString até EOF para processar um fluxo linha por linha, mantendo um controle preciso.

package main

import (
	"bufio"
	"fmt"
	"io"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("a\nb\nc\n"))
	for {
		line, err := r.ReadString('\n')
		fmt.Print("got: " + line)
		if err == io.EOF {
			break
		}
	}
}

Quando usar bufio.Reader

Envolver fontes lentas (arquivos, soquetes)
Muitas leituras pequenas
Precisar consultar antecipadamente ou ler por delimitador/runa

Para uma leitura simples linha a linha, prefira bufio.Scanner (na próxima lição).

Verificação rápida

Verifique sua compreensão sobre leitores com memória intermediária.

Recapitulação

Você aprendeu como bufio.Reader reduz as chamadas ao sistema usando uma memória intermediária.

NewReader / NewReaderSize envolvem um io.Reader
ReadByte, ReadRune, ReadString fornecem dados da memória intermediária
Peek consulta os dados seguintes sem consumi-los
Pare ao receber io.EOF

Perguntas Frequentes

A aula “Leitores com buffer” é grátis?

Sim — o texto completo de “Leitores com buffer” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Leitores com buffer”?

Leia com eficiência usando bufio Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Leitores com buffer”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy