¿Qué es el módulo del sistema de archivos en Node.js?

Nodejs es un tiempo de ejecución de javascript de código abierto para ejecutar javascript fuera del navegador. Es una opción popular para el desarrollo de back-end. Como cualquier otro lenguaje de programación, Nodejs también nos proporciona las bibliotecas integradas para interactuar con el sistema o la máquina. En Nodejs llamamos a estas bibliotecas módulos. 

Los módulos se dividen básicamente en 3 categorías:

1. Módulos de núcleo de Node
2. Módulos locales
3. Módulos de terceros (como módulos npm).

Módulo del sistema de archivos: el sistema de archivos es un módulo central de un Node para interactuar con archivos y carpetas. Proporciona varios eventos y métodos para acceder y manipular archivos y carpetas en nuestra máquina.

Algunas de las operaciones que proporciona para manipular archivos son:

• Crear y eliminar archivos o carpetas.
• Acceder y renombrar archivos o carpetas.
• Leer, escribir y adjuntar archivos.
• Cambio de permiso y propietario de archivo o carpeta.

Para usar el módulo Sistema de archivos en su programa, necesita el módulo central del Node fs:

Sintaxis:

const fs = require('fs')

Ahora, antes de usar el módulo fs, debe comprender que existen dos enfoques para usar los métodos del módulo fs: –

1. Uso de métodos sincrónicos
2. Uso de métodos asincrónicos

Ahora surge la pregunta de si debemos elegir métodos sincrónicos o métodos asincrónicos. Analicemos cuál es la diferencia entre los métodos sincrónicos y los métodos asincrónicos del módulo fs.

Métodos síncronos y asíncronos:

Los métodos síncronos usan funciones que son de naturaleza bloqueante . El bloqueo de funciones bloquea la ejecución de la siguiente instrucción o fragmento de código hasta que no se completa la operación actual. Los métodos síncronos esperan a que finalice la operación actual y luego continúa con la ejecución de la siguiente instrucción. Pero esto crea problemas cuando la operación actual lleva mucho tiempo.

Ejemplo: supongamos que nuestro servidor después de recibir una solicitud necesita crear un archivo y luego escribir un texto en él y luego responder al cliente. Si para crear y escribir en un archivo usamos un enfoque síncrono, para cada solicitud entrante bloquearíamos la ejecución hasta que terminemos con las operaciones y respondamos a ese cliente. Si se juntan muchas requests, básicamente estamos bloqueando a otros usuarios hasta que terminemos con el primer usuario. El último usuario tendría que esperar mucho para obtener esta respuesta y eso sería malo.

Los métodos asincrónicos son de naturaleza no bloqueante, ya que nunca esperan a que se complete la operación actual. Al llamar a un método asíncrono, tenemos que pasar una función de devolución de llamada como argumento. Cuando se llama a una función asíncrona, el bucle de eventos la registra o la envía a una cola y se ejecuta la siguiente línea de código. En segundo plano, nuestra función asíncrona se ejecuta y, cuando se completa, la función de devolución de llamada que pasamos como argumento se inserta en la cola de devolución de llamada y se ejecuta cuando llega su turno.

 Basically, the catch here is to understand that asynchronous methods do the operation in the background and do not block the 
 execution of code.

Ejecución de código síncrono y asíncrono

El sistema de archivos nos proporciona una versión sincrónica y asincrónica de los métodos.

NOTA   :   siempre debemos usar la versión asíncrona de los métodos en nuestro código si tenemos una opción. Los métodos sincrónicos solo deben usarse en el código de nivel superior porque el código de nivel superior se ejecuta solo una vez o solo en situaciones en las que estamos seguros de que la operación no llevará mucho tiempo (operación ligera).

Operaciones en archivo:

• Leer un archivo:   la forma más sencilla de leer un archivo es usar el método fs.readFile() . Este método se encarga de abrir y cerrar el archivo y carga el contenido del archivo en la memoria para que lo usemos en nuestro programa.

Sintaxis:

fs.readFile(path,options,callback);

Parámetros:

• ruta: el nombre o la ruta del archivo que queremos leer
• options – este es un argumento opcional y generalmente pasamos la codificación que es ‘ utf-8 ‘
• devolución de llamada: se ejecuta cuando hemos leído el archivo. Toma dos parámetros
  • error – si ocurre algún error
  • datos – contenido del archivo

Ejemplo:   cree un nombre de archivo app.js y también cree un archivo de texto input.txt

Estructura del proyecto –

const fs = require("fs");
// Asynchronous version of readFile method
fs.readFile("input.txt", "utf-8", (error, data) => {
  
  // If the file doesnt exist then there 
  // is error then if condition will run
  if (error) {
    console.log("File not found");
  } else {
  
    // Data contains the content that we 
    // have read from file in case of 
    // error , data will output undefined
    console.log(data);
  }
});

Ejecute app.js usando el siguiente comando:

node app.js

Producción: 

Hurrah, now you know how to read a file.

Ejemplo 2: Usaremos la versión síncrona, que es fs.readFileSync() . Todos los demás métodos discutidos a continuación también tienen una versión síncrona. Para usar eso, simplemente agregue Sync al final del nombre de la función y elimine el parámetro de devolución de llamada.

const fs = require("fs");
  
try {
  // If file not found then throws error
  //Reading file in asynchronous way
  const data = fs.readFileSync("input.txt", "utf-8");
  console.log(data);
} catch (error) {
  console.log(error);
}

Producción : 

Hurrah, now you know how to read a file synchronously.

• Escribir en un archivo : podemos escribir en nuestro archivo usando la función fs.writeFile() . Esta función escribe datos en el archivo reemplazando el contenido existente del archivo. Además, si no existe dicho archivo, crea el archivo y escribe datos en él.

