Una guía básica para manipular el sistema de archivos en Node.js

Una de las funciones integradas de Node.js es la manipulación del sistema de archivos del sistema operativo mediante el módulo fs. Este módulo de Node.js contiene muchas funciones útiles para trabajar con archivos y directorios.

Los archivos se denominan simplemente objetos persistentes o fragmentos de datos que normalmente se almacenan en un medio duro conocido como disco o memoria. Los archivos pueden ser de varios tipos, desde archivos de texto hasta archivos de imagen, archivos de audio y muchos más.

Entonces, ¿qué es un sistema de archivos y cómo puede interactuar fácilmente con el sistema de archivos de un sistema operativo en Node.js?

¿Qué es un sistema de archivos?

Un sistema de archivos define cómo un sistema operativo puede identificar, organizar, almacenar y acceder a archivos, junto con otras operaciones.

El sistema de archivos de un sistema operativo también hace el trabajo de agrupar archivos en colecciones conocidas como directorios o carpetas. Los archivos y directorios ordinarios son las partes más comunes de un sistema de archivos con los que a menudo se interactúa entre muchos otros.

Algunos ejemplos de sistemas de archivos incluyen el Sistema de archivos de nueva tecnología (NTFS), el Sistema de archivos UNIX (UFS) y el Sistema de archivos jerárquico (HFS).

¿Qué es el módulo fs de Node.js?

El nodo.js fs module es una biblioteca integrada proporcionada por Node.js para trabajar con el sistema de archivos de cualquier sistema operativo compatible con Node. El fs El módulo es fácilmente accesible y es la biblioteca de acceso para operaciones de archivos como lectura de archivos o escribir datos en archivos en Node.js.

Se usa muy comúnmente con el camino y sistema operativo módulos para realizar diversas operaciones en los archivos. Usar el fs módulo en sus programas, puede importarlo a su código fuente como se muestra en el código a continuación.

// CommonJS
constante f = requerir('fs')
// ES6
importar fs de 'fs'

¿Qué es el módulo de ruta de Node.js?

Puedes usar Node.js camino módulo para manipular rutas de archivos. Incluye utilidades para interactuar fácilmente con rutas de archivos y directorios. Utilizando el fs y camino módulos en tándem para completar una tarea es una práctica estándar. Esto se debe a que la mayoría de fs las funciones del módulo dependen de las rutas a los archivos o directorios de destino para funcionar.

Puede importar el camino module en su código con la siguiente sintaxis:

// CommonJS
constante camino = requerir('camino')
// ES6
importar camino de 'camino'

Funciones comunes para acceder al sistema de archivos en Node.js

Aquí están los Node.js más utilizados fs y camino funciones del módulo y cómo usarlas para interactuar con archivos y directorios.

Trabajar con rutas

1. ruta.resolver: Esta es la función para resolver una ruta de una lista de instrucciones de ruta pasadas como parámetros. Por ejemplo:

   ruta.resolve('inicio', 'proyectos', 'web');
   // devoluciones /home/projects/web
   path.resolve('inicio/proyectos/web', '../móvil');
   // devoluciones /home/projects/mobile
   

2. ruta.normalizar: El normalizar La función devuelve la ruta correcta y normalizada de una ruta de entrada dada. Por ejemplo:

   ruta.normalize('inicio/proyectos/web/../móvil/./código');
   // regresa a inicio/proyectos/móvil/código
   

3. ruta.unirse: Esta función crea una ruta a partir de varios segmentos. Por ejemplo:

   path.join('inicio', 'proyectos', '../', 'películas');
   // regresa a casa/películas
   

4. ruta.nombrebase: El nombre base La función devuelve el segmento de ruta final. Puedes usarlo de dos maneras:

   ruta.nombrebase('inicio/proyectos/web/index.js');
   // devuelve index.js
   ruta.nombrebase('inicio/proyectos/web/index.js', '.js');
   // elimina la extensión y devuelve 'índice'
   

