[Node.js] 03 - Buffer, Stream and File IO

fs 模块，视频教学

os 模块，视频教学，api doc

Buffer类

---

创建 Buffer 类

// 创建一个长度为 10、且用 0 填充的 Buffer。
const buf1 = Buffer.alloc(10);

// 创建一个长度为 10、且用 0x1 填充的 Buffer。
const buf2 = Buffer.alloc(10, 1);

------------------------------------------------------------------
// 创建一个长度为 10、且未初始化的 Buffer。
// 这个方法比调用 Buffer.alloc() 更快，
// 但返回的 Buffer 实例可能包含旧数据，
// 因此需要使用 fill() 或 write() 重写。
const buf3 = Buffer.allocUnsafe(10);

-------------------------------------------------------------------
// 创建一个包含 [0x1, 0x2, 0x3] 的 Buffer。
const buf4 = Buffer.from([1, 2, 3]);

// 创建一个包含 UTF-8 字节 [0x74, 0xc3, 0xa9, 0x73, 0x74] 的 Buffer。
const buf5 = Buffer.from('tést');

// 创建一个包含 Latin-1 字节 [0x74, 0xe9, 0x73, 0x74] 的 Buffer。
const buf6 = Buffer.from('tést', 'latin1');

写 Buffer类

buf = Buffer.alloc(256);
len = buf.write("www.runoob.com");

console.log("写入字节数 : "+  len);

读 Buffer类

1. 查看其中内容：

一个 Buffer 类似于一个整数数组，但它对应于 V8 堆内存之外的一块原始内存。

const buf = Buffer.from('runoob', 'ascii');

// 输出 72756e6f6f62
console.log(buf.toString('hex'));

ascii - 仅支持 7 位 ASCII 数据。如果设置去掉高位的话，这种编码是非常快的。

utf8 - 多字节编码的 Unicode 字符。许多网页和其他文档格式都使用 UTF-8 。

utf16le - 2 或 4 个字节，小字节序编码的 Unicode 字符。支持代理对（U+10000 至 U+10FFFF）。

ucs2 - utf16le 的别名。

base64 - Base64 编码。

latin1 - 一种把 Buffer 编码成一字节编码的字符串的方式。

binary - latin1 的别名。

hex - 将每个字节编码为两个十六进制字符。

Node.js 目前支持的字符编码包括：

2. 转换为 JSON 对象：

const buf  = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
const json = JSON.stringify(buf);　　// 隐式地调用了 toJSON()

// 输出: {"type":"Buffer","data":[1,2,3,4,5]}
console.log(json);

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ?
    Buffer.from(value.data) :
    value;
});

// 输出: <Buffer 01 02 03 04 05>
console.log(copy);

• JSON.parse

服务器 --> 字符串 --> JavaScript 对象。

JSON.parse(text[, reviver])

对text进行parse后，再进行一次处理，示范试下：

<script>

var text = '{ "name":"Runoob", "initDate":"2013-12-14", "site":"www.runoob.com"}';
var obj = JSON.parse(text, function (key, value) {
    if (key == "initDate") {
        return new Date(value);
    } else {
        return value;
}});

document.getElementById("demo").innerHTML = obj.name + "创建日期：" + obj.initDate;

</script>

缓冲区合并

/*
 * Buffer.concat(list[, totalLength])
 */

var buffer1 = Buffer.from(('菜鸟教程'));
var buffer2 = Buffer.from(('www.runoob.com'));
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());

缓冲区比较

var buffer1 = Buffer.from('ABC');
var buffer2 = Buffer.from('ABCD');
var result  = buffer1.compare(buffer2);　　// 是比较大小

if(result < 0) {
   console.log(buffer1 + " 在 " + buffer2 + "之前");
}else if(result == 0){
   console.log(buffer1 + " 与 " + buffer2 + "相同");
}else {
   console.log(buffer1 + " 在 " + buffer2 + "之后");
}

缓冲区拷贝

/**
 * buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])
 */
var buf1 = Buffer.from('abcdefghijkl');
var buf2 = Buffer.from('RUNOOB');

//将 buf2 插入到 buf1 指定位置上
buf2.copy(buf1, 2);

console.log(buf1.toString());

Result: abRUNOOBijkl

缓冲区裁剪

/**
 * buf.slice([start[, end]])
 */
