Go Academy · Lección

Lectores con búfer

Lea de forma eficiente con bufio

Lectores con búfer es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 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.

Por qué usar búferes al leer

Leer un byte a la vez desde un archivo o una red activa una llamada al sistema cada vez. Es lento.

El paquete bufio envuelve un lector y lee grandes bloques en un búfer en memoria, proporcionando desde ese búfer las lecturas pequeñas.

Menos llamadas al sistema
Mucho más rápido para muchas lecturas pequeñas

Crear un bufio.Reader

Envuelva cualquier io.Reader con bufio.NewReader. Aquí envolvemos un 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)
}

Leer bytes

ReadByte devuelve el siguiente byte individual. Se obtiene del búfer, no mediante una nueva llamada al 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 hasta un delimitador

ReadString(delim) lee hasta la primera aparición del byte delimitador y devuelve todo, incluido el 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)
}

Consultar por adelantado

Peek(n) devuelve los siguientes n bytes sin consumirlos. Es muy útil para decidir cómo analizar los datos antes de comprometerse.

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

Tamaño del búfer

bufio.NewReaderSize(r, size) establece la capacidad del búfer. Un búfer más grande implica menos lecturas subyacentes, pero más memoria.

package main

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

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

ReadLine frente a ReadString

ReadString('\n') conserva el salto de línea; muchos analizadores prefieren eliminarlo. Scanner (en la siguiente lección) lo hace automáticamente.

Use ReadString cuando necesite controlar por completo los delimitadores.

Gestionar io.EOF

Cuando el flujo subyacente se agota, los métodos de lectura devuelven io.EOF. Compruébelo siempre para saber cuándo detenerse.

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 un rune UTF-8 completo, que puede abarcar varios bytes. Úselo para texto con caracteres no 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()
}

Leer hasta terminar

Un patrón habitual consiste en usar ReadString en un bucle hasta llegar a EOF para procesar un flujo línea por línea manteniendo un control 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
		}
	}
}

Cuándo usar bufio.Reader

Para envolver fuentes lentas (archivos, sockets)
Cuando haya muchas lecturas pequeñas
Cuando necesite consultar por adelantado o leer por delimitador o rune

Para analizar líneas de forma sencilla, prefiera bufio.Scanner (en la siguiente lección).

Comprobación rápida

Compruebe su comprensión de los lectores con búfer.

Recapitulación

Ha aprendido cómo bufio.Reader reduce las llamadas al sistema mediante el uso de búferes.

NewReader / NewReaderSize envuelven un io.Reader
ReadByte, ReadRune, ReadString obtienen los datos del búfer
Peek consulta datos por adelantado sin consumirlos
Deténgase al recibir io.EOF

Preguntas frecuentes

¿La lección «Lectores con búfer» es gratis?

Sí — el texto completo de «Lectores con búfer» 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 «Lectores con búfer»?

Lea de forma eficiente con bufio 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 1 de 4.

¿Cuánto tiempo toma la lección «Lectores con búfer»?

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

← Volver a Go Academy