0Pricing
Go Academy · Lección

Lectura de archivos con os y bufio

Apertura, lectura de líneas y cierre seguro de archivos

Lectura de archivos con os y bufio 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.

os.ReadFile

os.ReadFile (Go 1.16+) lee un archivo completo en un slice de bytes en una sola llamada. Es una opción sencilla e idiomática para archivos pequeños.

data, err := os.ReadFile("config.json")
if err != nil { log.Fatal(err) }
fmt.Println(string(data))

os.Open y cierre manual

Para tener más control, abra un archivo con os.Open (solo lectura) y ciérrelo con defer:

f, err := os.Open("data.txt")
if err != nil { return err }
defer f.Close()

Lectura en un búfer

Lea un bloque de bytes con f.Read(buf). Devuelve el número de bytes leídos y io.EOF cuando termina el archivo.

buf := make([]byte, 1024)
n, err := f.Read(buf)
if err != nil && err != io.EOF { return err }
fmt.Println(string(buf[:n]))

bufio.NewReader

Envuelva un archivo en bufio.Reader para almacenar en búfer las lecturas y reducir las llamadas al sistema. Entre sus métodos se incluyen ReadString, ReadLine y ReadByte.

reader := bufio.NewReader(f)
line, err := reader.ReadString('\n')

Lectura línea por línea con bufio.Scanner

bufio.NewScanner es la forma idiomática de leer un archivo de texto línea por línea. La función de división predeterminada es ScanLines.

scanner := bufio.NewScanner(f)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}
if err := scanner.Err(); err != nil { return err }

Búfer personalizado del scanner

El búfer predeterminado del scanner es de 64 KiB. Para archivos con líneas muy largas, aumente el búfer con scanner.Buffer.

buf := make([]byte, 1024*1024)
scanner.Buffer(buf, len(buf))

io.ReadAll

io.ReadAll lee de cualquier io.Reader hasta EOF y devuelve los bytes. Es útil para leer conexiones de red, cuerpos de respuesta o archivos envueltos en readers.

data, err := io.ReadAll(f)

Lectura de palabras y bytes

Reemplace la función de división del scanner para leer palabras (bufio.ScanWords) o bytes individuales (bufio.ScanBytes).

scanner.Split(bufio.ScanWords)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

Lectura de texto estructurado

Después de leer las líneas, use strings.Fields o strings.Split para analizar las columnas:

for scanner.Scan() {
    fields := strings.Fields(scanner.Text())
    // fields[0], fields[1], ...
}

Errores de lectura de archivos

Compruebe siempre Err() del scanner después del bucle de lectura: devuelve el primer error que no sea EOF. Un bucle que termina normalmente sin leer ninguna línea puede haber encontrado un error.

Lectura de stdin con nombre

Use os.Stdin en cualquier lugar donde se acepte un io.Reader. Así, las herramientas CLI funcionan tanto con argumentos de archivo como con entrada canalizada.

scanner := bufio.NewScanner(os.Stdin)

Comprobación rápida

¿Qué tipo de bufio es la forma idiomática de leer un archivo de texto línea por línea en Go?

Resumen: lectura de archivos

Puntos clave:

  • os.ReadFile: lee un archivo pequeño completo en una sola llamada
  • bufio.Scanner: lectura línea por línea; compruebe Err() después del bucle
  • bufio.Reader: lecturas almacenadas en búfer que reducen las llamadas al sistema
  • io.ReadAll: lee cualquier io.Reader hasta el final

Preguntas frecuentes

¿La lección «Lectura de archivos con os y bufio» es gratis?

Sí — el texto completo de «Lectura de archivos con os y bufio» 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 «Lectura de archivos con os y bufio»?

Apertura, lectura de líneas y cierre seguro de archivos 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 «Lectura de archivos con os y bufio»?

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. Lectura de archivos con os y bufio
  2. Escritura de archivos y archivos temporales
  3. Codificación y decodificación de JSON
  4. JSON y CSV en streaming
← Volver a Go Academy