Dominando el Sistema de Archivos con Node.js: Guía Completa del Módulo fs

El módulo fs de Node.js es una herramienta esencial para cualquier desarrollador que trabaje con este entorno de ejecución. Su objetivo principal es permitir la interacción con el file system node, es decir, con el sistema de archivos del servidor donde se ejecuta la aplicación Node.js. A través de este módulo, podemos realizar una gran variedad de operaciones con archivos y directorios, desde la simple lectura y escritura hasta la manipulación de permisos y atributos.

En este artículo, vamos a explorar en profundidad el módulo fs de Node.js, cubriendo todos sus métodos y funcionalidades de forma detallada y práctica. Aprenderemos a realizar operaciones de lectura, escritura, creación y eliminación de archivos y directorios. Además, veremos cómo trabajar con funciones sincrónicas y asíncronas, utilizando callbacks, promesas y la sintaxis async/await. Finalmente, abordaremos conceptos como la obtención de información sobre archivos, la gestión de permisos y los tiempos de acceso.

Importando el Módulo fs

Antes de poder utilizar las funciones del sistema de archivos, debemos importar el módulo fs en nuestro script Node.js. Esto se realiza con la siguiente línea de código:

javascript
var fs = require("fs");


Esta línea de código importa el módulo fs y lo asigna a la variable fs, que podremos utilizar para acceder a todas sus funciones.

Operaciones Básicas con Archivos

El módulo fs ofrece una amplia gama de funciones para trabajar con archivos. Empecemos con las operaciones más básicas:

Creando y Escribiendo Archivos

Para crear un nuevo archivo y escribir datos en él, podemos utilizar la función writeFileSync(). Esta función toma dos argumentos: el nombre del archivo y los datos que se van a escribir.

javascript
// Crea un archivo llamado "miArchivo.txt" y escribe "Hola mundo!" en él.
fs.writeFileSync("miArchivo.txt", "Hola mundo!");


Si el archivo ya existe, writeFileSync() lo sobrescribirá con los nuevos datos.

Para escribir datos en un archivo de forma asíncrona, podemos utilizar la función writeFile(). Esta función toma tres argumentos: el nombre del archivo, los datos que se van a escribir y una función de devolución de llamada que se ejecutará cuando la operación se haya completado.

javascript
// Escribe "Hola mundo!" en el archivo "miArchivo.txt" de forma asíncrona.
fs.writeFile("miArchivo.txt", "Hola mundo!", (err) => {
if (err) {
console.error(err);
} else {
console.log("Archivo escrito correctamente!");
}
});


Leyendo Archivos

Para leer el contenido de un archivo, podemos utilizar las funciones readFileSync() y readFile(). La función readFileSync() lee el contenido del archivo de forma sincrónica y devuelve el contenido como una cadena de texto.

javascript
// Lee el contenido del archivo "miArchivo.txt".
const contenido = fs.readFileSync("miArchivo.txt", "utf-8");
console.log(contenido);


La función readFile() lee el contenido del archivo de forma asíncrona. Esta función toma dos argumentos: el nombre del archivo y una función de devolución de llamada que se ejecutará cuando la operación se haya completado. La función de devolución de llamada recibe dos argumentos: un posible error y el contenido del archivo.

javascript
// Lee el contenido del archivo "miArchivo.txt" de forma asíncrona.
fs.readFile("miArchivo.txt", "utf-8", (err, data) => {
if (err) {
console.error(err);
} else {
console.log(data);
}
});


Eliminando Archivos

Para eliminar un archivo, podemos utilizar la función unlink(). Esta función toma un único argumento: el nombre del archivo.

javascript
// Elimina el archivo "miArchivo.txt".
fs.unlink("miArchivo.txt", (err) => {
if (err) {
console.error(err);
} else {
console.log("Archivo eliminado correctamente!");
}
});


Renombrando y Copiando Archivos

El módulo fs también ofrece funciones para renombrar y copiar archivos. La función rename() renombra un archivo, mientras que la función copyFile() copia un archivo a otro.

javascript
// Renombra el archivo "miArchivo.txt" a "nuevoArchivo.txt".
fs.rename("miArchivo.txt", "nuevoArchivo.txt", (err) => {
if (err) {
console.error(err);
} else {
console.log("Archivo renombrado correctamente!");
}
});


javascript
// Copia el archivo "miArchivo.txt" a "copiaArchivo.txt".
fs.copyFile("miArchivo.txt", "copiaArchivo.txt", (err) => {
if (err) {
console.error(err);
} else {
console.log("Archivo copiado correctamente!");
}
});


Trabajando con Directorios

Además de archivos, el módulo fs también ofrece funciones para trabajar con directorios.

Creando Directorios

Para crear un nuevo directorio, podemos utilizar la función mkdir(). Esta función toma dos argumentos: el nombre del directorio y una función de devolución de llamada que se ejecutará cuando la operación se haya completado.

