Flujos de Node.js: FileStream, Pipes y Eventos

Tipos de flujos en Node.js

Cada flujo que expone Node.js se clasifica en uno de cuatro tipos básicos, y conocer el tipo que devuelve una API determinada explica cómo se comporta dicho flujo antes de escribir cualquier código. El módulo de flujo que viene con Node.js define estas categorías, y las API de archivos, redes y compresión que se utilizan en este artículo se basan en ellas.

Un flujo legible y un flujo escribible son los dos bloques de construcción utilizados a lo largo de este artículo; ambos también impulsan un servidor web HTTP En Node.js, un flujo dúplex combina ambos roles en un solo objeto, mientras que un flujo de transformación es un flujo dúplex cuya salida modifica su entrada, como la compresión gzip aplicada a mitad del flujo.

Flujo de archivos en Node.js

Una vez definidas las cuatro categorías de flujo, el resto de este artículo describe cómo se realiza una transferencia de archivos utilizando las API de flujo legible y escribible.

Node hace un uso extensivo de transmisiones como mecanismo de transferencia de datos.

Por ejemplo, cuando envía algo a la consola usando la función console.log, en realidad está usando una secuencia para enviar los datos a la consola.

Node.js también tiene la capacidad de transmitir datos desde archivos para que puedan leerse y escribirse adecuadamente. Ahora veremos un ejemplo de cómo podemos usar transmisiones para leer y escribir desde archivos. Necesitamos seguir los pasos que se mencionan a continuación para este ejemplo.

Paso 1) Cree un archivo llamado data.txt que tenga los siguientes datos. Supongamos que este archivo está almacenado en la unidad D de nuestra máquina local.

Tutorial sobre Node.js

Introducción

Eventos

Generators

Conectividad de datos

Usando jazmín

Paso 2) Escriba el código relevante que utilizará secuencias para leer datos del archivo.

var fs = require("fs");
var stream;
stream = fs.createReadStream("D://data.txt");

stream.on("data", function(data) {
    var chunk = data.toString();
    console.log(chunk);
}); 

Code Explicación:-

1. Primero debemos incluir los módulos 'fs' que contienen toda la funcionalidad necesaria para crear transmisiones.
2. A continuación, creamos una secuencia legible utilizando el método – createReadStream. Como entrada, damos la ubicación de nuestro archivo data.txt.
3. La función steam.on es un controlador de eventos y en él, especificamos el primer parámetro como "datos". Esto significa que cada vez que ingresan datos en la secuencia del archivo, se ejecuta una función de devolución de llamada. En nuestro caso, estamos definiendo una función de devolución de llamada que realizará 2 pasos básicos. La primera es convertir los datos leídos del archivo como una cadena. El segundo sería enviar la cadena convertida como salida a la consola.
4. Tomamos cada fragmento de datos que se lee del flujo de datos y lo convertimos en una cadena.
5. Finalmente, enviamos la salida de cada fragmento de cadena convertido a la consola.

Salida:

• Si el código se ejecuta correctamente, verá el resultado anterior en la consola. Esta salida será la misma que la del archivo data.txt.

Escribir en un archivo

De la misma manera que creamos una secuencia de lectura, también podemos crear una secuencia de escritura para escribir datos en un archivo. Primero creemos un archivo vacío sin contenido llamado data.txt. Supongamos que este archivo está ubicado en la unidad D de nuestra computadora.

El siguiente código muestra cómo podemos escribir datos en el archivo.

var fs = require("fs");
var stream;
stream = fs.createWriteStream("D://data.txt");

stream.write("Tutorial on Node.js")
stream.write("Introduction")
stream.write("Events")
stream.write("Generators")
stream.write("Data Connectivity")
stream.write("Using Jasmine") 

Code Explicación:-

1. Estamos creando una secuencia de escritura utilizando el método – createWriteStream. Como entrada, damos la ubicación de nuestro archivo data.txt.
2. A continuación usamos stream.write un método para escribir las diferentes líneas de texto en nuestro archivo de texto. La transmisión se encargará de escribir estos datos en el archivo data.txt.

Si abre el archivo data.txt, ahora verá los siguientes datos en el archivo

Tutorial sobre Node.js

Introducción

Eventos

Generators

Conectividad de datos

El uso de Jazmín

Tuberías en Node.js

Leer y escribir flujos de forma independiente es útil, pero Node.js también permite que un flujo de lectura se conecte directamente a un flujo de escritura, transfiriendo datos sin necesidad de código de almacenamiento en búfer manual.

