Compréhension approfondie des flux dans Node.js

Les flux dans Node.js sont notoirement difficiles à utiliser ou même à comprendre. [Recommandation du didacticiel vidéo : tutoriel vidéo nodejs ]

Selon les mots de Dominic Tarr : "Le streaming est l'idée la meilleure et la plus mal comprise dans Node." Le membre Dan Abramov a également peur des flux Node.

Cet article vous aidera à comprendre les flux et comment les utiliser. N'ayez pas peur, vous pouvez tout à fait le comprendre !

Qu'est-ce qu'un flux ?

Les flux sont l'un des concepts fondamentaux qui alimentent les applications Node.js. Ce sont des méthodes de traitement de données qui lisent séquentiellement les données d'entrée ou écrivent des données en sortie.

Le streaming est un moyen de gérer efficacement la lecture et l'écriture de fichiers, les communications réseau ou tout type d'échange d'informations de bout en bout.

La méthode de traitement du flux est tout à fait unique. Au lieu de lire le fichier d'un seul coup dans la mémoire comme la manière traditionnelle, le flux lit le bloc de données morceau par morceau et traite le contenu. des données. Gardez tout cela en mémoire.

Cette approche rend les flux très puissants lors du traitement de grandes quantités de données, par exemple, la taille du fichier peut être supérieure à l'espace mémoire disponible, ce qui rend impossible la lecture de l'intégralité du fichier en mémoire pour traitement. C'est là qu'intervient le flux !

Vous pouvez utiliser des flux pour traiter des blocs de données plus petits et lire des fichiers plus volumineux.

Prenons par exemple les services de « streaming » comme YouTube ou Netflix : ces services ne vous permettent pas de télécharger instantanément des fichiers vidéo et audio. Au lieu de cela, votre navigateur reçoit la vidéo sous la forme d'un flux continu de morceaux, permettant au destinataire de commencer à regarder et à écouter presque immédiatement.

Cependant, le streaming ne se limite pas au traitement des médias et du big data. Ils nous donnent également le pouvoir de « composabilité » dans notre code. Concevoir en gardant à l'esprit la composabilité signifie être capable de combiner plusieurs composants d'une manière ou d'une autre pour produire le même type de résultat. Dans Node.js, vous pouvez transmettre des données dans d'autres extraits plus petits via des flux pour former des extraits puissants.

Pourquoi utiliser les flux ?

Le streaming présente essentiellement deux avantages principaux par rapport aux autres méthodes de traitement de données :

1. Efficacité de la mémoire : Vous n'avez pas besoin de charger un grande quantité de données en mémoire pour le traitement
2. Efficacité du temps : Le temps requis pour démarrer immédiatement après l'obtention des données est considérablement réduit, et il n'est pas nécessaire d'attendre que toutes les données valides soient envoyé avant de commencer le traitement

Il existe 4 types de flux dans Node.js :

1. Inscriptible. stream : Oui Le flux dans lequel les données sont écrites. Par exemple, fs.createWriteStream() nous permet d'utiliser un flux pour écrire des données dans un fichier.
2. Flux lisible : Un flux à partir duquel les données peuvent être lues. Par exemple : fs.createReadStream() Lisons le contenu d’un fichier.
3. Flux duplex (flux lisible et inscriptible) : Flux lisible et inscriptible. Par exemple, net.Socket
4. Transformer : modifie ou transforme les données lors de l'écriture et de la lecture. Par exemple, dans le cas d'une compression de fichier, vous pouvez écrire des données compressées dans le fichier et lire des données décompressées à partir du fichier.

Si vous avez utilisé Node.js, vous avez peut-être rencontré des flux. Par exemple, dans un serveur HTTP basé sur Node.js, request est un flux lisible et response est un flux inscriptible. Vous avez peut-être utilisé le module fs, qui vous permet d'utiliser des flux de fichiers lisibles et inscriptibles. Chaque fois que vous utilisez Express, vous utilisez des flux pour interagir avec le client, et comme les sockets TCP, les piles TLS et d'autres connexions sont toutes basées sur Node.js, utilisez des flux dans chaque programme basé sur une connexion de base de données que vous pouvez utiliser.

