0Pricing
Go Academy · Lección

Implementación de lectores personalizados

Construya sus propios streams

Implementación de lectores personalizados es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Cree sus propios flujos

Puede crear fuentes de datos personalizadas implementando la interfaz io.Reader, que solo requiere un método. De este modo, su tipo funcionará con todas las utilidades de io.

El método que debe implementar

Implemente Read(p []byte) (n int, err error) en su tipo. Rellene p, devuelva la cantidad y devuelva io.EOF cuando haya terminado.

Un lector constante

Aquí se muestra un lector que emite indefinidamente el mismo byte, limitado con 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))
}

Señalar EOF

Devuelva io.EOF cuando se agote la fuente. Puede devolverlo solo o junto con los bytes finales.

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))
}

Leer desde un slice

Un lector personalizado puede seguir una posición dentro de los datos subyacentes y devolver un fragmento en cada llamada.

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))
}

Un lector transformador

Envuelva otro lector y transforme los bytes sobre la marcha; aquí, convirtiendo cada byte a mayúscula a medida que fluye.

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))
}

Respete la longitud del búfer

No escriba nunca más de len(p) bytes. Use copy(p, src), que está limitada por el slice más pequeño, y devuelva la cantidad copiada.

Receptores por valor frente a receptores por puntero

Si su lector mantiene una posición o un estado, use un receptor por puntero para que las modificaciones persistan entre llamadas. Los lectores sin estado pueden usar un receptor por valor.

Componer con utilidades de io

Como su tipo satisface io.Reader, puede integrarlo directamente con io.Copy, bufio.NewReader, io.LimitReader y otras utilidades.

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")
}

Errores frecuentes

  • Olvidar devolver io.EOF (lectura infinita)
  • Escribir más allá de len(p)
  • Usar un receptor por valor para lectores con estado

Por qué usar lectores personalizados

Permiten adaptar cualquier fuente, como generadores, decodificadores, limitadores de velocidad o flujos cifrados, al ecosistema universal de E/S de Go.

Comprobación rápida

Compruebe sus conocimientos sobre lectores personalizados.

Resumen

Ha aprendido a crear sus propios flujos.

  • Implemente Read(p []byte) (int, error)
  • Use copy y respete len(p)
  • Devuelva io.EOF cuando haya terminado
  • Use un receptor por puntero para lectores con estado
  • Compóngalos con todas las utilidades de io

Preguntas frecuentes

¿La lección «Implementación de lectores personalizados» es gratis?

Sí — el texto completo de «Implementación de lectores personalizados» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Implementación de lectores personalizados»?

Construya sus propios streams Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Implementación de lectores personalizados»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. La interfaz Reader
  2. La interfaz Writer
  3. Funciones auxiliares de io
  4. Implementación de lectores personalizados
← Volver a Go Academy