var buffer1 = Buffer.from('runoob');
// 剪切缓冲区
var buffer2 = buffer1.slice(0,2);
console.log("buffer2 content: " + buffer2.toString());

Result: buffer2 content: ru

缓冲区长度

var buffer = Buffer.from('www.runoob.com');
//  缓冲区长度
console.log("buffer length: " + buffer.length);

Node.js 文件系统

---

包括：文件操作和流操作

文件操作

Node 导入文件系统模块(fs)，有异步、同步读取文件之分：

var fs = require("fs");

// 1.异步读取
fs.readFile('input.txt', function (err, data) {
   if (err) {
       return console.error(err);
   }
   console.log("异步读取: " + data.toString());
});

// 2.同步读取
var data = fs.readFileSync('input.txt');
console.log("同步读取: " + data.toString());

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

• 同步也可能会影响异步：

如下是异步读文件。However, “线程delay 4秒会cover到这个异步，竟然使异步也delay 4sec.

• 删除文件：unlink

以下接口参见原文：

• readFile()，readFileSync()
• writeFile()，writeFileSync()
• exists(path, callback)
• mkdir()，writeFile()，readFile()
• mkdirSync()，writeFileSync()，readFileSync()
• readdir()，readdirSync()
• stat()

这里再详述若干有意思的接口：

watchfile()，unwatchfile()

watchfile方法监听一个文件，如果该文件发生变化，就会自动触发回调函数。

var fs    =require('fs');
var path  =require('path');
var file1 =path.resolve('/test1/one.txt');  
//监视文件
//当前程序没有结束，一直在监视文件
var listener=function(curr,prev){
    console.log('监视文件发生修改');
};  
fs.watchFile(file1, {interval:100}, listener);  
//取消监视文件
//当前程序程序结束退出
fs.unwatchFile(file1,listener);  

文件部分内容放入buffer中，提高了文件处理效率。

文件流操作

Stream 有四种流类型：

• Readable - 可读操作。

• Writable - 可写操作。

• Duplex - 可读可写操作.

• Transform - 操作被写入数据，然后读出结果。

所有的 Stream 对象都是 EventEmitter 的实例。常用的事件有：

• data - 当有数据可读时触发。

• end - 没有更多的数据可读时触发。

• error - 在接收和写入过程中发生错误时触发。

• finish - 所有数据已被写入到底层系统时触发。

读取流

触发机制：Node.js 所有的异步 I/O 操作在完成时都会发送一个事件到事件队列。

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

// 创建可读流
var readerStream = fs.createReadStream(__dirname + 'input.txt', 'utf8');
// readerStream.setEncoding('UTF8'); //　一处编码方式设置即可

// 处理流事件 --> 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("程序执行完毕");

写入流

var fs = require("fs");
var data = '菜鸟教程官网地址：www.runoob.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("程序执行完毕");

管道操作

管道流

简单的复制内容的操作

var fs = require("fs");

// 创建一个可读流
var readerStream = fs.createReadStream('input.txt');

// 创建一个可写流
var writerStream = fs.createWriteStream('output.txt');

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

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

链式流

链式流一般用于管道操作。

读文件 --> 压缩文件。

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

// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'));

console.log("文件压缩完成。");

读文件 --> 解压文件。

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("文件解压完成。");

os模块

返回当前操作系统的换行符

const fs = require(`fs`);

// bad
fs.readFile('./myFile.txt', 'utf8', (err, data) => {
  data.split('\r\n').forEach(line => {
    // do something
  });
});

// good
const os = require('os');
fs.readFile('./myFile.txt', 'utf8', (err, data) => {
  data.split(os.EOL).forEach(line => {
    // do something
  });
});

os.tmpdir 方法返回操作系统默认的临时文件目录。

os.arch 方法返回当前计算机的架构。

require(`os`).arch()
// "x64"

列出当前系列的所有IP地址

var os = require('os');
var interfaces = os.networkInterfaces();

for (item in interfaces) {
  console.log('Network interface name: ' + item);
  for (att in interfaces[item]) {　　　　　　　　// 看上去interface是个map
    var address = interfaces[item][att];

    console.log('Family: ' + address.family);
    console.log('IP Address: ' + address.address);
    console.log('Is Internal: ' + address.internal);
    console.log('');
  }
  console.log('==================================');
}

（完）