Exemple

Comment créer un flux lisible ?

Nécessite d'abord un flux de lisibilité, puis l'initialise.

const Stream = require('stream')
const readableStream = new Stream.Readable()

Maintenant, le flux est initialisé et vous pouvez lui envoyer des données :

readableStream.push('ping!')
readableStream.push('pong!')

Async Iterator

Il est fortement recommandé d'utiliser des itérateurs asynchrones lors de l'utilisation de flux. Selon le Dr Axel Rauschmayer, l'itération asynchrone est un protocole permettant de récupérer le contenu d'un conteneur de données de manière asynchrone (ce qui signifie que la « tâche » en cours peut être suspendue avant de récupérer des éléments). Il faut également mentionner que l'implémentation de l'itérateur asynchrone de flux utilise l'événement readable en interne.

Lors de la lecture à partir d'un flux lisible, vous pouvez utiliser un itérateur asynchrone :

import * as fs from 'fs';

async function logChunks(readable) {
  for await (const chunk of readable) {
    console.log(chunk);
  }
}

const readable = fs.createReadStream(
  'tmp/test.txt', {encoding: 'utf8'});
logChunks(readable);

// Output:
// 'This is a test!\n'

Vous pouvez également utiliser une chaîne pour collecter le contenu du flux lisible :

import {Readable} from 'stream';

async function readableToString2(readable) {
  let result = '';
  for await (const chunk of readable) {
    result += chunk;
  }
  return result;
}

const readable = Readable.from('Good morning!', {encoding: 'utf8'});
assert.equal(await readableToString2(readable), 'Good morning!');

注意，在这种情况下必须使用异步函数，因为我们想返回 Promise。

请切记不要将异步功能与 EventEmitter 混合使用，因为当前在事件处理程序中发出拒绝时，无法捕获拒绝，从而导致难以跟踪错误和内存泄漏。目前的最佳实践是始终将异步函数的内容包装在 try/catch 块中并处理错误，但这很容易出错。 这个 pull request 旨在解决一旦其落在 Node 核心上产生的问题。

要了解有关异步迭代的 Node.js 流的更多信息，请查看这篇很棒的文章。

Readable.from()：从可迭代对象创建可读流

stream.Readable.from(iterable, [options])  这是一种实用方法，用于从迭代器中创建可读流，该迭代器保存可迭代对象中包含的数据。可迭代对象可以是同步可迭代对象或异步可迭代对象。参数选项是可选的，除其他作用外，还可以用于指定文本编码。

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

async function * generate() {
  yield 'hello';
  yield 'streams';
}

const readable = Readable.from(generate());

readable.on('data', (chunk) => {
  console.log(chunk);
});

两种读取模式

根据 Streams API，可读流有效地以两种模式之一运行：flowing和paused。可读流可以处于对象模式，无论处于 flowing 模式还是 paused 模式。

• 在流模式下，将自动从底层系统读取数据，并通过 EventEmitter 接口使用事件将其尽快提供给程序。
• 在 paused 模式下，必须显式调用 stream.read() 方法以从流中读取数据块。

在 flowing 模式中，要从流中读取数据，可以监听数据事件并附加回调。当有大量数据可用时，可读流将发出一个数据事件，并执行你的回调。看下面的代码片段：

var fs = require("fs");
var data = '';

var readerStream = fs.createReadStream('file.txt'); //Create a readable stream

readerStream.setEncoding('UTF8'); // Set the encoding to be utf8. 

// Handle stream events --> data, end, and error
readerStream.on('data', function(chunk) {
   data += chunk;
});

readerStream.on('end',function() {
   console.log(data);
});

readerStream.on('error', function(err) {
   console.log(err.stack);
});

console.log("Program Ended");

函数调用 fs.createReadStream() 给你一个可读流。最初流处于静态状态。一旦你侦听数据事件并附加了回调，它就会开始流动。之后将读取大块数据并将其传递给你的回调。流实现者决定发送数据事件的频率。例如，每当有几 KB 的数据被读取时，HTTP 请求就可能发出一个数据事件。当从文件中读取数据时，你可能会决定读取一行后就发出数据事件。