Dentro de las aplicaciones de Node, las transmisiones se pueden canalizar entre sí utilizando el método pipe(), que toma dos argumentos:

• Una secuencia de escritura requerida que actúa como destino de los datos y
• Un objeto opcional utilizado para pasar opciones.

Un ejemplo típico de uso de canalizaciones, si desea transferir datos de un archivo a otro.

Entonces, veamos un ejemplo de cómo podemos transferir datos de un archivo a otro usando tuberías.

Paso 1) Cree un archivo llamado datainput.txt que tenga los siguientes datos. Supongamos que este archivo está almacenado en la unidad D de nuestra máquina local.

Tutorial sobre Node.js

Introducción

Eventos

Generators

Conectividad de datos

Usando jazmín

Paso 2) Cree un archivo vacío en blanco llamado dataOutput.txt y colóquelo en la unidad D de su máquina local.

Paso 3) Escriba el siguiente código para llevar a cabo la transferencia de datos desde el archivo datainput.txt al archivo dataOutput.txt.

var fs = require("fs");
var readStream = fs.createReadStream("D://datainput.txt");
var writeStream = fs.createWriteStream("D://dataOutput.txt");
readStream.pipe(writeStream);

Code Explicación:-

1. Primero estamos creando una "secuencia de lectura" para nuestro archivo datainput.txt que contiene todos nuestros datos que deben transferirse al nuevo archivo.
2. Luego necesitamos crear un "flujo de escritura" en nuestro archivo dataOutput.txt, que es nuestro archivo vacío y es el destino para la transferencia de datos desde el archivo datainput.txt.
3. Luego usamos el comando pipe para transferir los datos del flujo de lectura al flujo de escritura. El comando pipe tomará todos los datos que ingresan al flujo de lectura y los enviará al flujo de escritura.

Si ahora abre el archivo dataOutput.txt, verá todos los datos que estaban presentes en el archivo datainput.txt.

Eventos de transmisión y contrapresión en Node.js

Llamar a pipe(), como se muestra arriba, oculta dos mecanismos importantes a gran escala: los eventos que emite cada flujo y el sistema de contrapresión que impide que una fuente rápida sature un destino lento.

• datos: emitido por un flujo legible cada vez que hay un nuevo fragmento disponible.
• fin: Se emite una vez que una secuencia legible ha entregado su último fragmento.
• terminar: emitido por un flujo escribible una vez que se han vaciado todos los datos en cola.
• error: Emitido por cualquiera de los tipos de flujo en caso de fallo; siempre manéjelo o el proceso fallará.

El ejemplo que se muestra a continuación escucha los cuatro eventos mientras gestiona manualmente la contrapresión, el mismo comportamiento que pipe() proporciona automáticamente.

var fs = require("fs");
var readStream = fs.createReadStream("D://data.txt");
var writeStream = fs.createWriteStream("D://dataOutput.txt");

readStream.on("data", function(chunk) {
    var ok = writeStream.write(chunk);
    if (!ok) {
        readStream.pause();
    }
});

writeStream.on("drain", function() {
    readStream.resume();
});

readStream.on("end", function() {
    writeStream.end();
});

writeStream.on("finish", function() {
    console.log("Write completed.");
});

readStream.on("error", function(err) {
    console.log(err);
});

La contrapresión se produce cuando un flujo de lectura genera datos más rápido de lo que un flujo de escritura puede consumirlos. El método `write()` devuelve `false` una vez que su búfer se llena, por lo que el código anterior pausa el origen hasta que el destino emite un evento de drenaje, lo que indica que es seguro reanudarlo. El método `pipe()` realiza este ciclo automáticamente.

⚠ Consejo: En producción, es preferible usar la función pipeline() del módulo stream en lugar de una cadena pipe() manual, ya que reenvía los errores de cada flujo y cierra automáticamente los descriptores de archivo.

Eventos en Node.js

Los flujos son un ejemplo del diseño orientado a eventos de Node.js. El resto de este artículo analiza cómo funcionan los eventos en general, utilizando la misma clase EventEmitter en la que se basan internamente los flujos.

Los eventos son uno de los conceptos clave en Node.js y, a veces, se hace referencia a Node.js como un marco basado en eventos.

Básicamente, un evento es algo que sucede. Por ejemplo, si se establece una conexión con una base de datos, se activa el evento de conexión de la base de datos. La programación impulsada por eventos consiste en crear funciones que se activarán cuando se activen eventos específicos.

Veamos un ejemplo básico de definición de un evento en Node.js.

Vamos a crear un evento llamado "datos_recibidos". Cuando se activa este evento, el texto "datos recibidos" se enviará a la consola.