Sintaxis:

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

Parámetros:

• ruta : el nombre o la ruta del archivo en el que se va a escribir.
• datos : contenido para escribir en el archivo
• opciones : opcional, pero generalmente especificamos la codificación: ‘ utf-8 ‘.
• devolución de llamada : se ejecuta después de haber escrito en el archivo.
  • error: si se produce algún error,

Ejemplo : cree un archivo de texto vacío: output.txt y también el archivo app.js :

Estructura del proyecto :

const fs = require("fs");
  
const str = "Learning how to write to a file.";
  
fs.writeFile("output.txt", str, "utf-8", (error) => {
  
  // If there is error then this will execute
  if (error) {
    console.log(error);
  }
  else {
    console.log("Successfully written!!");
  }
    
  // Reading what we have written in file
  fs.readFile("output.txt", "utf-8", (error, data) => {
    if (error) {
      console.log(error);
    } 
    else {
      console.log(data);
    }
  });
});

Ejecute el archivo app.js con el comando –

node app.js

Salida: Se creará un nuevo archivo con el nombre salida.txt y se escribirán datos en él. Pero el archivo ya existía, entonces todo su contenido será eliminado y reemplazado por los datos que escribimos.

Successfully written!!
Learning how to write to a file.

• Agregar en un archivo: podemos agregar datos a nuestro archivo usando fs.appendFile() . A diferencia de fs.writeFile() , no reemplaza el contenido del archivo, sino que le agrega los datos. Si no se encuentra el archivo, lo crea y le agrega los datos.

Sintaxis:

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

Parámetros –

• ruta : el nombre o la ruta del archivo.
• datos : contenido que se agregará en el archivo.
• opciones : generalmente especificamos la codificación: ‘ utf-8 ‘
• devolución de llamada : se ejecuta después de haber agregado el archivo
  • error – si hay un error

Ejemplo: cree un archivo app.js y también un archivo output.txt vacío:

Estructura del proyecto:

salida.txt: Inicialmente contiene – 

Learning how to write to a file. (Previous content)

aplicación.js

const fs = require("fs");
  
const data = "\nLearning how to append to a file. (New content)";
fs.appendFile("output.txt", data, "utf-8", (error) => {
  if (error) {
    console.log(error);
  } 
  else {
    console.log("Successfully written!!");
  }
  
  fs.readFile("output.txt", "utf-8", (error, data) => {
    if (error) {
      console.log(error);
    }
    else {
      console.log(data);
    }
  });
});

Ejecute app.js  con el comando –

node app.js

Salida: los datos que proporcionamos se agregarán en output.txt y obtendremos el siguiente resultado:

Successfully written!!
Learning how to write to a file. (Previous content)
Learning how to append to a file. (New content)

Hay muchos otros métodos del módulo fs que se utilizan para realizar varios tipos de operaciones en archivos: fs.rename() , fs.unlink() , fs.open(), fs.close() , etc.

Vamos a crear un proyecto de juez fuera de línea usando el módulo del sistema de archivos:

Una demostración de un juez fuera de línea: suponga que tiene un archivo JSON test-cases.json que contiene todos los casos de prueba de entrada para un problema y su salida. 

Estructura del proyecto – 

casos-de-prueba.json  

{
  "problem": 121,
  "input": [
    [5, 3, 4, 2, 1],
    [8, 100, 47, 999, 504, 771, 21, 53, 45, 660, 9],
    [0, 0, 7, 1, 4, 7, 3, 5],
    [1],
    []
  ],
  "output": [3, 673, 19, 1, 10]
}

Declaración del problema: Encuentra la diferencia entre la suma par e impar

// Complete this function to find the 
// absolute difference of sum of even 
// and odd terms in arr
function diffOfOddEvenSum(arr) {
  
  // Write your code here
}

Ahora, para crear un juez sin conexión, debe crear un archivo app.js y escribir el código:

const fs = require("fs");
const funct = require("./index");
function diffOfOddEvenSum(arr) {
  let odd = 0;
  let even = 0;
  
  arr.forEach((element) => {
    
    if (element % 2 == 1) {
      odd += element;
    } else even += element;
  });
  
  return odd - even;
}
  
// OFFLINE-JUDGE
// Since this is top level code we can
// use Synchronous version
// reading the data from json file
const jsonData = fs.readFileSync("test.json", "utf-8");
  
// The data we read from file is in json
// parsing the json to get the data
const testCases = JSON.parse(jsonData);
  
// Inputs is an array of input cases
const inputs = testCases.input;
  
// Exptected Output contains the correct
// output of the given problem number
const expectedOutput = testCases.output;
  
// To store the result of our input test cases
let result = "";
  
// Calling the diffOdOddEvenSum() function
// to get the output
inputs.forEach((input, index) => {
  const output = diffOfOddEvenSum(input);
  //  console.log(output)
  
  // Checking if the output is correct
  if (output == expectedOutput[index]) {
    result += `Test Case ${index + 1}- passed \n`;
  } else {
    result += `Test Case ${index + 1}- failed \n`;
  }
});
  
// We can use Synchronous version as it
// is top-level code
// writing the output to the file
fs.writeFileSync("result.txt", result, "utf-8");

Ejecute app.js usando el comando –

node app.js

Salida : en nuestro archivo result.txt , tenemos

Test Case 1- passed 
Test Case 2- passed
Test Case 3- passed 
Test Case 4- passed 
Test Case 5- failed

De esta manera, podemos simplemente crear una herramienta de evaluación fuera de línea utilizando el módulo central del sistema de archivos.