当没有更多数据要读取（结束）时，流将发出结束事件。在以上代码段中，我们监听此事件以在结束时得到通知。

另外，如果有错误，流将发出并通知错误。

在 paused 模式下，你只需在流实例上重复调用 read()，直到读完所有数据块为止，如以下示例所示：

var fs = require('fs');
var readableStream = fs.createReadStream('file.txt');
var data = '';
var chunk;

readableStream.on('readable', function() {
    while ((chunk=readableStream.read()) != null) {
        data += chunk;
    }
});

readableStream.on('end', function() {
    console.log(data)
});

read() 函数从内部缓冲区读取一些数据并将其返回。当没有内容可读取时返回 null。所以在 while 循环中，我们检查是否为 null 并终止循环。请注意，当可以从流中读取大量数据时，将会发出可读事件。

所有 Readable 流均以 paused 模式开始，但可以通过以下方式之一切换为 flowing 模式：

• 添加一个 'data' 事件处理。
• 调用 stream.resume() 方法。
• 调用 stream.pipe() 方法将数据发送到可写对象。

Readable 可以使以下方法之一切换回 paused 模式：

• 如果没有管道目标，则通过调用 stream.pause() 方法。
• 如果有管道目标，请删除所有管道目标。可以通过调用 stream.unpipe() 方法来删除多个管道目标。

一个需要记住的重要概念是，除非提供了一种用于消耗或忽略该数据的机制，否则 Readable 将不会生成数据。如果使用机制被禁用或取消，则 Readable 将会试图停止生成数据。添加 readable 事件处理会自动使流停止 flowing，并通过 read.read() 得到数据。如果删除了 readable 事件处理，那么如果存在 'data' 事件处理，则流将再次开始 flowing。

如何创建可写流？

要将数据写入可写流，你需要在流实例上调用 write()。如以下示例所示：

var fs = require('fs');
var readableStream = fs.createReadStream('file1.txt');
var writableStream = fs.createWriteStream('file2.txt');

readableStream.setEncoding('utf8');

readableStream.on('data', function(chunk) {
    writableStream.write(chunk);
});

上面的代码很简单。它只是简单地从输入流中读取数据块，并使用 write() 写入目的地。该函数返回一个布尔值，指示操作是否成功。如果为 true，则写入成功，你可以继续写入更多数据。如果返回 false，则表示出了点问题，你目前无法写任何内容。可写流将通过发出 drain 事件来通知你什么时候可以开始写入更多数据。

调用 writable.end() 方法表示没有更多数据将被写入 Writable。如果提供，则可选的回调函数将作为 finish 事件的侦听器附加。

// Write 'hello, ' and then end with 'world!'.
const fs = require('fs');
const file = fs.createWriteStream('example.txt');
file.write('hello, ');
file.end('world!');
// Writing more now is not allowed!

你可以用可写流从可读流中读取数据：

const Stream = require('stream')

const readableStream = new Stream.Readable()
const writableStream = new Stream.Writable()

writableStream._write = (chunk, encoding, next) => {
    console.log(chunk.toString())
    next()
}

readableStream.pipe(writableStream)

readableStream.push('ping!')
readableStream.push('pong!')

writableStream.end()

还可以用异步迭代器来写入可写流，建议使用

import * as util from 'util';
import * as stream from 'stream';
import * as fs from 'fs';
import {once} from 'events';

const finished = util.promisify(stream.finished); // (A)

async function writeIterableToFile(iterable, filePath) {
  const writable = fs.createWriteStream(filePath, {encoding: 'utf8'});
  for await (const chunk of iterable) {
    if (!writable.write(chunk)) { // (B)
      // Handle backpressure
      await once(writable, 'drain');
    }
  }
  writable.end(); // (C)
  // Wait until done. Throws if there are errors.
  await finished(writable);
}

await writeIterableToFile(
  ['One', ' line of text.\n'], 'tmp/log.txt');
