Saltar al contenido
JavaScript en el servidor

Archivos y streams

Lección 3 de 712 min3 ejercicios

Leer una configuración, guardar un informe, recorrer una carpeta de imágenes, procesar un registro de varios gigas: trabajar con archivos es de lo más común en Node.js. Para archivos pequeños alcanza con leerlos enteros; para los grandes, los streams permiten procesarlos por partes, sin agotar la memoria.

Leer y escribir

import { readFile, writeFile, appendFile, mkdir } from "node:fs/promises";
import { join } from "node:path";

const ruta = join(import.meta.dirname, "datos", "config.json");

const config = JSON.parse(await readFile(ruta, "utf8"));   // sin "utf8" devuelve un Buffer
config.visitas += 1;

await mkdir(join(import.meta.dirname, "datos"), { recursive: true });   // no falla si ya existe
await writeFile(ruta, JSON.stringify(config, null, 2));
await appendFile(join(import.meta.dirname, "registro.txt"), `${new Date().toISOString()} visita\n`);

Los errores llegan con un code: ENOENT (no existe), EACCES (sin permiso), EEXIST (ya existe), EISDIR (es una carpeta)…

import { readFile } from "node:fs/promises";

try {
  await readFile("no-existe.txt", "utf8");
} catch (e) {
  if (e.code === "ENOENT") console.log("Todavía no hay archivo: empiezo vacío");
  else throw e;
}

Rutas

Las rutas relativas se resuelven desde el directorio de trabajo (process.cwd()), no desde el archivo. Arma siempre las rutas a partir de import.meta.dirname, y con node:path, que conoce las diferencias entre sistemas:

import path from "node:path";

path.join("datos", "..", "config", "app.json");   // "config/app.json"
path.resolve("src", "index.js");                 // ruta absoluta desde el directorio de trabajo
path.basename("/fotos/viaje.jpg");               // "viaje.jpg"
path.extname("informe.pdf");                     // ".pdf"
path.dirname("/fotos/2026/viaje.jpg");           // "/fotos/2026"
path.parse("/fotos/viaje.jpg");                  // { root, dir, base, ext, name }

Carpetas

import { readdir, stat } from "node:fs/promises";

const entradas = await readdir("./fotos", { withFileTypes: true, recursive: true });
for (const e of entradas) {
  if (e.isFile() && e.name.endsWith(".jpg")) {
    const info = await stat(path.join(e.parentPath, e.name));
    console.log(e.name, `${(info.size / 1024).toFixed(0)} KB`);
  }
}

Streams

Un stream es un flujo de datos que llega o sale por partes (chunks). Hay cuatro tipos:

  • Readable: de donde se lee (un archivo, una petición HTTP, process.stdin).
  • Writable: donde se escribe (un archivo, una respuesta HTTP, process.stdout).
  • Transform: transforma lo que pasa (comprimir, cifrar, convertir).
  • Duplex: las dos cosas (un socket de red).

pipeline los conecta, maneja los errores y cierra todo al terminar:

import { createReadStream, createWriteStream } from "node:fs";
import { createGzip } from "node:zlib";
import { pipeline } from "node:stream/promises";

// Comprime un archivo de cualquier tamaño, usando poca memoria
await pipeline(
  createReadStream("registro.log"),
  createGzip(),
  createWriteStream("registro.log.gz"),
);

Si el destino es más lento que el origen, el stream frena la lectura hasta que el destino se pone al día. Se llama contrapresión (backpressure), y pipeline la maneja por ti.

Los streams que se leen son iterables asíncronos, así que se pueden recorrer con for await, como viste en Iteración asíncrona:

import { createReadStream } from "node:fs";
import { createInterface } from "node:readline";

// Contar las líneas con errores de un registro enorme, línea por línea
let errores = 0;
const lineas = createInterface({ input: createReadStream("servidor.log") });
for await (const linea of lineas) {
  if (linea.includes("ERROR")) errores++;
}
console.log(`${errores} errores`);

Resumen

  • node:fs/promises: readFile, writeFile, appendFile, mkdir, readdir, stat…
  • Los errores traen un code: ENOENT, EACCES, EEXIST.
  • Arma las rutas desde import.meta.dirname y con node:path.
  • Los streams procesan datos por partes; pipeline los conecta y maneja errores y contrapresión.
  • Los streams que se leen se recorren con for await.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Leer y escribir sin bloquear

Elige una respuesta en cada pregunta.

  1. ¿Qué módulo conviene para trabajar con archivos en código moderno?

  2. ¿Por qué usar path.join en lugar de concatenar rutas con "/"?

  3. ¿Cuándo conviene un stream en lugar de readFile?

  4. ¿Qué ventaja tiene pipeline sobre origen.pipe(destino)?

Ordena la salida: Rutas

Cuatro funciones de node:path. Ordena lo que aparecería en la terminal.

import path from "node:path"; console.log(path.join("/datos", "../config", "app.json"));console.log(path.basename("/fotos/viaje.jpg", ".jpg"));console.log(path.extname("informe.final.pdf"));console.log(path.resolve("/proyecto", "src", "./index.js"));

Consola, de arriba abajo

  1. .pdf
  2. /config/app.json
  3. /proyecto/src/index.js
  4. viaje

Detective: Un archivo que está ahí

El archivo está junto al script, pero Node.js dice que no existe. Encuentra la línea y elige el arreglo.

Consola

node:internal/fs/promises:639
  return new FileHandle(await binding.openFileHandle(path, flags, mode, kUsePromises));
                                      ^

Error: ENOENT: no such file or directory, open 'datos.json'
    at async open (node:internal/fs/promises:639:25)
    at async readFile (node:internal/fs/promises:1242:14)
    at async file:///proyecto/scripts/importar.mjs:4:25 {
  errno: -2,
  code: 'ENOENT',
  syscall: 'open',
  path: 'datos.json'
}

Paso 1: toca la línea de código que causa el error.

domina-js · JavaScript en español, gratis y paso a paso.