{"id":54117,"date":"2022-07-12T09:20:02","date_gmt":"2022-07-12T07:20:02","guid":{"rendered":"https:\/\/kinsta.com\/es\/?p=54117&post_type=knowledgebase&preview_id=54117"},"modified":"2025-10-01T21:32:05","modified_gmt":"2025-10-01T19:32:05","slug":"nodejs-fs","status":"publish","type":"post","link":"https:\/\/kinsta.com\/es\/blog\/nodejs-fs\/","title":{"rendered":"Entender el M\u00f3dulo del Sistema de Archivos de Node.js (FS)"},"content":{"rendered":"

JavaScript ha sido durante mucho tiempo uno de los lenguajes de scripting m\u00e1s populares, pero durante un largo periodo de tiempo, no fue una gran opci\u00f3n para el desarrollo de aplicaciones de backend del lado del servidor. Entonces lleg\u00f3 Node.js, que se utiliza para crear aplicaciones ligeras del lado del servidor, basadas en eventos, construidas con el lenguaje de programaci\u00f3n JavaScript.<\/p>\n

Node.js es un tiempo de ejecuci\u00f3n de JavaScript de c\u00f3digo abierto<\/a> que se puede descargar e instalar gratuitamente en cualquiera de los principales sistemas operativos (Windows, Mac, Linux). En los \u00faltimos a\u00f1os se ha hecho cada vez m\u00e1s popular entre los creadores de aplicaciones<\/a>, y ha proporcionado muchas nuevas oportunidades de empleo<\/a> para los desarrolladores de JavaScript que buscan una especialidad.<\/p>\n\n

En este art\u00edculo, aprenderemos a gestionar el sistema de archivos utilizando Node.js. Es f\u00e1cil utilizar las API de Node.js para interactuar con el sistema de archivos y realizar muchas operaciones complejas, y saber c\u00f3mo maniobrar con ellas aumentar\u00e1 tu productividad.<\/p>\n

\u00a1Vamos a sumergirnos!<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Requisitos previos para entender el sistema de archivos de Node.js<\/h2>\n

El principal requisito previo es la instalaci\u00f3n de Node.js en tu sistema operativo. Node.js no requiere ning\u00fan hardware complejo para funcionar, por lo que es f\u00e1cil descargar e instalar Node.js<\/a> en tu ordenador.<\/p>\n

Ser\u00eda \u00fatil que tambi\u00e9n tuvieras conocimientos b\u00e1sicos de JavaScript<\/a> para trabajar con m\u00f3dulos de Node.js como los sistemas de archivos (tambi\u00e9n conocidos como \u00abFS\u00bb o \u00abfs\u00bb). Una comprensi\u00f3n de alto nivel de las funciones de JavaScript, las funciones de devoluci\u00f3n de llamada y las promesas te ayudar\u00e1n a dominar este tema<\/a> a\u00fan m\u00e1s r\u00e1pido.<\/p>\n

M\u00f3dulo del Sistema de Archivos de Node.js<\/h2>\n

Trabajar con archivos y directorios es una de las necesidades b\u00e1sicas de una aplicaci\u00f3n full-stack. Tus usuarios pueden querer subir im\u00e1genes, curr\u00edculos u otros archivos a un servidor. Al mismo tiempo, tu aplicaci\u00f3n puede necesitar leer archivos de configuraci\u00f3n, mover archivos o incluso cambiar sus permisos mediante programaci\u00f3n.<\/p>\n

El m\u00f3dulo del sistema de archivos de Node.js tiene todo esto cubierto. Proporciona varias API para interactuar con los sistemas de archivos sin problemas. La mayor\u00eda de las API son personalizables con opciones y banderas. Tambi\u00e9n puedes utilizarlas para realizar operaciones de archivo tanto s\u00edncronas como as\u00edncronas.<\/p>\n

Antes de sumergirnos en el m\u00f3dulo del sistema de archivos, echemos un vistazo a lo que es el m\u00f3dulo Node.js.<\/p>\n

M\u00f3dulos Node.js<\/h3>\n

Los m\u00f3dulos de Node.js son un conjunto de funcionalidades disponibles como APIs para que las utilice un programa consumidor. Por ejemplo, tienes el m\u00f3dulo fs<\/code> para interactuar con el sistema de archivos. Asimismo, un m\u00f3dulo http<\/code> utiliza sus funciones para crear un servidor y muchas m\u00e1s operaciones. Node.js ofrece un mont\u00f3n de m\u00f3dulos para abstraer muchas funcionalidades de bajo nivel por ti.<\/p>\n

Tambi\u00e9n puedes crear tus propios m\u00f3dulos. A partir de la versi\u00f3n 14 de Node.js, puedes crear y utilizar los m\u00f3dulos de Node.js de dos maneras: M\u00f3dulos CommonJS (CJS) y m\u00f3dulos ESM (MJS). Todos los ejemplos que veremos en este art\u00edculo son del estilo CJS.<\/p>\n

Trabajar con archivos en Node.js<\/h2>\n

Trabajar con archivos implica varias operaciones con archivos y directorios (carpetas). Ahora aprenderemos sobre cada una de estas operaciones con c\u00f3digo fuente de ejemplo. Por favor, abre tu editor de c\u00f3digo fuente<\/a> favorito y pru\u00e9balos mientras lees.<\/p>\n

Primero, importa el m\u00f3dulo fs<\/code> a tu archivo fuente para empezar a trabajar con los m\u00e9todos del sistema de archivos. En el estilo CJS, utilizamos el m\u00e9todo require<\/code> para importar un m\u00e9todo de un m\u00f3dulo. As\u00ed, para importar y utilizar los m\u00e9todos del m\u00f3dulo fs, har\u00edas lo siguiente<\/p>\n

const { writeFile } = require('fs\/promises');<\/code><\/pre>\n
Adem\u00e1s, ten en cuenta que estamos importando el m\u00e9todo writeFile<\/code> del paquete fs\/promises<\/code>. Queremos utilizar los m\u00e9todos promisorios, ya que son los m\u00e1s recientes, y son f\u00e1ciles de usar con las palabras clave async\/await y con menos c\u00f3digo. Otras alternativas son los m\u00e9todos s\u00edncronos y las funciones de devoluci\u00f3n de llamada que veremos m\u00e1s adelante.<\/p>\n
\u00bfC\u00f3mo Cambiar el T\u00edtulo del Sitio de WordPress? (5 M\u00e9todos Sencillos)C\u00f3mo crear y escribir en un archivo<\/h3>\n
Puedes crear y escribir en un archivo de tres maneras:<\/p>\n
    \n
  1. Utilizando el m\u00e9todo writeFile<\/code><\/li>\n
  2. Utilizando el m\u00e9todo appendFile<\/code><\/li>\n
  3. Utilizaci\u00f3n del m\u00e9todo openFile<\/code><\/li>\n<\/ol>\n
    Estos m\u00e9todos aceptan una ruta de archivo y los datos como contenido a escribir en el archivo. Si el archivo existe, sustituyen el contenido del archivo. Si no, se crea un nuevo archivo con el contenido.<\/p>\n
    1. Uso del m\u00e9todo writeFile<\/h4>\n
    El siguiente fragmento de c\u00f3digo muestra el uso del m\u00e9todo writeFile<\/code>. Empieza por crear un archivo llamado createFile.js<\/strong> utilizando el fragmento de c\u00f3digo que aparece a continuaci\u00f3n:<\/p>\n
    const { writeFile } = require('fs\/promises');\nasync function writeToFile(fileName, data) {\n  try {\n    await writeFile(fileName, data);\n    console.log(`Wrote data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to write the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ten en cuenta que estamos utilizando la palabra clave await<\/code> para invocar el m\u00e9todo, ya que devuelve una promesa de JavaScript. Una promesa exitosa crear\u00e1\/escribir\u00e1 en el archivo. Tenemos un bloque try-catch para manejar los errores en caso de que la promesa sea rechazada.<\/p>\n
    Ahora podemos invocar la funci\u00f3n writeToFile<\/code>:<\/p>\n
    writeToFile('friends.txt', 'Bob');<\/code><\/pre>\n
    A continuaci\u00f3n, abre un s\u00edmbolo del sistema o un terminal y ejecuta el programa anterior con el siguiente comando:<\/p>\n
    node createFile.js<\/code><\/pre>\n
    Se crear\u00e1 un nuevo archivo llamado amigos.txt<\/strong> con una l\u00ednea que diga simplemente<\/p>\n
    Bob<\/code><\/pre>\n
    2. Uso del m\u00e9todo appendFile<\/h4>\n
    Como su nombre indica, el uso principal de este m\u00e9todo es a\u00f1adir y editar un archivo. Sin embargo, tambi\u00e9n puedes utilizar el mismo m\u00e9todo para crear un archivo.<\/p>\n
    Echa un vistazo a la siguiente funci\u00f3n. Utilizamos el m\u00e9todo appendFile<\/code> con la bandera w<\/code> para escribir un archivo. La bandera por defecto para a\u00f1adir a un archivo es a<\/code>:<\/p>\n
    const { appendFile} = require('fs\/promises');\n\nasync function appendToFile(fileName, data) {\n  try {\n    await appendFile(fileName, data, { flag: 'w' });\n    console.log(`Appended data to ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to append the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Ahora, puedes invocar la funci\u00f3n anterior as\u00ed<\/p>\n
    appendToFile('activities.txt', 'Skiing');<\/code><\/pre>\n
    A continuaci\u00f3n, puedes ejecutar el c\u00f3digo en el entorno Node.js utilizando el comando node, como vimos anteriormente. Esto crear\u00e1 un archivo llamado activities.txt<\/strong> con el contenido Skiing<\/code> en \u00e9l.<\/p>\n
    3. Utilizar el m\u00e9todo open<\/h4>\n
    El \u00faltimo m\u00e9todo que aprenderemos para crear y escribir en un archivo es el m\u00e9todo open<\/code>. Puedes abrir un archivo utilizando la bandera w<\/code> (para \u00abescribir\u00bb):<\/p>\n
    const { open} = require('fs\/promises');\n\nasync function openFile(fileName, data) {\n  try {\n    const file = await open(fileName, 'w');\n    await file.write(data);\n    console.log(`Opened file ${fileName}`);\n  } catch (error) {\n    console.error(`Got an error trying to open the file: {error.message}`);\n  }\n}<\/code><\/pre>\n
    Ahora invoca la funci\u00f3n openFile<\/code> con:<\/p>\n
    openFile('tasks.txt', 'Do homework');<\/code><\/pre>\n
    Cuando ejecutes el script con el comando nodo, tendr\u00e1s un archivo llamado tareas.txt<\/strong> creado con el contenido inicial:<\/p>\n
    Do homework<\/code><\/pre>\n
    \u00bfC\u00f3mo leer un archivo?<\/h3>\n
    Ahora que sabemos c\u00f3mo crear y escribir en un archivo, vamos a aprender a leer el contenido de un archivo. Para ello utilizaremos el m\u00e9todo readFile<\/code> del m\u00f3dulo del sistema de archivos.<\/p>\n
    Crea un archivo llamado readThisFile.js<\/strong> con el siguiente c\u00f3digo:<\/p>\n
    \/\/ readThisFile.js\nconst { readFile } = require('fs\/promises');\nasync function readThisFile(filePath) {\n  try {\n    const data = await readFile(filePath);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(`Got an error trying to read the file: {error.message}`);\n }\n}<\/code><\/pre>\n
    Ahora vamos a leer los tres archivos que hemos creado invocando la funci\u00f3n readThisFile<\/code>:<\/p>\n
    readThisFile('activities.txt');\nreadThisFile('friends.txt');\nreadThisFile('tasks.txt');<\/code><\/pre>\n
    Por \u00faltimo, ejecuta el script con el siguiente comando de nodo:<\/p>\n
    node readThisFile.js<\/code><\/pre>\n
    Deber\u00edas ver la siguiente salida en la consola:<\/p>\n
    Skiing\nDo homework\nBob<\/code><\/pre>\n
    Un punto a tener en cuenta aqu\u00ed: El m\u00e9todo readFile<\/code> lee el archivo de forma as\u00edncrona. Esto significa que el orden en el que lee el archivo y el orden en el que obtiene una respuesta para imprimir en la consola puede no ser el mismo. Tienes que utilizar la versi\u00f3n sincr\u00f3nica del m\u00e9todo readFile<\/code> para conseguirlo en orden. Lo veremos aqu\u00ed dentro de un rato.<\/p>\n
    \u00bfC\u00f3mo cambiar el nombre de un archivo?<\/h3>\n
    Para renombrar un archivo, utiliza el m\u00e9todo rename del m\u00f3dulo fs. Vamos a crear un archivo llamado rename-me.txt<\/strong>. Renombraremos este archivo mediante programaci\u00f3n.<\/p>\n
    Crea un archivo llamado renameFile.js<\/strong> con el siguiente c\u00f3digo:<\/p>\n
    const { rename } = require('fs\/promises');\n\nasync function renameFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Renamed ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to rename the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Como habr\u00e1s notado, el m\u00e9todo renombrar toma dos argumentos. Uno es el archivo con el nombre de origen, y el otro es el nombre de destino.<\/p>\n
    Ahora vamos a invocar la funci\u00f3n anterior para renombrar el archivo:<\/p>\n
    const oldName = \"rename-me.txt\";\nconst newName = \"renamed.txt\";\nrenameFile(oldName, newName);<\/code><\/pre>\n
    Al igual que antes, ejecuta el archivo de script utilizando el comando nodo para renombrar el archivo:<\/p>\n
    node renameFile.js<\/code><\/pre>\n
    \u00bfC\u00f3mo mover un archivo?<\/h3>\n
    Mover un archivo de un directorio a otro es similar a renombrar su ruta. Por tanto, podemos utilizar el propio m\u00e9todo rename<\/code> para mover archivos.<\/p>\n
    Vamos a crear dos carpetas, desde<\/strong> y hasta<\/strong>. Luego crearemos un archivo llamado moverme.txt <\/strong>dentro de la carpeta desde<\/strong>.<\/p>\n
    A continuaci\u00f3n, escribiremos el c\u00f3digo para mover el archivo move-me. txt<\/strong>. Crea un archivo llamado moveFile.js<\/strong> con el siguiente fragmento:<\/p>\n
    const { rename } = require('fs\/promises');\nconst { join } = require('path');\nasync function moveFile(from, to) {\n  try {\n    await rename(from, to);\n    console.log(`Moved ${from} to ${to}`);\n  } catch (error) {\n    console.error(`Got an error trying to move the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Como puedes ver, estamos utilizando el m\u00e9todo rename<\/code> igual que antes. Pero, \u00bfpor qu\u00e9 necesitamos importar el m\u00e9todo join<\/code> del m\u00f3dulo path<\/code> (s\u00ed, la ruta es otro m\u00f3dulo crucial de Node.js)?<\/p>\n
    El m\u00e9todo join<\/code> se utiliza para unir varios segmentos de ruta especificados para formar una ruta. Lo utilizaremos para formar la ruta de los nombres de los archivos de origen y destino:<\/p>\n
    const fromPath = join(__dirname, \"from\", \"move-me.txt\");\nconst destPath = join(__dirname, \"to\", \"move-me.txt\");\nmoveFile(fromPath, destPath);<\/code><\/pre>\n
    \u00a1Y eso es todo! Si ejecutas el script moveFile.js<\/strong>, ver\u00e1s que el archivo move-me.txt<\/strong> se ha movido a la carpeta to<\/strong>.<\/p>\n
    \u00bfC\u00f3mo copiar un archivo?<\/h3>\n
    Utilizamos el m\u00e9todo copyFile<\/code> del m\u00f3dulo fs<\/code> para copiar un archivo del origen al destino.<\/p>\n
    Echa un vistazo al fragmento de c\u00f3digo que aparece a continuaci\u00f3n:<\/p>\n
    const { copyFile } = require('fs\/promises');\nconst { join } = require('path');\nasync function copyAFile(from, to) {\n  try {\n    await copyFile(from, to);\n    console.log(`Copied ${from} to ${to}`);\n  } catch (err) {\n    console.error(`Got an error trying to copy the file: ${err.message}`);\n  }\n}<\/code><\/pre>\n
    Ahora puedes invocar la funci\u00f3n anterior con<\/p>\n
    copyAFile('friends.txt', 'friends-copy.txt');<\/code><\/pre>\n
    Copiar\u00e1 el contenido de amigos.txt<\/strong> al archivo amigos-copia.txt<\/strong>.<\/p>\n
    Eso est\u00e1 muy bien, pero \u00bfc\u00f3mo se copian varios archivos?<\/p>\n
    Puedes utilizar la API Promise.all<\/code> para ejecutar varias promesas en paralelo:<\/p>\n
    async function copyAll(fromDir, toDir, filePaths) {\n  return Promise.all(filePaths.map(filePath => {\n   return copyAFile(join(fromDir, filePath), join(toDir, filePath));\n  }));\n}<\/code><\/pre>\n
    Ahora puedes suministrar todas las rutas de los archivos para copiarlos de un directorio a otro:<\/p>\n
    copyFiles('from', 'to', ['copyA.txt', 'copyB.txt']);<\/code><\/pre>\n
    Tambi\u00e9n puedes utilizar este m\u00e9todo para realizar otras operaciones como mover, escribir y leer archivos en paralelo.<\/p>\n
    \u00bfC\u00f3mo eliminar un archivo?<\/h3>\n
    Utilizamos el m\u00e9todo unlink<\/code> para eliminar un archivo:<\/p>\n
    const { unlink } = require('fs\/promises');\nasync function deleteFile(filePath) {\n  try {\n    await unlink(filePath);\n    console.log(`Deleted ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the file: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Recuerda que tendr\u00e1s que proporcionar la ruta del archivo para eliminarlo:<\/p>\n
    deleteFile('delete-me.txt');<\/code><\/pre>\n
    Ten en cuenta que si la ruta es un enlace simb\u00f3lico a otro archivo, el m\u00e9todo de desvinculaci\u00f3n cancelar\u00e1 el enlace simb\u00f3lico, pero el archivo original no se ver\u00e1 afectado. M\u00e1s adelante hablaremos de los enlaces simb\u00f3licos.<\/p>\n
    C\u00f3mo cambiar los permisos y la propiedad de los archivos<\/h3>\n
    Puede que en alg\u00fan momento quieras cambiar los permisos de los archivos mediante programaci\u00f3n. Esto puede ser muy \u00fatil para hacer que un archivo sea de s\u00f3lo lectura o totalmente accesible.<\/p>\n
    Utilizaremos el m\u00e9todo chmod<\/code> para cambiar el permiso de un archivo:<\/p>\n
    const { chmod } = require('fs\/promises');\nasync function changePermission(filePath, permission) {\n  try {\n    await chmod(filePath, permission);\n    console.log(`Changed permission to ${permission} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change permission: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Podemos pasar la ruta del archivo y la m\u00e1scara de bits del permiso para cambiar el permiso.<\/p>\n
    Aqu\u00ed est\u00e1 la llamada a la funci\u00f3n para cambiar el permiso de un archivo a s\u00f3lo lectura:<\/p>\n
    changePermission('permission.txt', 0o400);<\/code><\/pre>\n
    De forma similar al permiso, tambi\u00e9n puedes cambiar la propiedad de un archivo mediante programaci\u00f3n. Para ello utilizamos el m\u00e9todo chown<\/code>:<\/p>\n
    const { chown } = require('fs\/promises');\n\nasync function changeOwnership(filePath, userId, groupId) {\n  try {\n    await chown(filePath, userId, groupId);\n    console.log(`Changed ownership to ${userId}:${groupId} for ${filePath}`);\n  } catch (error) {\n    console.error(`Got an error trying to change ownership: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Luego llamamos a la funci\u00f3n con la ruta del archivo, el ID de usuario y el ID de grupo:<\/p>\n
    changeOwnership('ownership.txt', 1000, 1010);<\/code><\/pre>\n
    \u00bfC\u00f3mo crear un enlace simb\u00f3lico?<\/h3>\n
    El enlace simb\u00f3lico (tambi\u00e9n conocido como symlink)<\/a> es un concepto del sistema de archivos para crear un enlace a un archivo o carpeta. Creamos enlaces simb\u00f3licos para crear accesos directos a un archivo\/carpeta de destino en el sistema de archivos. El m\u00f3dulo de Node.js filesystem<\/code> proporciona el m\u00e9todo symlink<\/code> para crear un enlace simb\u00f3lico.<\/p>\n
    Para crear el enlace simb\u00f3lico, tenemos que pasar la ruta del archivo de destino, la ruta real del archivo y el tipo:<\/p>\n
    const { symlink } = require('fs\/promises');\nconst { join } = require('path');\nasync function createSymlink(target, path, type) {\n  try {\n    await symlink(target, path, type);\n    console.log(`Created symlink to ${target} at ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the symlink: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Podemos invocar la funci\u00f3n con:<\/p>\n
    createSymlink('join(__dirname, from, symMe.txt)', 'symToFile', 'file');<\/code><\/pre>\n
    Aqu\u00ed hemos creado un enlace simb\u00f3lico llamado symToFile<\/code>.<\/p>\n
    \u00bfC\u00f3mo ver los cambios en un archivo?<\/h3>\n
    \u00bfSab\u00edas que puedes observar los cambios que se producen en un archivo? Es una buena forma de controlar las alteraciones y los eventos, especialmente cuando no los esperas. Puedes capturarlas y auditarlas para su posterior revisi\u00f3n.<\/p>\n
    El m\u00e9todo watch<\/code> es la mejor manera de observar los cambios en los archivos. Existe un m\u00e9todo alternativo llamado watchFile<\/code>, pero no es tan eficaz como el m\u00e9todo watch<\/code>.<\/p>\n
    Hasta ahora, hemos utilizado el m\u00e9todo del m\u00f3dulo del sistema de archivos con las palabras clave async\/await. Veamos los usos de la funci\u00f3n de devoluci\u00f3n de llamada con este ejemplo.<\/p>\n
    El m\u00e9todo watch<\/code> acepta como argumentos la ruta del archivo y una funci\u00f3n de devoluci\u00f3n de llamada. Cada vez que se produce una actividad en el archivo, se llama a la funci\u00f3n callback<\/code>.<\/p>\n
    Podemos aprovechar el par\u00e1metro event<\/code> para obtener m\u00e1s informaci\u00f3n sobre las actividades:<\/p>\n
    const fs = require('fs');\nfunction watchAFile(file) {\n  fs.watch(file, (event, filename) => {\n    console.log(`${filename} file Changed`);\n  });\n}<\/code><\/pre>\n
    Invoca la funci\u00f3n pasando un nombre de archivo a watch<\/code>:<\/p>\n
    watchAFile('friends.txt');<\/code><\/pre>\n
    Ahora capturamos autom\u00e1ticamente cualquier actividad en el archivo friends.txt<\/strong>.<\/p>\n
    Trabajar con directorios (carpetas) en Node.js<\/h2>\n
    Pasemos ahora a aprender c\u00f3mo realizar operaciones sobre directorios o carpetas. Muchas de las operaciones como renombrar, mover y copiar son similares a las que hemos visto para los archivos. Sin embargo, hay m\u00e9todos y operaciones espec\u00edficas que s\u00f3lo se pueden realizar sobre directorios.<\/p>\n
    \u00bfC\u00f3mo crear un directorio?<\/h3>\n
    Utilizamos el m\u00e9todo mkdir<\/code> para crear un directorio. Tienes que pasar el nombre del directorio como argumento:<\/p>\n
    const { mkdir } = require('fs\/promises');\nasync function createDirectory(path) {\n  try {\n    await mkdir(path);\n    console.log(`Created directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ahora podemos invocar la funci\u00f3n createDirectory<\/code> con una ruta de directorio:<\/p>\n
    createDirectory('new-directory');<\/code><\/pre>\n
    Esto crear\u00e1 un directorio llamado nuevo-directorio<\/strong>.<\/p>\n
    \u00bfC\u00f3mo crear un directorio temporal?<\/h3>\n
    Los directorios temporales no son directorios normales. Tienen un significado especial para el sistema operativo. Puedes crear un directorio temporal utilizando el m\u00e9todo mkdtemp()<\/code>.<\/p>\n
    Vamos a crear una carpeta temporal dentro del directorio temporal de tu sistema operativo. Obtenemos la informaci\u00f3n para la ubicaci\u00f3n del directorio temporal del m\u00e9todo tmpdir()<\/code> del m\u00f3dulo os<\/code>:<\/p>\n
    const { mkdtemp } = require('fs\/promises');\nconst { join } = require('path');\nconst { tmpdir } = require('os');\nasync function createTemporaryDirectory(fileName) {\n  try {\n    const tempDirectory = await mkdtemp(join(tmpdir(), fileName));\n    console.log(`Created temporary directory ${tempDirectory}`);\n  } catch (error) {\n    console.error(`Got an error trying to create the temporary directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    Ahora, vamos a llamar a la funci\u00f3n con el nombre del directorio para crearlo:<\/p>\n
    createTemporaryDirectory('node-temp-file-');<\/code><\/pre>\n
    Ten en cuenta que Node.js a\u00f1adir\u00e1 seis caracteres aleatorios al final del nombre de la carpeta temporal creada para que sea \u00fanica.<\/p>\n
    \u00bfC\u00f3mo eliminar un directorio?<\/h3>\n
    Tienes que utilizar el m\u00e9todo rmdir()<\/code> para eliminar\/borrar un directorio:<\/p>\n
    const { rmdir } = require('fs\/promises');\nasync function deleteDirectory(path) {\n  try {\n    await rmdir(path);\n    console.log(`Deleted directory ${path}`);\n  } catch (error) {\n    console.error(`Got an error trying to delete the directory: ${error.message}`);\n  }\n}<\/code><\/pre>\n
    A continuaci\u00f3n, llama a la funci\u00f3n anterior pasando la ruta de la carpeta que quieres eliminar:<\/p>\n
    deleteDirectory('new-directory-renamed');<\/code><\/pre>\n
    APIs s\u00edncronas vs. as\u00edncronas<\/h2>\n
    Hasta ahora, hemos visto muchos ejemplos de m\u00e9todos del sistema de archivos, y todos ellos son con usos as\u00edncronos. Sin embargo, es posible que necesites manejar algunas operaciones de forma sincr\u00f3nica.<\/p>\n
    Un ejemplo de operaci\u00f3n sincr\u00f3nica es la lectura de varios archivos uno tras otro. El m\u00f3dulo fs<\/code> tiene un m\u00e9todo llamado readFileSync()<\/code> para hacerlo:<\/p>\n
    const { readFileSync } = require('fs');\nfunction readFileSynchronously(path) {\n  try {\n    const data = readFileSync(path);\n    console.log(data.toString());\n  } catch (error) {\n    console.error(error);\n  }\n}<\/code><\/pre>\n
    Ten en cuenta que el m\u00e9todo readFileSync()<\/code> no es necesario desde el paquete \u00abfs\/promesas\u00bb. Esto se debe a que el m\u00e9todo no es as\u00edncrono. Por tanto, puedes llamar a la funci\u00f3n anterior con<\/p>\n
    readFileSynchronously('activities.txt');\nreadFileSynchronously('friends.txt');\nreadFileSynchronously('tasks.txt');<\/code><\/pre>\n
    En este caso, todos los archivos anteriores se leer\u00e1n en el orden en que se llamaron las funciones.<\/p>\n
    El m\u00f3dulo del sistema de archivos de Node.js ofrece un m\u00e9todo s\u00edncrono para otras operaciones como la de lectura. Util\u00edzalos con prudencia y s\u00f3lo cuando sea necesario. Los m\u00e9todos as\u00edncronos son mucho m\u00e1s \u00fatiles para la ejecuci\u00f3n en paralelo.<\/p>\n
    Manejo de errores<\/h2>\n
    Como sabe cualquier programador, tienes que esperar que se produzcan errores y estar preparado para manejarlos<\/a> cuando realices una operaci\u00f3n de archivo o directorio. \u00bfQu\u00e9 pasa si no se encuentra el archivo, o si no tienes permiso para escribir en un archivo? Puede haber (y probablemente habr\u00e1) muchos casos en los que puedas encontrar un error.<\/p>\n
    Siempre debes rodear tus llamadas a m\u00e9todos con un bloque try-catch. De esta forma, si se produce un error, el control pasar\u00e1 al bloque catch, donde podr\u00e1s revisar y manejar el error. Como habr\u00e1s observado en todos los ejemplos anteriores, hemos utilizado el bloque try-catch para manejar los errores que nos encontramos.<\/p>\n\n
    Resumen<\/h2>\n
    Repasemos los puntos clave que hemos cubierto en este tutorial:<\/p>\n