Nodejs流相关知识

于 2024-06-28 11:10:23 发布
阅读量940 收藏 21
点赞数 23
分类专栏： Node.js 前端工程化 文章标签： 前端 node.js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40588441/article/details/140037860
版权

Nodejs流相关知识

流的分类

  • Readable 可读流
  • Writable 可写流
  • Duplex 双工流
  • Transform 转换流
  • PassThrough 传递流

streaminherits1_1638679161974

Readable(可读流)

ReadableStream1_1638521193041

2.1 1.readableStream.js

1.readableStream.js

const readableStream = require('./readableStream');
readableStream.on('data', (data) => {
    console.log(data);
    readableStream.pause();
});

2.2 readableStream.js

readableStream.js

const Readable = require('./Readable');
const readableIterator = (function (count) {
    return {
        next() {
            count++;
            if (count <= 5) {
                return { done: false, value: count + '' };
            } else {
                return { done: true, value: null }
            }
        }
    }
})(0)

const readableStream = new Readable({
    read() {
        let { done, value } = readableIterator.next();
        if (done) {
            this.push(null);
        } else {
            this.push(value);
        }
    }
});
module.exports = readableStream;

2.3 Readable.js

Readable.js

const Stream = require('./Stream');
var { inherits } = require('util');
function Readable(options) {
    Stream.call(this, options);
    this._readableState = { ended: false, buffer: [], flowing: false };
    if (options.read) this._read = options.read;
}
inherits(Readable, Stream);
Readable.prototype.on = function (event, fn) {
    Stream.prototype.on.call(this, event, fn);
    if (event === 'data') {
        this.resume();
    }
}
Readable.prototype.resume = function () {
    this._readableState.flowing = true;
    while (this.read());
}
Readable.prototype.pause = function () {
    this._readableState.flowing = false;
}
Readable.prototype.read = function () {
    if (!this._readableState.ended && this._readableState.flowing) {
        this._read();
    }
    let data = this._readableState.buffer.shift();
    if (data) {
        this.emit('data', data);
    }
    return data;
}
Readable.prototype.push = function (chunk) {
    if (chunk === null) {
        this._readableState.ended = true;
    } else {
        this._readableState.buffer.push(chunk);
    }
}
module.exports = Readable;

2.4 Stream.js

Stream.js

const EventEmitter = require('events');
var { inherits } = require('util');
function Stream(options) {
     this.options = options;
    EventEmitter.call(this);
}
inherits(Stream, EventEmitter);
module.exports = Stream;

Writable(可写流)

Writable_1638585773103

基本实现

writableStream.js

writableStream.js

let writableStream = require('./writableStream');
writableStream.write('1');
writableStream.write('2');
writableStream.write('3');
writableStream.write('4');
writableStream.write('5');
writableStream.end();
writableStream.js

writableStream.js

const Writable = require('./Writable');
const writableStream = new Writable({
    write(data, encoding, next) {
        console.log(data.toString(encoding));
        setTimeout(next, 1000);
    }
});
module.exports = writableStream;
Writable.js

Writable.js

const Stream = require('./Stream');
var { inherits } = require('util');
function Writable(options) {
    Stream.call(this, options);
    this._writableState = {
        ended: false,
        writing: false,
        buffer: []
    };
    if (options.write) this._write = options.write;
}
inherits(Writable, Stream);
Writable.prototype.write = function (chunk) {
    if (this._writableState.ended) {
        return;
    }
    if (this._writableState.writing) {
        this._writableState.buffer.push(chunk);
    } else {
        this._writableState.writing = true;
        this._write(chunk, 'utf8', () => this.next());
    }
}
Writable.prototype.next = function () {
    this._writableState.writing = false;
    if (this._writableState.buffer.length > 0) {
        this._write(this._writableState.buffer.shift(), 'utf8', () => this.next());
    }
}
Writable.prototype.end = function () {
    this._writableState.ended = true;
}
module.exports = Writable;

highWaterMark

highWaterMark.js

highWaterMark.js

