nodejs-stream

stream模块初解，流的类型，流的历史

const stream = require('stream');

stream 流 是一种在nodejs中处理‘流式数据’的抽象接口

Node.js，Stream 有四种流类型：

• Readable - 可读操作。
• Writable - 可写操作。
• Duplex - 可读可写操作.
• Transform - 操作被写入数据，然后读出结果。

可读流Readable的使用，可写流Writable的使用

Readable：两种模式，三种状态

两种模式：流动中（flowing）或已暂停（paused），可读流一档处于二者其一

• 在 flowing 模式中，数据自动地从底层的系统被读取，并通过 EventEmiter 接口的事件尽可能快地被提供给应用程序。
• 在 paused 模式中，必须显式调用 stream.read() 方法来从流中读取数据片段。

三种状态：在任意时刻，任一可读流会处于以下三种状态之一：

• readable.readableFlowing = null    // 没有提供消费流数据的机制，不会产生数据
• readable.readableFlowing = false   // 暂时停止事件流动，但数据依旧产生
• readable.readableFlowing = true    // 事件流动，产生数据

事件：close、data、end、error、readable

Writable：

事件：close、drain、finish、error、pipe、unpipe

Duplex的使用，Transform的使用

Duplex：同时实现了 Readable 和 Writable 接口的流

Transform：变换流，是一种 Duplex 流

stream的流的使用技巧，管道，链的使用，流的优化

管道流：.pipe()

 

fs中的流使用：大多用在管道流的使用上：.pipe().pipe()...

// import { read } from 'fs';

var cl = function(data){
    console.log(data);
}
var clstr = function(data){
    console.log(data.toString());
}

/** Stream 流的四种类型：
 * Readable ： 可读
 * Writeable ： 可写
 * Duplex : 可读可写
 * Transform : 操作被写入数据，然后读出结果
 */
/** Stream 对象事件
 * data ： 当有数据可读时触发。
 * end ： 没有更多的数据可读时触发
 * error ： 在接收和写入过程中发生错误时触发
 * finish ： 所有数据已被写入到底层系统时触发
 */

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

/** 创建测试文件 */
var fcreateFile = function(){
    fs.writeFile('./theTest.txt','this is a test data of strem', function(err){
        if(err){
            throw err;
        }
        cl('创建成功');
    })
}
// fcreateFile();


/** 创建可读文件流 */
var freadStream = function(){
    // 创建可读流
    var readerStream = fs.createReadStream('theTest.txt');
    // cl(readerStream);   // 一个ReadStream格式的对象

    // 设置编码utf8
    readerStream.setEncoding('UTF8');

    // 处理流事件---->data, end, and error
    readerStream.on('data', function(chunk){
        data += chunk;

        cl('监听事件---->data');
        cl(data);       // 'this is a test data of strem' 文件内容
    })

    readerStream.on('end', function(){
        cl('监听事件---->end');
        cl(data);       // 'this is a test data of strem' 文件内容
    })

    readerStream.on('error', function(err){
        console.error('ERROR!!!')
        cl(err.stack);
    })
}
// freadStream();


/** 写入文件流 */
var fwriteStream = function(){
    var data = 'the test of write Stream\n';
    // 创建可写流
    // var writeStream = fs.createWriteStream('output.txt');   // 覆盖式写入
    var writeStream = fs.createWriteStream('output.txt', {'flags' : 'a'});  // 追加式写入

    // 写入数据并指定编码格式
    writeStream.write(data, 'UTF8');
    // writeStream.write(data, {'flags' : 'a'}, 'UTF8');    ERROR function!!!!

    // 标记文件末尾
    writeStream.end();

    // 处理流事件---->data, end, and error
    writeStream.on('finish', function(){
        cl('写入完成');
    });

    writeStream.on('error', function(err){
        cl('ERROR');
        cl(err.stack);
    });
}
// fwriteStream();

/** 管道流
 * 用于从一个流中获取数据并将数据传递到另外一个流中
 */
var fpipeStream = function(){
    // 可读文件流
    var readerStream = fs.createReadStream('pipe_read.txt');

    // 追加写入方式文件流
    var writeStream = fs.createWriteStream('pipe_write.txt',{'flags' : 'a'});

    //管道读写操作
    readerStream.pipe(writeStream);

    cl('Over');
}
// fpipeStream();


/** 链式流 */
var fzlib = function(){
    var zlib = require('zlib');
    // 压缩
    exports.a = function(){
        fs.createReadStream('./zlib/input.txt')
            .pipe(zlib.createGzip())
            .pipe(fs.createWriteStream('./zlib/input.txt.gz'));
        
        cl('文件压缩完成');
    }

    // 解压
    exports.b = function(){
        fs.createReadStream('./zlib/input.txt.gz')
            .pipe(zlib.createGunzip())
            .pipe(fs.createWriteStream('./zlib/output.txt'));

        cl('文件解压完成')
    }
}
// fzlib().a();
cl(fzlib);