javascript
// Crea un nuevo directorio llamado "miDirectorio".
fs.mkdir("miDirectorio", (err) => {
if (err) {
console.error(err);
} else {
console.log("Directorio creado correctamente!");
}
});


Leyendo Directorios

Para leer el contenido de un directorio, podemos utilizar la función readdir(). Esta función toma dos argumentos: el nombre del directorio y una función de devolución de llamada que se ejecutará cuando la operación se haya completado. La función de devolución de llamada recibe dos argumentos: un posible error y una matriz que contiene los nombres de los archivos y subdirectorios del directorio.

javascript
// Lee el contenido del directorio "miDirectorio".
fs.readdir("miDirectorio", (err, files) => {
if (err) {
console.error(err);
} else {
console.log(files);
}
});


Eliminando Directorios

Para eliminar un directorio, podemos utilizar la función rmdir(). Esta función toma dos argumentos: el nombre del directorio y una función de devolución de llamada que se ejecutará cuando la operación se haya completado.

javascript
// Elimina el directorio "miDirectorio".
fs.rmdir("miDirectorio", (err) => {
if (err) {
console.error(err);
} else {
console.log("Directorio eliminado correctamente!");
}
});


Gestión de Permisos y Atributos

El módulo fs también ofrece funciones para gestionar los permisos y atributos de archivos y directorios.

Obtener Información sobre Archivos

Para obtener información sobre un archivo, podemos utilizar la función stat(). Esta función toma un único argumento: el nombre del archivo y devuelve un objeto Stats que contiene información sobre el archivo, como su tamaño, fecha de modificación, tipo de archivo (archivo o directorio), etc.

javascript
// Obtiene información sobre el archivo "miArchivo.txt".
fs.stat("miArchivo.txt", (err, stats) => {
if (err) {
console.error(err);
} else {
console.log(stats);
}
});


Cambiar Permisos de Archivos

Para cambiar los permisos de un archivo, podemos utilizar la función chmod(). Esta función toma dos argumentos: el nombre del archivo y los nuevos permisos. Los permisos se representan como un número octal, donde cada dígito representa un conjunto de permisos (leer, escribir, ejecutar).

javascript
// Cambia los permisos del archivo "miArchivo.txt" para que sea solo de lectura.
fs.chmod("miArchivo.txt", 0o444, (err) => {
if (err) {
console.error(err);
} else {
console.log("Permisos cambiados correctamente!");
}
});


Cambiar Tiempos de Acceso y Modificación

Para cambiar los tiempos de acceso y modificación de un archivo, podemos utilizar la función utimes(). Esta función toma tres argumentos: el nombre del archivo, el nuevo tiempo de acceso y el nuevo tiempo de modificación.

javascript
// Cambia el tiempo de acceso y modificación del archivo "miArchivo.txt".
const tiempoActual = new Date();
fs.utimes("miArchivo.txt", tiempoActual, tiempoActual, (err) => {
if (err) {
console.error(err);
} else {
console.log("Tiempos de acceso y modificación cambiados correctamente!");
}
});


Trabajando con Promesas

El módulo fs también ofrece una API de promesas para la gestión de archivos, utilizando la sintaxis async/await. Esta API facilita la manipulación de tareas asíncronas, eliminando la necesidad de callbacks.

Para utilizar la API de promesas, debemos importar el módulo fs/promises:

javascript
const fsPromises = require('fs/promises');


Luego, podemos utilizar las funciones de esta API con la sintaxis async/await.

«`javascript
// Escribe datos en un archivo de forma asíncrona utilizando promesas.
async function escribirArchivo(nombreArchivo, datos) {
try {
await fsPromises.writeFile(nombreArchivo, datos);
console.log(«Archivo escrito correctamente!»);
} catch (err) {
console.error(err);
}
}

// Lee datos de un archivo de forma asíncrona utilizando promesas.
async function leerArchivo(nombreArchivo) {
try {
const contenido = await fsPromises.readFile(nombreArchivo, ‘utf-8’);
console.log(contenido);
} catch (err) {
console.error(err);
}
}
«`

Conclusión

El módulo fs de Node.js proporciona una interfaz potente y completa para interactuar con el sistema de archivos. Dominar este módulo es esencial para cualquier desarrollador que trabaje con Node.js, ya que permite realizar una gran variedad de operaciones con archivos y directorios.

En este artículo, hemos explorado las principales funciones del módulo fs, desde las operaciones básicas de lectura y escritura hasta la gestión de permisos y atributos. Hemos aprendido a trabajar con funciones sincrónicas y asíncronas, utilizando callbacks, promesas y la sintaxis async/await.

Con este conocimiento, podrás crear aplicaciones Node.js robustas y eficientes que interactúen de forma fluida con el file system node.