Sistema de archivos Node.js

Posted on by Rudeus Greyrat

Node.js es un tiempo de ejecución de JavaScript basado en el motor de JavaScript V8 de Chrome. Node.js ayuda a los desarrolladores a escribir código JavaScript para ejecutarlo en el lado del servidor, para generar contenido dinámico y entregarlo a los clientes web.

Las dos características que hacen que Node.js se destaque son:

  • Evento conducido
  • Modelo de E/S sin bloqueo

Acerca del sistema de archivos Node.js: para manejar operaciones de archivos como crear, leer, eliminar, etc., Node.js proporciona un módulo incorporado llamado FS (Sistema de archivos). Node.js brinda la funcionalidad de E/S de archivos al proporcionar contenedores alrededor de las funciones POSIX estándar. Todas las operaciones del sistema de archivos pueden tener formas sincrónicas y asincrónicas según los requisitos del usuario.

Para usar este módulo de sistema de archivos, use el método require():

var fs = require('fs');

Uso común para el módulo del sistema de archivos:

  • Leer archivos
  • Escribir archivos
  • Agregar archivos
  • Cerrar archivos
  • Borrar archivos

¿Qué es el enfoque síncrono y asíncrono?

  • Enfoque síncrono: se denominan funciones de bloqueo, ya que espera a que se complete cada operación, solo después de eso, ejecuta la siguiente operación, por lo tanto, bloquea la ejecución del siguiente comando, es decir, un comando no se ejecutará hasta & a menos que la consulta haya terminado de ejecutarse para obtener todo el resultado de los comandos anteriores.
  • Enfoque asincrónico: se denominan funciones sin bloqueo, ya que nunca espera a que se complete cada operación, sino que ejecuta todas las operaciones en el primer intento. El resultado de cada operación se manejará una vez que el resultado esté disponible, es decir, cada comando se ejecutará poco después de la ejecución del comando anterior. Mientras que el comando anterior se ejecuta en segundo plano y carga el resultado una vez que termina de procesar los datos.
  • Casos de uso:
    • Si sus operaciones no están haciendo un trabajo muy pesado, como consultar grandes datos de la base de datos, continúe con la forma sincrónica, de lo contrario, con la forma asincrónica.
    • De forma Asincrónica, puede mostrar algún indicador de progreso al usuario mientras que en segundo plano puede continuar con sus trabajos pesados. Este es un escenario ideal para aplicaciones basadas en GUI.
  • Ejemplo de asíncrono y síncrono: Cree un archivo de texto llamado input.txt con el siguiente contenido: 
    GeeksforGeeks: A computer science portal

    Ahora vamos a crear un archivo js llamado main.js con el siguiente código:

    var fs = require("fs");
      
    // Asynchronous read
    fs.readFile('input.txt', function (err, data) {
       if (err) {
          return console.error(err);
       }
       console.log("Asynchronous read: " + data.toString());
    });

    Producción:

    Asynchronous read: GeeksforGeeks: A computer science portal

    var fs = require("fs");
      
    // Synchronous read
    var data = fs.readFileSync('input.txt');
    console.log("Synchronous read: " + data.toString());

    Producción:

    Synchronous read: GeeksforGeeks: A computer science portal

Abrir un archivo: el método fs.open() se usa para crear, leer o escribir un archivo. El método fs.readFile() es solo para leer el archivo y el método fs.writeFile() es solo para escribir en el archivo, mientras que el método fs.open() realiza varias operaciones en un archivo. Primero, necesitamos cargar la clase fs, que es un módulo para acceder al sistema de archivos físico.

Sintaxis:

fs.open(path, flags, mode, callback)

Parámetros:

  • ruta: contiene el nombre del archivo para leer o la ruta completa si se almacena en otras ubicaciones.
  • banderas: Las banderas indican el comportamiento del archivo que se va a abrir. Todos los valores posibles son (r, r+, rs, rs+, w, wx, w+, wx+, a, ax, a+, ax+).
  • mode: Establece el modo del archivo, es decir, r-read, w-write, r+ -readwrite. Se establece por defecto como lectura y escritura.
    • llamar de vuelta:

    Es una función de devolución de llamada que se llama después de leer un archivo. Toma dos parámetros:

  • err: Si ocurre algún error.
  • data: Contenido del archivo. Se llama después de ejecutar la operación de apertura.

Ejemplo: Vamos a crear un archivo js llamado main.js que tenga el siguiente código para abrir un archivo input.txt para lectura y escritura.

var fs = require("fs");
  
// Asynchronous - Opening File
console.log("opening file!");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File open successfully");     
});

Producción:

opening file!
File open successfully

Leer un archivo: el método fs.read() se usa para leer el archivo especificado por fd. Este método lee todo el archivo en el búfer.

Sintaxis:

fs.read(fd, buffer, offset, length, position, callback)

Parámetros:

  • fd: este es el descriptor de archivo devuelto por el método fs.open().
  • búfer: Este es el búfer en el que se escribirán los datos.
  • offset: este es el desplazamiento en el búfer para comenzar a escribir.
  • longitud: Este es un número entero que especifica el número de bytes para leer.
  • position: este es un número entero que especifica desde dónde comenzar a leer en el archivo. Si la posición es nula, los datos se leerán desde la posición actual del archivo.
  • devolución de llamada: es una función de devolución de llamada que se llama después de leer el archivo. Toma dos parámetros:
    • err: Si ocurre algún error.
    • data: Contenido del archivo.

Ejemplo: Vamos a crear un archivo js llamado main.js que tenga el siguiente código:

var fs = require("fs");
var buf = new Buffer(1024);
  