var events = require('events');
var eventEmitter = new events.EventEmitter();
eventEmitter.on('data_received', function() {
    console.log('data received succesfully.');
});

eventEmitter.emit('data_received'); 

Code Explicación:-

1. Utilice la función require para incluir el módulo 'eventos'. Con este módulo, podrás crear eventos en Node.js.
2. Crea un nuevo emisor de eventos. Esto se utiliza para vincular el evento, que en nuestro caso es "datos_recibidos" a una función de devolución de llamada que se define en el paso 3.
3. Definimos una función controlada por eventos que dice que si en caso de que se active el evento "data_received", debemos enviar el texto "data_received" a la consola.
4. Finalmente, tenemos un disparador manual de nuestro evento usando la función eventEmiter.emit. Esto activará el evento data_received.

Cuando se ejecuta el programa, el texto "datos recibidos" se enviará a la consola como se muestra a continuación.

Eventos de emisión

Además de emitir y escuchar eventos, Node.js ofrece métodos adicionales para controlar cómo se registran e inspeccionan los oyentes.

Al definir eventos, existen diferentes métodos para los eventos que se pueden invocar. Este tema se centra en mirar cada uno de ellos en detalle.

1. Controladores de eventos únicos

A veces puede que le interese reaccionar ante un evento sólo la primera vez que ocurre. En estas situaciones, puede utilizar el método once().

Veamos cómo podemos utilizar el método once para controladores de eventos.

Code Explicación:-

1. Aquí estamos usando el método "once" para decir que para el evento "data_received", la función de devolución de llamada solo debe ejecutarse una vez.
2. Aquí estamos activando manualmente el evento "datos_recibidos".
3. Cuando el evento 'data_received' se active nuevamente, esta vez no sucederá nada. Esto se debe al primer paso en el que dijimos que el evento solo podía activarse una vez.

Si el código se ejecuta correctamente, el resultado en el registro será "datos_recibidos correctamente". Este mensaje solo aparecerá una vez en la consola.

2. Inspeccionar oyentes de eventos

En cualquier momento de su vida, un emisor de eventos puede tener cero o más oyentes asociados. Los oyentes de cada tipo de evento se pueden inspeccionar de varias maneras.

Si solo está interesado en determinar el número de oyentes conectados, no busque más que el método EventEmitter.listenerCount().

(Nota: Los oyentes son importantes porque el programa principal debe saber si se están agregando oyentes sobre la marcha a un evento; de lo contrario, el programa funcionará mal porque se llamará a oyentes adicionales).

Code Explicación:-

1. Estamos definiendo un tipo eventEmitter que es necesario para utilizar los métodos relacionados con eventos.
2. Luego estamos definiendo un objeto llamado emisor que se utilizará para definir nuestros controladores de eventos.
3. Estamos creando 2 controladores de eventos que básicamente no hacen nada. En nuestro ejemplo, esto se mantiene simple para mostrar cómo funciona el método listenerCount.
4. Ahora, cuando invoque el método listenerCount en nuestro evento data_received, enviará la cantidad de detectores de eventos adjuntos a este evento en el registro de la consola.

Si el código se ejecuta correctamente, el valor de 2 se mostrará en el registro de la consola.

3. El nuevo evento Listener

Cada vez que se registra un nuevo controlador de eventos, el emisor de eventos emite un evento newListener. Este evento se utiliza para detectar nuevos controladores de eventos. Normalmente utiliza el evento newListener cuando necesita asignar recursos o realizar alguna acción para cada nuevo controlador de eventos.

var events = require('events');
var eventEmitter = events.EventEmitter;
var emitter = new eventEmitter();
emitter.on("newListener", function(eventName, listener) {
    console.log("Added listener for " + eventName + " events");
});
emitter.on('data_received', function() {});
emitter.on('data_received', function() {}); 

Code Explicación:-

1. Estamos creando un nuevo controlador de eventos para el evento "newListener". Entonces, cada vez que se registra un nuevo controlador de eventos, el texto "Oyente agregado para" + el nombre del evento se mostrará en la consola.
2. Aquí escribimos en la consola el texto “Oyente agregado para” + el nombre del evento para cada evento registrado.
3. Estamos definiendo 2 controladores de eventos para nuestro evento 'data_received'.

Si el código anterior se ejecuta correctamente, el siguiente texto se mostrará en la consola. Simplemente muestra que el controlador de eventos 'newListener' se activó dos veces.

Se agregó un oyente para eventos data_received

Se agregó un oyente para eventos data_received

Preguntas Frecuentes