Secuencias de Node.js

Los flujos son uno de los conceptos fundamentales de Node.js. Los flujos son un tipo de métodos de manejo de datos y se utilizan para leer o escribir entradas en la salida de forma secuencial. Los flujos se utilizan para manejar la lectura/escritura de archivos o el intercambio de información de manera eficiente.

La documentación oficial de Node.js define flujos como «Un flujo es una interfaz abstracta para trabajar con datos de transmisión en Node.js». El módulo de transmisión proporciona una API para implementar la interfaz de transmisión. Los ejemplos del objeto de flujo en Node.js pueden ser una solicitud a un servidor HTTP y process.stdout son instancias de flujo. En resumen, los Streams son objetos en Node.js que permiten al usuario leer datos de una fuente o escribir datos en un destino de manera continua.

Acceso a flujos:

const stream = require('stream');

Nota: lo que hace que las secuencias sean potentes cuando se trata de grandes cantidades de datos es que, en lugar de leer un archivo en la memoria de una sola vez, las secuencias en realidad leen fragmentos de datos y procesan los datos de su contenido sin guardarlos en la memoria.

Ventajas de Streams sobre otros métodos de manejo de datos:

• Tiempo eficiente: no tenemos que esperar hasta que se haya transmitido todo el archivo. Podemos comenzar a procesar datos tan pronto como los tengamos.
• Memoria eficiente: no tenemos que cargar una gran cantidad de datos en la memoria antes de comenzar a procesar.

Tipos de flujos en Node.js: hay cuatro tipos de flujos en Node.js.

1. Escribible: podemos escribir datos en estos flujos. Ejemplo: fs.createWriteStream().
2. Legible: podemos leer datos de estos flujos. Ejemplo: fs.createReadStream().
3. Dúplex: flujos que son tanto de escritura como de lectura. Ejemplo: red.socket.
4. Transformar: flujos que pueden modificar o transformar los datos a medida que se escriben y leen. Ejemplo: zlib.createDeflate.

Algunas API de Node que usan flujos son:

• red.Socket()
• proceso.stdin()
• proceso.stdout()
• proceso.stderr()
• fs.createReadStream()
• fs.createWriteStream()
• red.conectar()
• http.solicitud()
• zlib.createGzip()
• zlib.createGunzip()
• zlib.createDeflate()
• zlib.createInflate()

Implementación de un flujo legible: leeremos los datos de inStream y los repetiremos en la salida estándar usando process.stdout.

// Sample JavaScript Code for creating
// a Readable Stream
// Accessing streams
const { Readable } = require('stream');
  
// Reading the data 
const inStream = new Readable({
    read() { }
});
  
// Pushing the data to the stream
inStream.push('GeeksForGeeks : ');
inStream.push(
    'A Computer Science portal for Geeks');
  
// Indicates that no more data is
// left in the stream
inStream.push(null);
  
// Echoing data to the standard output
inStream.pipe(process.stdout);

Producción:

GeeksForGeeks : A Computer Science portal for Geeks 

Implementación de un flujo de escritura: en el flujo de salida, simplemente consolamos y registramos el fragmento como una string. También llamamos a la función de devolución de llamada para indicar el éxito sin ningún error. Leeremos los datos de inStream y los repetiremos en la salida estándar usando process.stdout.

// Sample JavaScript Code for
// Writable Stream
// Accessing Streams
const { Writable } = require('stream');
  
// Whatever is passed in standard 
// input is out streamed here.
const outStream = new Writable({
  
    // The Write function takes three 
    // arguments
    // Chunk is for Buffer
    // Encoding is used in case we want
    // to configure the stream differently
    // In this sample code, Encoding is ignored 
    // callback is used to indicate 
    // successful execution
    write(chunk, encoding, callback) {
        console.log(chunk.toString());
        callback();
    }
  
});
  
// Echo the data to the standard output
process.stdin.pipe(outStream);

Producción:

Hello Geeks