assert.equal(
  fs.readFileSync('tmp/log.txt', {encoding: 'utf8'}),
  'One line of text.\n');

stream.finished() 的默认版本是基于回调的，但是可以通过 util.promisify() 转换为基于 Promise 的版本（A行）。

在此例中，使用以下两种模式：

Writing to a writable stream while handling backpressure (line B):
在处理 backpressure 时写入可写流（B行）：

if (!writable.write(chunk)) {
  await once(writable, 'drain');
}

关闭可写流，并等待写入完成（C行）：

writable.end();
await finished(writable);

pipeline()

pipeline（管道）是一种机制，可以将一个流的输出作为另一流的输入。它通常用于从一个流中获取数据并将该流的输出传递到另一个流。管道操作没有限制。换句话说，管道可用于分多个步骤处理流数据。

在 Node 10.x 中引入了 stream.pipeline()。这是一种模块方法，用于在流转发错误和正确清理之间进行管道传输，并在管道完成后提供回调。

这是使用管道的例子：

const { pipeline } = require('stream');
const fs = require('fs');
const zlib = require('zlib');

// 使用 pipeline API 可以轻松将一系列流
// 通过管道传输在一起，并在管道完全完成后得到通知。
// 一个有效地用 gzip压缩巨大视频文件的管道：

pipeline(
  fs.createReadStream('The.Matrix.1080p.mkv'),
  zlib.createGzip(),
  fs.createWriteStream('The.Matrix.1080p.mkv.gz'),
  (err) => {
    if (err) {
      console.error('Pipeline failed', err);
    } else {
      console.log('Pipeline succeeded');
    }
  }
);

由于pipe 不安全，应使用 pipeline 代替 pipe。

流模块

Node.js 流模块 提供了构建所有流 API 的基础。

Stream 模块是 Node.js 中默认提供的原生模块。 Stream 是 EventEmitter 类的实例，该类在 Node 中异步处理事件。因此流本质上是基于事件的。

要访问流模块：

const stream = require('stream');

stream 模块对于创建新型流实例非常有用。通常不需要使用 stream 模块来消耗流。

流驱动的 Node API

由于它们的优点，许多 Node.js 核心模块提供了原生流处理功能，最值得注意的是：

• net.Socket 是流所基于的主 API 节点，它是以下大多数 API 的基础
• process.stdin 返回连接到 stdin 的流
• process.stdout 返回连接到 stdout 的流
• process.stderr 返回连接到 stderr 的流
• fs.createReadStream() 创建一个可读的文件流
• fs.createWriteStream() 创建可写的文件流
• net.connect() 启动基于流的连接
• http.request() 返回 http.ClientRequest 类的实例，它是可写流
• zlib.createGzip() 使用gzip（一种压缩算法）将数据压缩到流中
• zlib.createGunzip() 解压缩 gzip 流。
• zlib.createDeflate() deflate（压缩算法）将数据压缩到流中
• zlib.createInflate() 解压缩一个deflate流

流 备忘单：

查看更多：Node.js 流速查表

以下是与可写流相关的一些重要事件：

• error – Indique qu'une erreur s'est produite lors de l'écriture ou de la configuration du pipeline.
• pipeline – Cet événement est émis par un flux inscriptible lorsqu'un flux lisible est passé dans un flux inscriptible.
• unpipe – Émis lorsque vous appelez unpipe sur un flux lisible et arrêtez de le rediriger vers le flux cible.

Conclusion

C'est toutes les bases des streams. Les flux, les canaux et les chaînes sont les fonctionnalités principales et les plus puissantes de Node.js. Les flux vous aident vraiment à écrire du code concis et efficace pour effectuer des E/S.

En outre, il existe un plan stratégique Node.js à espérer, appelé BOB, qui vise à améliorer le flux de données interne de Node.js et, espérons-le, comme l'avenir L'API publique de l'interface de données de streaming Node.js.

Adresse originale en anglais : https://nodesource.com/blog/understanding-streams-in-nodejs

Auteur : Liz Parody

Traduction : Crazy Technology geek

Recommandations associées : tutoriel nodejs

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!