console.log("opening an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
   console.log("reading the file");
     
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }
      console.log(bytes + " bytes read");
        
      // Print only read bytes to avoid junk.
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }
   });
});

Producción:

opening an existing file
File opened successfully!
reading the file
GeeksforGeeks: A computer science portal

Escribir en un archivo: este método sobrescribirá el archivo si ya existe. El método fs.writeFile() se utiliza para escribir de forma asíncrona los datos especificados en un archivo. De forma predeterminada, el archivo se reemplazaría si existe. El parámetro ‘opciones’ se puede utilizar para modificar la funcionalidad del método.

Sintaxis:

fs.writeFile(path, data, options, callback)

Parámetros:

  • ruta: Es un número entero de string, búfer, URL o descripción de archivo que indica la ruta del archivo donde debe escribirse. El uso de un descriptor de archivo hará que se comporte de manera similar al método fs.write().
  • data: es una string, Buffer, TypedArray o DataView que se escribirá en el archivo.
  • opciones: es una string u objeto que se puede usar para especificar parámetros opcionales que afectarán la salida. Tiene tres parámetros opcionales:
    • codificación: Es un valor de string que especifica la codificación del archivo. El valor predeterminado es ‘utf8’.
    • modo: Es un valor entero que especifica el modo del archivo. El valor predeterminado es 0o666.
    • bandera: es un valor de string que especifica la bandera utilizada al escribir en el archivo. El valor predeterminado es ‘w’.
  • callback: Es la función que sería llamada cuando se ejecuta el método.
    • err: Es un error que se lanzaría si falla la operación.

Ejemplo: Vamos a crear un archivo js llamado main.js que tenga el siguiente código:

var fs = require("fs");
  
console.log("writing into existing file");
fs.writeFile('input.txt', 'Geeks For Geeks', function(err) {
   if (err) {
      return console.error(err);
   }
     
   console.log("Data written successfully!");
   console.log("Let's read newly written data");
     
   fs.readFile('input.txt', function (err, data) {
      if (err) {
         return console.error(err);
      }
      console.log("Asynchronous read: " + data.toString());
   });
});

Producción:

writing into existing file
Data written successfully!
Let's read newly written data
Asynchronous read: Geeks For Geeks

Agregar a un archivo: el método fs.appendFile() se usa para agregar de forma síncrona los datos al archivo.

Sintaxis:

fs.appendFile(filepath, data, options, callback);

o

fs.appendFileSync(filepath, data, options);

Parámetros:

  • filepath: es una string que especifica la ruta del archivo.
  • data: Es obligatorio y contiene los datos que anexes al archivo.
  • opciones: Es un parámetro opcional que especifica la codificación/modo/bandera.
  • Devolución de llamada: la función es obligatoria y se llama cuando se completa la adición de datos al archivo.

Ejemplo 1: Vamos a crear un archivo js llamado main.js con el siguiente código:

var fs = require('fs');
   
var data = "\nLearn Node.js";
   
// Append data to file
fs.appendFile('input.txt', data, 'utf8',
  
    // Callback function
    function(err) { 
        if (err) throw err;
  
        //  If no error
        console.log("Data is appended to file successfully.")
});

Producción:

Data is appended to file successfully.

Ejemplo 1: para agregar sincrónicamente

var fs = require('fs');
   
var data = "\nLearn Node.js";
   
// Append data to file
fs.appendFileSync('input.txt', data, 'utf8');
console.log("Data is appended to file successfully.")

Producción:

Data is appended to file successfully.
  • Antes de agregar datos al archivo input.txt: 
    GeeksforGeeks: A computer science portal
  • Después de agregar datos al archivo input.txt: 
    GeeksforGeeks: A computer science portal
Learn Node.js

Cerrar el archivo: el método fs.close() se usa para cerrar de forma asincrónica el descriptor de archivo dado, borrando así el archivo asociado con él. Esto permitirá que el descriptor de archivo se reutilice para otros archivos. Llamar a fs.close() en un descriptor de archivo mientras se realiza alguna otra operación puede generar un comportamiento indefinido.

Sintaxis:

fs.close(fd, callback)

Parámetros:

  • fd: es un número entero que denota el descriptor de archivo del archivo para el cual se cerrará.
  • devolución de llamada: Es una función que sería llamada cuando se ejecuta el método.
    • err: es un error que se lanzaría si el método falla.

Ejemplo: Vamos a crear un archivo js llamado main.js que tenga el siguiente código:

// Close the opened file.
fs.close(fd, function(err) {
   if (err) {
      console.log(err);
   } 
   console.log("File closed successfully.");
}

Producción:

File closed successfully.

Eliminar un archivo: el método fs.unlink() se utiliza para eliminar un archivo o enlace simbólico del sistema de archivos. Esta función no funciona en directorios, por lo que se recomienda usar fs.rmdir() para eliminar un directorio.

Sintaxis:

fs.unlink(path, callback)

Parámetros:

  • ruta: Es una string, Buffer o URL que representa el archivo o enlace simbólico que se debe eliminar.
  • devolución de llamada: Es una función que sería llamada cuando se ejecuta el método.
    • err: es un error que se lanzaría si el método falla.

Ejemplo: Vamos a crear un archivo js llamado main.js que tenga el siguiente código:

var fs = require("fs");
  
console.log("deleting an existing file");
fs.unlink('input.txt', function(err) {
   if (err) {
      return console.error(err);
   }
   console.log("File deleted successfully!");
});

Producción:

deleting an existing file
File deleted successfully!

Publicación traducida automáticamente

Artículo escrito por kevadiyasmeet y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *