Guía completa de transmisiones en Node.js

Los flujos en Node.js son una forma poderosa de manejar la lectura y escritura de datos de manera continua. Le permiten procesar datos de manera eficiente, especialmente cuando se trata de grandes cantidades de información u operaciones de E/S. Esta guía cubrirá los tipos de transmisiones, cómo usarlas y ejemplos prácticos para ayudarlo a comprender cómo funcionan las transmisiones en Node.js.

¿Qué son las corrientes?

Los flujos son objetos que le permiten leer datos de un origen o escribir datos en un destino de manera continua. Son ideales para procesar datos pieza por pieza en lugar de leer o escribir archivos o buffers completos a la vez. Esto es especialmente útil cuando se trabaja con grandes conjuntos de datos, ya que puede reducir significativamente el uso de memoria.

Conceptos clave

• Modo de flujo: los datos fluyen automáticamente desde el origen al destino.
• Modo pausado: los datos deben leerse manualmente desde la fuente.
• Transmisiones legibles: transmisiones desde las que puedes leer datos.
• Transmisiones grabables: transmisiones en las que puedes escribir datos.
• Transmisiones dúplex: transmisiones que pueden leer y escribir datos.
• Transformar flujos: flujos que modifican o transforman los datos a medida que se leen o escriben.

Tipos de corrientes

1. Transmisiones legibles: Estas transmisiones le permiten leer datos. Los ejemplos incluyen fs.createReadStream() y http.IncomingMessage.

2. Secuencias grabables: Estas secuencias le permiten escribir datos. Los ejemplos incluyen fs.createWriteStream() y http.ServerResponse.

3. Transmisiones dúplex: estas transmisiones pueden leer y escribir datos. Los ejemplos incluyen sockets TCP y net.Duplex.

4. Transform Streams: son un tipo de flujo dúplex que puede modificar los datos a medida que se leen o escriben. Los ejemplos incluyen zlib.createGzip() para compresión.

Crear transmisiones legibles

Puedes crear una transmisión legible usando el módulo fs incorporado para leer archivos o usando stream.Readable para crear transmisiones legibles personalizadas.

Ejemplo: leer un archivo con una secuencia legible

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('example.txt', { encoding: 'utf8' });

// Handling the 'data' event
readableStream.on('data', (chunk) => {
    console.log('New chunk received:', chunk);
});

// Handling the 'end' event
readableStream.on('end', () => {
    console.log('No more data to read.');
});

Ejemplo: secuencia legible personalizada

const { Readable } = require('stream');

class MyReadableStream extends Readable {
    constructor(options) {
        super(options);
        this.current = 0;
    }

    _read(size) {
        if (this.current  {
    console.log('Received:', chunk.toString());
});

Crear secuencias grabables

Puedes crear transmisiones grabables usando el módulo fs o extendiendo la clase stream.Writable.

Ejemplo: escribir en un archivo con una secuencia grabable

const fs = require('fs');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Write data to the stream
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');

// End the stream
writableStream.end(() => {
    console.log('Finished writing to file.');
});

Ejemplo: secuencia de escritura personalizada

const { Writable } = require('stream');

class MyWritableStream extends Writable {
    _write(chunk, encoding, callback) {
        console.log('Writing:', chunk.toString());
        callback(); // Call when done
    }
}

const myWritableStream = new MyWritableStream();
myWritableStream.write('Hello, World!\n');
myWritableStream.write('Writing to custom writable stream.\n');
myWritableStream.end();

Uso de transmisiones dúplex

Las transmisiones dúplex pueden leer y escribir datos simultáneamente. Un caso de uso común son los sockets TCP.

Ejemplo: creación de una secuencia dúplex

const { Duplex } = require('stream');

class MyDuplexStream extends Duplex {
    _read(size) {
        this.push('Data from duplex stream\n');
        this.push(null); // No more data
    }

    _write(chunk, encoding, callback) {
        console.log('Received:', chunk.toString());
        callback();
    }
}

const myDuplexStream = new MyDuplexStream();
myDuplexStream.on('data', (chunk) => {
    console.log('Reading:', chunk.toString());
});

// Write to the duplex stream
myDuplexStream.write('Hello, Duplex!\n');
myDuplexStream.end();

Usando transmisiones de transformación

Las secuencias de transformación son útiles para modificar los datos a medida que fluyen a través de la secuencia. Por ejemplo, podrías usar una secuencia de transformación para comprimir datos.

Ejemplo: crear una secuencia de transformación

const { Transform } = require('stream');

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();
myTransformStream.on('data', (chunk) => {
    console.log('Transformed:', chunk.toString());
});

// Pipe data through the transform stream
process.stdin.pipe(myTransformStream).pipe(process.stdout);

Corrientes de tuberías

Una de las poderosas características de las transmisiones es la capacidad de canalizarlas juntas. La tubería le permite conectar una secuencia legible a una secuencia grabable, lo que facilita la transferencia de datos.

Ejemplo: corrientes de tuberías

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('input.txt');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Pipe the readable stream to the writable stream
readableStream.pipe(writableStream);

writableStream.on('finish', () => {
    console.log('Data has been written to output.txt');
});

Transmitir eventos en Node.js

1. Eventos de transmisiones legibles

Las transmisiones legibles emiten varios eventos importantes que te ayudan a administrar el flujo de datos:

• datos: Se emite cuando una porción de datos está disponible para ser leída.
• end: Se emite cuando no hay más datos para leer.
• error: Emitido cuando ocurre un error durante la lectura.
• cerrar: se emite cuando la transmisión y cualquier recurso subyacente (como descriptores de archivos) se han cerrado.

Ejemplo: eventos de transmisión legibles

const fs = require('fs');

const readableStream = fs.createReadStream('example.txt');

readableStream.on('data', (chunk) => {
    console.log('Received chunk:', chunk.toString());
});

readableStream.on('end', () => {
    console.log('No more data to read.');
});

readableStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

readableStream.on('close', () => {
    console.log('Stream closed.');
});

2. Eventos de transmisiones grabables

Las secuencias de escritura también emiten varios eventos:

• drenaje: Se emite cuando la transmisión está lista para aceptar más datos después de estar llena.
• finish: Se emite cuando todos los datos se han escrito en la secuencia y se ha llamado al método end().
• error: Emitido cuando ocurre un error durante la escritura.
• cerrar: se emite cuando se han cerrado la transmisión y cualquier recurso subyacente.

Ejemplo: eventos de transmisión grabables

const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt');

writableStream.on('finish', () => {
    console.log('All data has been written to output.txt');
});

writableStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

// Writing data
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');
writableStream.end(); // Call end to finish the writing process

3. Transformar eventos de transmisiones

Las secuencias de transformación heredan eventos de secuencias legibles y escribibles, y emiten:

• datos: Se emite cuando un fragmento transformado está disponible para lectura.
• end: Se emite cuando no hay más datos para transformar.
• error: Emitido cuando ocurre un error durante la transformación.
• finish: Emitido cuando todos los datos han sido procesados ​​y escritos.

Ejemplo: transformar eventos de transmisión

const { Transform } = require('stream');

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();

myTransformStream.on('data', (chunk) => {
    console.log('Transformed chunk:', chunk.toString());
});

myTransformStream.on('end', () => {
    console.log('No more data to transform.');
});

myTransformStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

// Write data to the transform stream
myTransformStream.write('Hello, World!\n');
myTransformStream.write('Transforming this text.\n');
myTransformStream.end(); // End the stream

Resumen de eventos

• Transmisiones legibles: datos, finalización, error, cierre
• Secuencias grabables: drenaje, finalización, error, cierre
• Transformar secuencias: hereda datos, finalización, error y finalización de secuencias legibles y escribibles

Conclusión

Los flujos en Node.js proporcionan una forma poderosa y eficiente de manejar datos de manera continua. Le permiten leer y escribir datos pieza por pieza, lo que los hace particularmente útiles para operaciones de E/S y trabajar con grandes conjuntos de datos. Comprender cómo crear y utilizar diferentes tipos de transmisiones, así como también cómo manejar eventos, lo ayudará a crear aplicaciones más eficientes y escalables en Node.js.

Ya sea que esté creando transmisiones legibles, escribibles, dúplex o transformadas, la flexibilidad de la API de transmisión le permite manejar el procesamiento de datos de la manera que mejor se adapte a las necesidades de su aplicación.