//const { Writable } = require('stream');
const Writable = require('./Writable');
class WritableStream extends Writable {
    _write = (data, encoding, next) => {
        console.log(data.toString());
        setTimeout(next, 1000);
    }
}
const writableStream = new WritableStream({
    highWaterMark: 1
});
writableStream.on('finish', () => {
    console.log('finish');
});
let canWrite = writableStream.write('1');
console.log('canWrite:1', canWrite);
canWrite = writableStream.write('2');
console.log('canWrite:2', canWrite);
canWrite = writableStream.write('3');
console.log('canWrite:3', canWrite);
writableStream.once('drain', () => {
    console.log('drain');
    let canWrite = writableStream.write('4');
    console.log('canWrite:4', canWrite);
    canWrite = writableStream.write('5');
    console.log('canWrite:5', canWrite);
    canWrite = writableStream.write('6');
    console.log('canWrite:6', canWrite);
});

/**
1
canWrite:1 false
canWrite:2 false
canWrite:3 false
2
3
drain
4
canWrite:4 false
canWrite:5 false
canWrite:6 false
5
6
 */
Writable.js

Writable.js

const Stream = require('./Stream');
var { inherits } = require('util');
function Writable(options) {
    Stream.call(this, options);
    this._writableState = {
        ended: false,
        writing: false,
        buffer: [],
+       bufferSize: 0
    };
    if (options.write) this._write = options.write;
}
inherits(Writable, Stream);
Writable.prototype.write = function (chunk) {
    if (this._writableState.ended) {
        return;
    }
    chunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8');
    this._writableState.bufferSize += chunk.length;
+   let canWrite = this.options.highWaterMark > this._writableState.bufferSize;
+   if (this._writableState.writing) {
+       this._writableState.buffer.push(chunk);
+   } else {
+       this._writableState.writing = true;
+       this._write(chunk, 'utf8', () => this.next());
+   }
+   return canWrite;
}
Writable.prototype.next = function () {
    this._writableState.writing = false;
+   if (this._writableState.buffer.length > 0) {
+       let chunk = this._writableState.buffer.shift();
+       this._write(chunk, 'utf8', () => {
+           this._writableState.bufferSize -= chunk.length;
+           this.next();
+       })
+   } else {
+       this.emit('drain');
+   }
}
Writable.prototype.end = function () {
    this._writableState.ended = true;
}
module.exports = Writable;

pipe(管道)

pipe.js

pipe.js

const readableStream = require('./readableStream');
const writableStream = require('./writableStream');
readableStream.pipe(writableStream);

Readable.js

Readable.js

const Stream = require('./Stream');
var { inherits } = require('util');
function Readable(options) {
    Stream.call(this, options);
    this._readableState = { ended: false, buffer: [], flowing: false };
    if (options.read) this._read = options.read;
}
inherits(Readable, Stream);
Readable.prototype.on = function (event, fn) {
    Stream.prototype.on.call(this, event, fn);
    if (event === 'data') {
        this.resume();
    }
}
Readable.prototype.resume = function () {
    this._readableState.flowing = true;
    while (this.read());
}
Readable.prototype.pause = function () {
    this._readableState.flowing = false;
}
Readable.prototype.read = function () {
    if (!this._readableState.ended && this._readableState.flowing) {
        this._read();
    }
    let data = this._readableState.buffer.shift();
    if (data) {
        this.emit('data', data);
    }
    return data;
}
Readable.prototype.push = function (chunk) {
    if (chunk === null) {
        this._readableState.ended = true;
    } else {
        this._readableState.buffer.push(chunk);
    }
}
+Readable.prototype.pipe = function (dest) {
+    this.on('data', (chunk) => {
+        dest.write(chunk);
+    })
+    this.on('end', () => {
+        dest.end();
+    });
+}
module.exports = Readable;

Duplex()双工流)

duplexStream.js

duplexStream.js

const duplexStream = require('./duplexStream');
duplexStream.pipe(duplexStream);

duplexStream.js

duplexStream.js

const Duplex = require('./Duplex');
const readableIterator = (function (count) {
    return {
        next() {
            count++;
            if (count <= 5) {
                return { done: false, value: count + '' };
            } else {
                return { done: true, value: null }
            }
        }
    }
})(0)
const duplexStream = new Duplex({
    read() {
        let { done, value } = readableIterator.next();
        if (done) {
            this.push(null);
        } else {
            this.push(value);
        }
    },
    write(data, encoding, next) {
        console.log(data.toString(encoding));
        setTimeout(next, 1000);
    }
});
module.exports = duplexStream;

