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.dirnamey connode:path. - Los streams procesan datos por partes;
pipelinelos 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
Resuelto
Elige una respuesta en cada pregunta.
¿Qué módulo conviene para trabajar con archivos en código moderno?
¿Por qué usar
path.joinen lugar de concatenar rutas con"/"?¿Cuándo conviene un stream en lugar de
readFile?¿Qué ventaja tiene
pipelinesobreorigen.pipe(destino)?
Ordena la salida: Rutas
Resuelto
Cuatro funciones de node:path. Ordena lo que aparecería en la terminal.
1import path from "node:path";2 3console.log(path.join("/datos", "../config", "app.json"));4console.log(path.basename("/fotos/viaje.jpg", ".jpg"));5console.log(path.extname("informe.final.pdf"));6console.log(path.resolve("/proyecto", "src", "./index.js"));Consola, de arriba abajo
- /config/app.json
- /proyecto/src/index.js
- viaje
join une y normaliza: el .. sale de /datos. basename da el nombre del archivo, sin la extensión si se la pasas. extname da solo la última extensión. resolve arma una ruta absoluta. (Ejemplo con rutas de Linux y macOS.)
Detective: Un archivo que está ahí
Resuelto
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.
Paso 2: ¿cómo lo arreglas?