Go Academy · Aula

Gravadores com buffer

Agrupe escritas

Gravadores com buffer é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 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 gravações

Assim como nas leituras, cada gravação pequena pode acionar uma chamada ao sistema. bufio.Writer reúne as gravações na memória e as descarrega em grandes blocos.

Importante: os dados na memória intermediária são perdidos se você não chamar Flush().

Criando um bufio.Writer

Envolva qualquer io.Writer. Aqui, envolvemos os.Stdout.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.WriteString("Hello buffered\n")
	w.Flush()
}

Não se esqueça de Flush

Sem Flush(), sua saída pode nunca aparecer. Um padrão comum é defer w.Flush().

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	w.WriteString("written via defer\n")
}

Escrevendo Bytes e cadeias de caracteres

Use Write para fatias de bytes, WriteString para cadeias de caracteres, e WriteByte e WriteRune para valores individuais.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.Write([]byte("bytes "))
	w.WriteString("string ")
	w.WriteRune('!')
	w.WriteByte('\n')
	w.Flush()
}

Verificando o estado da memória intermediária

Buffered() informa quantos bytes estão aguardando, e Available() informa quanto espaço livre resta.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.WriteString("abc")
	fmt.Fprintf(os.Stderr, "buffered: %d\n", w.Buffered())
	w.Flush()
}

Descarregamento automático quando cheio

Quando a memória intermediária fica cheia, bufio.Writer a descarrega automaticamente. Ainda é necessário chamar Flush() ao final para os dados restantes.

Tamanho personalizado da memória intermediária

bufio.NewWriterSize(w, size) define a capacidade. Memórias intermediárias maiores reduzem a frequência de descarregamento.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriterSize(os.Stdout, 8192)
	w.WriteString("custom size buffer\n")
	w.Flush()
}

Gravações formatadas com Fprintf

Como bufio.Writer é um io.Writer, você pode passá-lo para fmt.Fprintf para obter uma saída formatada e armazenada na memória intermediária.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	for i := 1; i <= 3; i++ {
		fmt.Fprintf(w, "line %d\n", i)
	}
	w.Flush()
}

Lidando com erros de gravação

Os erros podem aparecer em uma gravação posterior ou em Flush(). Verifique sempre o erro retornado por Flush().

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.WriteString("data\n")
	if err := w.Flush(); err != nil {
		fmt.Fprintln(os.Stderr, "flush failed:", err)
	}
}

Agrupando muitas gravações

O ganho real: um laço compacto de pequenas gravações se transforma em uma ou poucas chamadas ao sistema depois do uso da memória intermediária.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for i := 0; i < 5; i++ {
		w.WriteString("x")
	}
	w.WriteByte('\n')
}

Boas práticas

Chame sempre Flush() (ou use defer)
Verifique o erro de Flush(), não apenas o erro de cada gravação
Dimensione a memória intermediária de acordo com sua carga de trabalho

Verificação rápida

Verifique seus conhecimentos sobre gravadores com memória intermediária.

Recapitulação

Você aprendeu a agrupar gravações com bufio.Writer.

NewWriter / NewWriterSize
Write, WriteString, WriteByte, WriteRune
Funciona com fmt.Fprintf
Chame sempre Flush() e verifique o erro retornado

Perguntas Frequentes

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

Sim — o texto completo de “Gravadores 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 “Gravadores com buffer”?

Agrupe escritas 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 3 de 4.

Quanto tempo leva a aula “Gravadores 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