5. ruta.dirname: Esta función devuelve la ruta al último directorio de una ruta determinada. Ejemplo:

   ruta.dirname('inicio/proyectos/web/index.js');
   // regresa a inicio/proyectos/web
   

6. ruta.extname: Con esta función, puede obtener la extensión de un archivo de una ruta determinada.

   ruta.extname('inicio/proyectos/web/index.js');
   // devuelve '.js'
   

Abrir y cerrar archivos

1. fs.abierto: Esta es la función para abrir o crear un archivo sincrónicamente en Node.js. La forma sincrónica de fs.abierto es fs.openSync. fs.abrir unAcepta cuatro argumentos que son la ruta del archivo, las banderas, el modo abierto y una función de devolución de llamada. banderas y abiertomodo tienen un valor predeterminado, y puede obtener más información sobre ellos en la Node.js fs.open documentación.

   constante filePath = path.join (__dirname, '/videos/nuevoVideo.mp4');
   // __dirname devuelve la ruta al directorio de trabajo actual.
   // ruta del archivo = /videos/newVideo.mp4
   fs.open (filePath, (error, fileDescriptor) => {
   // manejar errores
   consola.log (descriptor de archivo); // imprime un entero que representa el descriptor del archivo
   })
   

2. fs.cerrar: Es una buena práctica cerrar siempre los archivos abiertos cuando ya no se necesiten. Node.js tiene la cerrar función para esto:

   fs.open (filePath, (error, fileDescriptor) => {
   // manejar errores, como 'archivo/directorio no existe'
   consola.log (descriptor de archivo);
   // cerrar el archivo
    fs.close (fileDescriptor, (error) => {
   // manejar errores
   consola.log('Archivo cerrado con éxito');
    });
   })
   

Crear y eliminar

1. fs.mkdir: Esto funciona igual que el mkdir comando de terminal que crea un nuevo directorio. Toma como parámetros una ruta, un modo (opcional) y una función de devolución de llamada. Puedes usarlo así:

   constante dirPath = ruta.join (__dirname, 'nuevoDirectorio');
   fs.mkdir (dirPath, (error) => {
   // manejar errores
   consola.log('Nuevo directorio creado con éxito');
   });
   

2. fs.unlink: Esta función elimina o borra el archivo en la ruta pasada como argumento. Considere el siguiente ejemplo de código:

   constante filePath = path.join (_dirname, 'oldFile.js');
   fs.unlink (filePath, (error) => {
   // manejar errores
   consola.log('El archivo se eliminó con éxito');
   });
   

3. fs.rmdir: Este método elimina el directorio en una ruta determinada. Es muy similar en uso al método de desvinculación:

   constante dirPath = ruta.resolve('inicio', 'proyectos', 'web');
   fs.rmdir (dirPath, (error) => {
   // manejar errores
   consola.log('Directorio eliminado con éxito');
   })
   

1. fs.existe: El existe El método comprueba si existe el archivo en una ruta dada. La implementación es la siguiente:

   dejar filePath = path.join (__dirname, 'index.html');
   fs.exists (filePath, (existe) => {
   consola.log (existe) // verdadero o falso
   })
   

2. fs.stat: Esta es una función síncrona que devuelve las propiedades de un archivo. Devuelve un fs. Estadísticas objeto que expone algunos métodos para acceder a las propiedades del archivo. Aquí hay un ejemplo:

   fs.stat('index.js', (error, estadísticas) => {
   consola.log (estadísticas); // imprime propiedades de bajo nivel del archivo
    estadísticas.isFile(); // devuelve verdadero
    stats.isDirectory(); // devuelve falso
   })
   

Manipulación del sistema de archivos en Node.js

La inmensidad de la fs El módulo hace que sea muy fácil acceder e interactuar con archivos en cualquier sistema operativo. Cuando lo usa junto con el camino módulo, está abierto a más funciones y puede manipular el sistema de archivos como desee.

Una gran ventaja de Node.js es su portabilidad. Puede desarrollar sus aplicaciones en cualquier plataforma e implementarlas en cualquier lugar sin preocuparse por problemas básicos de compatibilidad.