Duplex.js

Duplex.js

const Readable = require('./Readable');
const Writable = require('./Writable');
var { inherits } = require('util');
inherits(Duplex, Readable);
const keys = Object.keys(Writable.prototype);
for (let v = 0; v < keys.length; v++) {
    const method = keys[v];
    if (!Duplex.prototype[method]) {
        Duplex.prototype[method] = Writable.prototype[method];
    }
}
function Duplex(options) {
    Readable.call(this, options);
    Writable.call(this, options);
}

module.exports = Duplex;

Transform(转换流)

transform1_1638585663180

transformStream.js

transformStream.js

const readableStream = require('./readableStream');
const transformStream = require('./transformStream');
const writableStream = require('./writableStream');
readableStream.pipe(transformStream).pipe(writableStream);

transformStream.js

transformStream.js

const Transform = require('./Transform');
const transformStream = new Transform({
    transform(buffer, encoding, next) {
        let transformed = buffer.toString(encoding) + '$';
        next(null, transformed);
    }
});
module.exports = transformStream;

Transform.js

Transform.js

const Duplex = require('./Duplex');
var { inherits } = require('util');
inherits(Transform, Duplex);
function Transform(options) {
    Duplex.call(this, options);
    if (options.transform) this._transform = options.transform;
}
Transform.prototype._write = function (chunk, encoding, next) {
    this._transform(chunk, encoding, (err, data) => {
        if (data) {
            this.push(data);
        }
        next(err);
    });
}
Transform.prototype._read = function () {

}
module.exports = Transform;

objectMode(对象模式)

  • 默认情况下，流处理的数据是Buffer/String类型的值
  • 有一个objectMode标志，我们可以设置它让流可以接受任何JavaScript对象

objectMode.js

objectMode.js

const { Readable, Writable } = require('stream');
const readableIterator = (function (count) {
    return {
        next() {
            count++;
            if (count <= 5) {
                return { done: false, value: { id: count + '' } };
            } else {
                return { done: true, value: null }
            }
        }
    }
})(0)
const readableStream = new Readable({
    objectMode: true,
    read() {
        let { done, value } = readableIterator.next();
        if (done) {
            this.push(null);
        } else {
            this.push(value);
        }
    }
});
const writableStream = new Writable({
    objectMode: true,
    write(data, encoding, next) {
        console.log(data);
        setTimeout(next, 1000);
    }
});
readableStream.pipe(writableStream);

through2

  • through2是一个简单的流处理模块，它提供了一个简单的接口，可以让我们更加方便地处理流

index.js

  • through2.js

    const Transform = require('./Transform');
const { Transform } = require('stream');
function through2(transform) {
    return new Transform({
        transform
    });
}
through2.obj = function (transform) {
    return new Transform({
        objectMode: true,
        transform
    });
}
module.exports = through2;

  • index.js

    const fs = require('fs');
const through2 = require('./through2');
const readableStream = require('./readableStream');
const writableStream = require('./writableStream');
const transformStream = through2(function (chunk, encoding, next) {
    let transformed = chunk.toString(encoding) + '$';
    next(null, transformed);
});
readableStream.pipe(transformStream).pipe(writableStream);

highWaterMark参数

  • 在 Node.js 中，highWaterMark 参数用于配置流（stream）的缓冲区大小。它指定了在暂停读取或写入之前，流中可以存储的最大字节数。highWaterMark 参数在创建可读流（readable streams）和可写流（writable streams）时都可以使用。

  • highWaterMark 的作用

  • 对于可读流：highWaterMark 定义了内部缓冲区的大小，流会尽可能地读取数据并存储在缓冲区中，直到达到 highWaterMark 指定的字节数，然后暂停读取，直到缓冲区中的数据被消费。

  • 对于可写流：highWaterMark 定义了内部缓冲区的大小，流会尽可能地写入数据到缓冲区中，直到达到 highWaterMark 指定的字节数，然后暂停写入，直到缓冲区中的数据被消费。

