命令行输入输出

从命令行输入输出时，主要使用 process.stdin 和 process.stdout，示例如下。

// 引入readline模块
const readline = require('readline');

//创建readline接口实例
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// question方法
// rl.question("你的名字是？", function (answer) {
//     console.log("我的名字是：" + answer);
//     // 不加close，则程序不会结束
//     rl.close();
// });


function myQuestion(title){
    return new Promise((resolve, reject)=>{
        if(title === ''){
            reject("空");
        }
        rl.question(title, function (answer) {
            resolve(answer)
        });
    })
}

async function createPackage(){
    let name = await myQuestion("名字")
    let description = await myQuestion("描述")
    let main = await myQuestion("主体")
    console.log(name, description, main)
    rl.close();
}

createPackage();

// close事件监听
rl.on("close", function () {
    console.log("结束");
    // 结束程序
    process.exit(0);
})

文件输入输出

这里可以看我发的另一篇笔记《nodejs操作文件入门》。

但，当遇到有大量IO时，需要使用流的方式来写入文件。懂的都懂，文件IO是计算机的基础知识了，这里就不赘述流的原理了。

Node.js Stream(流)

Node.js中Stream 主要有四种流类型：

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

常用的事件有：

• data – 当有数据可读时，会触发。
• end – 没有更多的数据可读时，会触发。
• error – 在接收和写入过程中发生错误时，会触发。
• finish – 所有数据已被写入到底层系统时，会触发。

接下来主要介绍常用的流操作。

从流中读取数据操作

创建 input.txt 文件。

www.text.com

创建 main.js 文件。

let fs = require("fs");
let path = require('path');
let data = '';

// 创建可读流
filePath = path.resolve(__dirname, 'input.txt')
let readerStream = fs.createReadStream(filePath, {flags:'r', encoding:"utf-8"});

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

// 处理流事件 --> data, end, and error

readerStream.on('open', function (err) {
    console.log("文件已打开");
});


readerStream.on('data', function (chunk) {
    console.log("单批数据流入" + chunk.length)
    console.log(chunk)
    data += chunk;
});

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

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


readerStream.on("close", function(){
    console.log("on close")
})

console.log("程序执行完毕");

以上代码执行结果如下：

程序执行完毕
文件已打开
单批数据流入11
www.text.com
on end
on close

写入流操作

创建 main.js 文件。

var fs = require("fs");
var data = 'www.sxt.com';

// 创建一个可以写入的流，写入到文件 output.txt 中
var writerStream = fs.createWriteStream('output.txt');

// 使用 utf8 编码写入数据
writerStream.write(data,'UTF8');

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

// 处理流事件 --> data, end, and error
writerStream.on('finish', function() {
    console.log("写入完成。");
});

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

console.log("程序执行完毕");

以上程序会将 data 变量的数据写入到 output.txt 文件中。

代码执行结果如下：

$ node main.js 
程序执行完毕
写入完成。

查看 output.txt 文件的内容：

$ cat output.txt 
www.sxt.com

管道流操作

管道提供了一个输出流到输入流的操作机制。简单来说，就相当于在两条河流中间通个有方向的水管，使得水能够从一个流中输出到另外一个流，而这里的水就相当于是数据。

以下实例通过读取一个文件内容并将内容写入到另外一个文件中。

设置 input.txt 文件。

www.text.com
管道流操作实例

创建 main.js 文件。

let fs = require("fs");
let path = require("path")
// 创建一个可读流
let filePath = path.resolve(__dirname, "input.txt")
let readerStream = fs.createReadStream(filePath);

// 创建一个可写流
let writerStream = fs.createWriteStream(path.resolve(__dirname, "output.txt"));

// 管道读写操作
// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
readerStream.pipe(writerStream);

console.log("程序执行完毕");

代码执行结果如下：

$ node main.js 
程序执行完毕

查看 output.txt 文件的内容：

$ cat output.txt 
www.text.com
管道流操作实例

链式流操作

链式是通过连接输出流到另外一个流并创建多个流操作链的机制。链式流一般用于管道操作。

很好理解，就是流+链式调用。

接下来用管道和链式来压缩和解压文件。

创建 compress.js 文件, 代码如下：

let fs = require("fs");
let zlib = require('zlib');

// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'));
  
console.log("文件压缩完成。");

代码执行结果如下：

$ node compress.js 
文件压缩完成。

执行完以上操作后，可以看到当前目录下生成了 input.txt 的压缩文件 input.txt.gz。

接下来，解压该文件，创建 decompress.js 文件，代码如下：

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

// 解压 input.txt.gz 文件为 input.txt
fs.createReadStream('input.txt.gz')
  .pipe(zlib.createGunzip())
  .pipe(fs.createWriteStream('input.txt'));
  
console.log("文件解压完成。");

代码执行结果如下：

$ node decompress.js 
文件解压完成。