Trabajo con el sistema de archivos en TypeScript para principiantes

Introducción al trabajo con el sistema de archivos en TypeScript

Trabajar con el sistema de archivos es una de las tareas clave al desarrollar en TypeScript. Independientemente de si está creando una aplicación de servidor, una utilidad de procesamiento de datos o un servidor web, sin duda necesitará leer, escribir y gestionar archivos y directorios. En esta guía, cubriremos los fundamentos del trabajo con el módulo fs (File System) en TypeScript, veremos operaciones síncronas y asíncronas, y aprenderemos a manejar errores.

TypeScript es una extensión fuertemente tipada sobre JavaScript que añade tipado estático. Al trabajar con el sistema de archivos, usaremos el módulo estándar de Node.js fs, pero con las ventajas adicionales de TypeScript: autocompletado, verificación de tipos y legibilidad mejorada del código.

Configuración del proyecto e importación de módulos

Antes de comenzar, asegúrese de tener Node.js y TypeScript instalados. Cree un nuevo proyecto e instale los tipos necesarios:

mkdir fs-typescript-tutorialcd fs-typescript-tutorialnpm init -ynpm install typescript @types/node --save-devnpx tsc --init

Para trabajar con el sistema de archivos necesitaremos dos módulos principales:

• fs — para realizar operaciones con archivos (lectura, escritura, eliminación, etc.)
• path — para trabajar cómodamente con rutas (unión, normalización, obtención de extensión)

Los importamos en nuestro archivo TypeScript:

import * as fs from 'fs';import * as path from 'path';

// Alternativa — importar solo las funciones necesarias:import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';import { join, resolve } from 'path';

Tenga en cuenta: usamos import * as fs porque el módulo fs exporta muchas funciones. TypeScript tomará automáticamente los tipos del paquete instalado @types/node.

Lectura y escritura de archivos

Empecemos con las operaciones más básicas: lectura y escritura de archivos de texto. En Node.js hay dos enfoques: síncrono y asíncrono. Para scripts y utilidades simples, a menudo se usan métodos síncronos, y para servidores de alta carga, asíncronos, para no bloquear el event loop.

Lectura y escritura síncronas

Los métodos síncronos bloquean la ejecución del programa hasta que se completa la operación. Son fáciles de usar y adecuados para escenarios donde la velocidad no es crítica:

import { readFileSync, writeFileSync } from 'fs';import { join } from 'path';

const filePath = join(__dirname, 'data.txt');

// Escritura en archivo (crea el archivo si no existe)writeFileSync(filePath, '¡Hola, TypeScript!', 'utf-8');

// Lectura del archivoconst content: string = readFileSync(filePath, 'utf-8');console.log(content); // Mostrará: ¡Hola, TypeScript!

Tenga en cuenta la tipificación content: string — TypeScript garantiza que obtendremos una cadena. Si el archivo no existe, se lanzará una excepción que debe manejarse con try/catch.

Lectura y escritura asíncronas

Los métodos asíncronos aceptan un callback o devuelven una Promise (en versiones modernas). Se recomienda usar versiones con Promise junto con async/await:

import { promises as fsPromises } from 'fs';import { join } from 'path';

const filePath = join(__dirname, 'async-data.txt');

async function handleFile(): Promise<void> {    try {        // Escritura asíncrona        await fsPromises.writeFile(filePath, 'Contenido asíncrono', 'utf-8');                // Lectura asíncrona        const data: string = await fsPromises.readFile(filePath, 'utf-8');        console.log(data); // Contenido asíncrono    } catch (error) {        console.error('Error al trabajar con el archivo:', error);    }}

handleFile();

El uso de async/await hace que el código se parezca a sín