Método Node.js async.queue()

El módulo asíncrono está diseñado para trabajar con JavaScript asíncrono en NodeJS. async.queue devuelve un objeto de cola que es capaz de procesar simultáneamente, es decir, procesar varios elementos a la vez.

¿Cómo usar async.queue?

• Paso 1: Cree un archivo package.json. Se crea un archivo package.json ejecutando el siguiente comando. 
   

npm init

• Paso 2: Instalación del módulo asíncrono. El módulo asíncrono se puede instalar con el siguiente comando. 
   

npm i async

• Paso 3: Importación del módulo asíncrono. El módulo asíncrono se puede importar con el siguiente comando. 
   

const async = require('async')

• Paso 4: Usar el módulo async.queue. Sintaxis de async.queue.
   

const queue = async.queue('function', 'concurrency value')

La función de parámetro se ejecuta en el elemento agregado a la cola. El valor de concurrencia le dice a la cola, la cantidad de elementos que se procesarán en un momento determinado.

Ejemplo: Eche un vistazo al siguiente ejemplo para una mejor comprensión.

// Defining The queue
const queue = async.queue((task, completed) => {
    // Here task is the current element being
    // processed and completed is the callback function
     
    console.log("Currently Busy Processing Task " + task);
     
    // Simulating a complex process.
    setTimeout(()=>{
        // Number of elements to be processed.
        const remaining = queue.length();
        completed(null, {task, remaining});
    }, 1000);
 
}, 1);
 
// The concurrency value is set to one,
// Which means that one element is being
// Processed at a particular time

Métodos y propiedades importantes en async.queue:

push(element, callback) : El método push se usa para agregar elementos al final de la cola. El siguiente código demuestra cómo funciona el método push.

// Takes in two parameters, the item being pushed and
// the callback function
// Here the item is the element being added
// and other is the callback function with error
// and data property(destructured)
 
queue.push(item, (error, {item, remaining}) => {
  if(error){
      console.log(`An error occurred while processing task ${task}`);
  } else {
      console.log(`Finished processing task ${task}
             . ${remaining} tasks remaining`);
  }
});

length(): El método de longitud devuelve el número de elementos actualmente presentes en la cola. El siguiente código demuestra cómo funciona el método de longitud.

console.log(queue.length());

propiedad iniciada: la propiedad iniciada devuelve un valor booleano, que indica si la cola ha comenzado a procesar los datos o no. El siguiente código demuestra cómo funciona la propiedad iniciada.

// Returns true if the queue has started processing the data else false
console.log(queue.started)

unshift(element, callback) : El método unshift es similar al método push, pero el elemento se agrega al principio de la cola, lo que indica que el elemento que se procesará es importante. El siguiente código demuestra cómo funciona el método unshift:

// Takes in two parameters, the item being pushed
// and the callback function
// Here the item is the element being added
// and other is the callback function with error
// and data property(destructured)
 
queue.unshift(item, (error, {item, remaining}) => {
  if(error){
   console.log(`An error occurred while processing task ${task}`);
  } else {
   console.log(`Finished processing task ${task}. ${remaining} tasks remaining`);
  }
});

Método de drenaje(): el método de drenaje ejecuta una función de devolución de llamada cuando la cola termina de ejecutar todas las tareas. El siguiente código demuestra cómo funciona el método de drenaje.

Nota: El método de drenaje solo funciona cuando la función descrita es una función de flecha.

// Executes when the queue is done processing all the items
queue.drain(() => {
    console.log('Successfully processed all items');
})

Método de pausa(): el método de pausa detiene la ejecución de elementos en la cola hasta que se llama a la función de reanudación. El siguiente código demuestra cómo funciona el método de pausa.

// Pauses the execution of the queue
queue.pause()

Método resume(): El método resume reanuda la ejecución de elementos en la cola. El siguiente código demuestra cómo funciona el método resume.

// Resumes the execution of the queue
queue.resume()

Método kill(): el método kill elimina todos los elementos de la cola, la función de devolución de llamada del método de drenaje y lo obliga a estar inactivo. El siguiente código demuestra cómo funciona el método de eliminación.

// Forces the queue into idle mode
// and removes the drain callback
queue.kill()

Método inactivo(): El método inactivo() devuelve un valor booleano, que indica si la cola está inactiva o procesando algo. El siguiente código demuestra cómo funciona el método inactivo.

// Returns whether the queue is idle or not
queue.idle()

Código completo: el siguiente código es una demostración completa de cómo se usa realmente async.queue.

// Importing the async module
const async = require('async');
 
// Creating a tasks array
const tasks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
// Defining the queue
const queue = async.queue((task, completed) => {
    console.log("Currently Busy Processing Task " + task);
     
    // Simulating a Complex task
    setTimeout(()=>{
        // The number of tasks to be processed
        const remaining = queue.length();
        completed(null, {task, remaining});
    }, 1000);
 
}, 1); // The concurrency value is 1
 
 
// The queue is idle as there are no elements
// for the queue to process
console.log(`Did the queue start ? ${queue.started}`)
 
// Adding the each task to the queue
tasks.forEach((task)=>{
 
    // Adding the 5th task to the head of the
    // queue as it is deemed important by us
 if(task == 5){
    queue.unshift(task, (error, {task, remaining})=>{
      if(error){
       console.log(`An error occurred while processing task ${task}`);
      }else {
       console.log(`Finished processing task ${task}. ${remaining} tasks remaining`);
      }
    })     
        // Adding the task to the tail in the order of their appearance
 } else {
      queue.push(task, (error, {task, remaining})=>{
       if(error){
        console.log(`An error occurred while processing task ${task}`);
       }else {
        console.log(`Finished processing task ${task}. ${remaining} tasks remaining`);
      }
      })
    }
});
 
 
// Executes the callback when the queue is done processing all the tasks
queue.drain(() => {
    console.log('Successfully processed all items');
})
 
// The queue is not idle it is processing the tasks asynchronously
console.log(`Did the queue start ? ${queue.started}`)

Producción: