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

fs 模塊，視頻教學

os 模塊，視頻教學，api doc

 

Buffer類

---

  

建立 Buffer 類

// 建立一個長度爲 十、且用 0 填充的 Buffer。
const buf1 = Buffer.alloc(10);

// 建立一個長度爲 十、且用 0x1 填充的 Buffer。 
const buf2 = Buffer.alloc(10, 1);

------------------------------------------------------------------
// 建立一個長度爲 十、且未初始化的 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('==================================');
}

  

（完）