const fs = require('fs');
const through2 = require('through2');
// 创建一个可读流，读取 data.txt 文件，并设置 highWaterMark 为 10，意味着每次读取最多 10 个字节的数据
const fileStream = fs.createReadStream('data.txt', { highWaterMark: 10 });
const all = [];
fileStream.pipe(
    // 创建一个通过流（transform stream），在这里试图将读取的字节块（chunk）转换为 JSON 对象
    through2.obj(function (chunk, encoding, next) {
        // 尝试将读取的块解析为 JSON 对象，并将其推送到下一个流中
        this.push(JSON.parse(chunk))
        next();
    })).on('data', (data) => {
        all.push(data)
    }).on('end', () => {
        console.log(all);
    })

  • data.txt

    {"id":1}
{"id":2}
{"id":3}
若梦plus
关注
专栏目录
Node.js Readable Stream的实现简析
weixin_34319374的博客
03-23 1889
作者：肖磊 个人主页：github Readable Stream是对数据源的一种抽象。它提供了从数据源获取数据并缓存，以及将数据提供给数据消费者的能力。 接下来分别通过Readable Stream的2种模式来学习下可读流是如何获取数据以及将数据提供给消费者的。 Flowing模式 在flowing模式下，可读流自动从系统的底层读取数据，并通过EventEmitter接口的事件提供给消费者。如...
在Node.js中 Stream可读流的基本使用
最新发布
有我更精彩的博客
08-05 444
在Node.js中，Stream是一个抽象的接口，用于处理数据的读写操作。可读流（Readable Stream）专门用于从源中读取数据，源可以是文件、网络连接、标准输入等。可读流提供了一种方式，让开发者可以逐块地读取数据，而不是一次性加载整个数据集。这在处理大数据时尤为重要，因为它可以有效地减少内存消耗。
初探nodejs的stream(流)
weixin_34357928的博客
06-03 198
什么是流? Stream(流) 就和它得名字一样，我们可以把它想象成像水流，从一个地方流向另外一个地方。按照一定速率，有快有慢。而Nodejs里流则是将数据以一定的速率从原文件流向目标文件。它最基本的原理，按照官方对它的描述，它是一个发布订阅，因为它继承自EventEmitter,然后再去实现出了Readable(可读流),Writeable(可写流),Duplex(双工流,既可读又可写)。其中R...
Nodejs数据流（Stream）手册
Dragon.G
04-14 6845
在书上看到的补充阅读，为了以后方便以后复习干脆翻译了下来。翻译自Node数据流手册1、介绍本文介绍了使用 node.js streams 开发程序的基本方法。"We should have some ways of connecting programs like garden hose--screw in another segment when it becomes necessary to m
解释Node.js中的流（Streams）
有我更精彩的博客
06-12 696
在Node.js中，流（Stream）是一种处理数据的一种高级抽象。常见的数据流包括：从文件中读取数据、写入数据到文件中、通过HTTP传输数据等等。流的使用可以让你高效地处理大规模的数据输入和输出，而不必一次性将所有数据加载到内存中。简而言之，可以把流看作“管道”，这些管道允许你以块（chunk）为单位处理数据，这种方式对于处理大文件或者高并发请求中非常高效。
Nodejs 相关知识配套资源
09-20
文件列表中的 "node" 可能包含了 Node.js 的相关示例代码、教程文档或项目资源。学习这些资源可以帮助你深入理解 Node.js 的工作原理，掌握如何使用 Express 和 Koa 构建 web 应用，以及如何利用 Mocha 编写和运行...
nodejs基础知识
10-20
Node.js是一种基于Chrome V8引擎的JavaScript运行时环境，它允许JavaScript在服务器端运行，构建快速且可扩展的网络应用。Node.js的开发由Ryan Dahl在2009年开始，起初是为了克服传统服务器架构在处理高并发I/O密集...
NodeJs知识
08-04
标题中的“NodeJs知识”指的是关于Node.js这一服务器端JavaScript运行环境的相关学习和理解。Node.js利用了Chrome V8引擎，使开发者可以在服务端编写高性能的网络应用。它以其异步、非阻塞I/O模型而闻名，尤其适用于...
nodejs：nodejs中文文档
02-04
这个"nodejs：nodejs中文文档"压缩包文件包含了Node.js的中文文档，这对于学习和理解Node.js的特性和功能至关重要。 1. **事件驱动编程**：Node.js 的核心设计是基于事件循环和非阻塞I/O模型，这种模型使得Node.js...
nodejs实战pdf+源码_nodejs_nodejs实战pdf+源码_
10-03
《Node.js实战》是一本...此外，配合源码学习，读者可以实际操作书中示例，加深对理论知识的理解。通过本书的学习，无论是初学者还是有一定经验的开发者，都能提升在Node.js领域的专业技能，更好地应对各种开发挑战。
NodeJs标准库——流（Stream）的实现原理
qq_43778239的博客
03-30 1198
Node.js streams（流）因其晦涩难懂以及难以使用而闻名。不过读了这篇文章之后，这些都难不倒你了，本文通过解剖流的实现原理来学习流。
node那点事(一) -- Readable streams（可读流）
weixin_33872566的博客
04-03 298
流的简介 流（stream）在 Node.js 中是处理流数据的抽象接口（abstract interface）。 stream 模块提供了基础的 API 。使用这些 API 可以很容易地来构建实现流接口的对象。 Node.js 提供了多种流对象。 例如， HTTP 请求 和 process.stdout 就都是流的实例。 流可以是可读的、可写的，或是可读写的。所有的流都是 EventEmitte...
NodeJS Stream 三：readable
weixin_33674976的博客
01-16 242
什么是可读流 可读流是生产数据用来供程序消费的流。我们常见的数据生产方式有读取磁盘文件、读取网络请求内容等，看一下前面介绍什么是流用的例子： const rs = fs.createReadStream(filePath); rs 就是一个可读流，其生产数据的方式是读取磁盘的文件，我们常见的控制台 process.stdin 也是一个可读流： process.stdin.pipe(process....
Node.js开发入门—Stream用法详解
热门推荐
安晓辉生涯——聚焦程序员的职业规划与成长
10-14 2万+
Stream是Node.js中非常重要的一个模块，离开它，基本上你就废了，除了写个HelloWorld，其它什么也干不成……
初探Node.js Stream中Readable类的内部实现
一只
11-13 2179
写在最前本次试图浅析探索Nodejs的Stream模块中对于Readable类的一部分实现（可写流也差不多）。其中会以可读流两种模式中的paused mode即暂停模式的表现形式来解读源码上的实现，为什么不分析flowing mode自然是因为这个模式是我们常用的其原理相比暂停模式下相对简单（其实是因为笔者总是喜欢关注一些边边角角的东西，不按套路出牌=。=），同时核心方法都是一样的，一通百通嘛，有兴
NodeJs ReadStream机制分析
qiucheng55的专栏
08-02 4494
读了一下午源代码，作者写的代码太难懂了，洋洋洒洒，勉强看懂。 ReadStream有两个模式，即flow模式和readable模式，一旦设定成一种模式，最好不要切换成另一种。 1.当一个stream被调用了on("data",..)后，即进入flow模式。 2.stream.flow被设置成true，并且调用resume方法，下图是resume方法的截图 function resume(s
nodejs读取文件 —— createReadStream
AnitaSun的博客
03-10 1741
参数： 第一个参数：读取文件的路径 第二个参数：highWaterMark 最高水位线,默认最多读取64K 读取的内容都是buffer类型 返回的结果是一个可读流的实例，是非流动模式–我们最后要转化为流动模式 let rs=fs.createReadStream('./1.txt',{highWaterMark:1}) 设置最高水位线每次读取1k let fs=require("fs"); // 第一个参数，读取文件的路径 //第二个参数 highWaterMark 最高水位线,默认最多读取64K //.
Node.js 流源码解读之可读流
奇舞周刊
03-09 526
1. 基本概念1.1. 流的历史演变流不是 Node.js 特有的概念。它们是几十年前在 Unix 操作系统中引入的，程序可以通过管道运算符（|）对流进行相互交互。在基于 Unix 系统的...
NodeJS模块深入：面试必备知识
"NodeJS面试题涉及到模块机制、require加载...Node.js的面试题涵盖了从基础的模块机制到复杂的内存管理和进程通信，以及安全相关的知识。深入理解并能灵活运用这些概念和技术，是成为一名合格的Node.js开发者的关键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值