0Pricing
Go Academy · Aula

Implementação de leitores personalizados

Crie seus próprios fluxos

Implementação de leitores personalizados é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 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.

Crie seus próprios fluxos

Você pode criar fontes de dados personalizadas implementando a interface io.Reader, que possui um único método. Assim, seu tipo funciona com todos os auxiliares de io.

O método a implementar

Implemente Read(p []byte) (n int, err error) no seu tipo. Preencha p, retorne a quantidade e retorne io.EOF quando terminar.

Um leitor constante

Aqui temos um leitor que emite indefinidamente o mesmo byte, limitado por LimitReader.

package main

import (
	"fmt"
	"io"
)

type constReader struct{ ch byte }

func (c constReader) Read(p []byte) (int, error) {
	for i := range p {
		p[i] = c.ch
	}
	return len(p), nil
}

func main() {
	r := io.LimitReader(constReader{ch: 'A'}, 5)
	data, _ := io.ReadAll(r)
	fmt.Println(string(data))
}

Sinalizando EOF

Retorne io.EOF quando sua fonte se esgotar. Você pode retorná-lo sozinho ou junto com os bytes finais.

package main

import (
	"fmt"
	"io"
)

type oneShot struct{ done bool }

func (o *oneShot) Read(p []byte) (int, error) {
	if o.done {
		return 0, io.EOF
	}
	o.done = true
	n := copy(p, []byte("once"))
	return n, nil
}

func main() {
	data, _ := io.ReadAll(&oneShot{})
	fmt.Println(string(data))
}

Lendo de uma fatia

Um leitor personalizado pode acompanhar uma posição nos dados de suporte, retornando um bloco a cada chamada.

package main

import (
	"fmt"
	"io"
)

type sliceReader struct {
	data []byte
	pos  int
}

func (s *sliceReader) Read(p []byte) (int, error) {
	if s.pos >= len(s.data) {
		return 0, io.EOF
	}
	n := copy(p, s.data[s.pos:])
	s.pos += n
	return n, nil
}

func main() {
	r := &sliceReader{data: []byte("custom")}
	out, _ := io.ReadAll(r)
	fmt.Println(string(out))
}

Um leitor transformador

Envolva outro leitor e transforme os bytes durante a leitura — aqui, convertendo cada byte para maiúsculas enquanto ele é transmitido.

package main

import (
	"bytes"
	"fmt"
	"io"
)

type upper struct{ r io.Reader }

func (u upper) Read(p []byte) (int, error) {
	n, err := u.r.Read(p)
	for i := 0; i < n; i++ {
		if p[i] >= 'a' && p[i] <= 'z' {
			p[i] -= 32
		}
	}
	return n, err
}

func main() {
	out, _ := io.ReadAll(upper{r: bytes.NewReader([]byte("hello"))})
	fmt.Println(string(out))
}

Respeite o tamanho do buffer

Nunca escreva mais que len(p) bytes. Use copy(p, src), que é limitado pela menor fatia, e retorne a quantidade copiada.

Receptores de valor versus de ponteiro

Se o seu leitor acompanha uma posição ou um estado, use um receptor de ponteiro para que as alterações persistam entre as chamadas. Leitores sem estado podem usar um receptor de valor.

Compondo com auxiliares de io

Como seu tipo satisfaz io.Reader, ele pode ser usado diretamente com io.Copy, bufio.NewReader, io.LimitReader e outros, sem trabalho adicional.

package main

import (
	"io"
	"os"
)

type dots struct{ left int }

func (d *dots) Read(p []byte) (int, error) {
	if d.left == 0 {
		return 0, io.EOF
	}
	p[0] = '.'
	d.left--
	return 1, nil
}

func main() {
	io.Copy(os.Stdout, &dots{left: 4})
	os.Stdout.WriteString("\n")
}

Armadilhas comuns

  • Esquecer de retornar io.EOF (leitura infinita)
  • Escrever além de len(p)
  • Usar um receptor de valor para leitores que mantêm estado

Por que usar leitores personalizados

Eles permitem adaptar qualquer fonte — geradores, decodificadores, limitadores de taxa e fluxos criptografados — ao ecossistema universal de E/S do Go.

Verificação rápida

Teste seus conhecimentos sobre leitores personalizados.

Recapitulação

Você aprendeu a criar seus próprios fluxos.

  • Implemente Read(p []byte) (int, error)
  • Use copy e respeite len(p)
  • Retorne io.EOF quando terminar
  • Use um receptor de ponteiro para leitores que mantêm estado
  • Componha com todos os auxiliares de io sem trabalho adicional

Perguntas Frequentes

A aula “Implementação de leitores personalizados” é grátis?

Sim — o texto completo de “Implementação de leitores personalizados” é 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 “Implementação de leitores personalizados”?

Crie seus próprios fluxos 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 4 de 4.

Quanto tempo leva a aula “Implementação de leitores personalizados”?

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

  1. A interface Reader
  2. A interface Writer
  3. Funções utilitárias de io
  4. Implementação de leitores personalizados
← Voltar para Go Academy