摘要：表示當前正在執行的腳本的文件名。默認編碼為模式為，為回調函數，回調函數只包含錯誤信息參數，在寫入失敗時返回。參數使用說明如下通過方法返回的文件描述符。

Node.js異步編程的直接體現就是回調。

const fs = require("fs");
let data = fs.readFileSync("input.txt");

console.log(data.toString());
console.log("程序執行結束");

const fs = require("fs");
fs.readFile("input.txt",(error,data)=>{
    if(error) return console.log(error);
   console.log(data.toString()); 
});
console.log("程序執行結束");

Node.js是單進程單線程應用程序，但是通過事件和回調支持并發，所以性能非常高。
進程：CPU執行任務的模塊。線程：模塊中的最小單元。

Node.js使用事件驅動模型。
事件就是需要 eventEmitter.on 去綁定一個事件 通過 eventEmitter.emit 去觸發這個事件其次說的是 事件的 接收 和 發生 是分開的

代碼如下：

// 引入events 模塊
const events = require("events");
// 創建 eventEmitter 對象
let eventEmitter = new events.EventEmitter();

// 這里既可以使用.on  也可以使用 .addListener
eventEmitter.on("dataReceived",(data) => {
    console.log(`接受的數據為：${data}`);
});

// 觸發 dataReceived 事件
eventEmitter.emit("dataReceived");

大多數時候我們不會直接使用 EventEmitter，而是在對象中繼承它。包括 fs、net、 http 在內的，只要是支持事件響應的核心模塊都是 EventEmitter 的子類。

若事件隊列中出現一個未綁定事件則觸發error事件，若未綁定 error事件則程序拋出異常結束執行 emitter.emit("error"); 程序會直接中斷，并拋出異常。

該類用來創建一個專門存放二進制數據的緩存區。

在v6.0以后，官方文檔里面建議使用 Buffer.from() 接口去創建Buffer對象。

Buffer 實例一般用于表示編碼字符的序列，比如 UTF-8 、 UCS2 、 Base64 、或十六進制編碼的數據。 通過使用顯式的字符編碼，就可以在 Buffer 實例與普通的 JavaScript 字符串之間進行相互轉換。

const buf = Buffer.from("hello","utf8");

// 輸出 hex 編碼后的內容
console.log(buff.toString("hex"));

// 輸出 base64 編碼后的內容
console.log(buf.toString("base64"));

通過 from 和 allocation（n:分配）

// 創建一個長度為 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。
// 如果是字符串會被 0 覆蓋
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");

buf.write(string,[offset],[length],[encoding]);
參數描述：

string - 寫入緩沖區的字符串。

offset -開始寫入的索引值，默認為0。

length -寫入的字節數，默認為buffer.length。

encoding -使用的字符編碼，默認為‘utf8’。

// 分配一個256字節的緩沖區
let buf = Buffer.alloc(256);
let len = buf.write("www.baidu.com");

console.log(`寫入的字節數數為：${len}`);

buf.toString([encoding],[start],[end]);
參數描述：

encoding - 使用的編碼。默認為 "utf8" 。

start - 指定開始讀取的索引位置，默認為 0。

end - 結束位置，默認為緩沖區的末尾。

// 創建緩沖區并寫入26個小寫英文字母的ASCII碼
buf = Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97;
}

console.log( buf.toString("ascii"));       // 輸出: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString("ascii",0,5));   // 輸出: abcde
console.log( buf.toString("utf8",0,5));    // 輸出: abcde
console.log( buf.toString(undefined,0,5)); // 使用 "utf8" 編碼, 并輸出: abcde

buf.toJSON();

var buffer3 = Buffer.concat([buffer1,buffer2]);

buf.copy([targetBufffer],[targetStart],[sourceStart],{sourceEnd});
eg: buf2.copy(buf1,2) // 將buf2插入到buf1指定的位置上

Stream 是一個抽象接口，Node 中有很多對象實現了這個接口。例如，對http 服務器發起請求的request 對象就是一個 Stream，還有stdout（標準輸出）。
所有的Stream對象繼承了 EventEmitter 類,所以擁有以下事件：

data - 當有數據可讀時觸發。

end - 沒有更多的數據可讀時觸發。

error - 在接收和寫入過程中發生錯誤時觸發。

finish - 所有數據已被寫入到底層系統時觸發。

const fs = require("fs");
let data = "";

// 創建可讀流
let readStream = fs.createReadStream("input.txt");
readStream.on("data",(chunk)=>{
    data += chunk;
})
readStream.on("end",()=>{
    console.log(data);
})
...

var fs = require("fs");
var data = "百度官網地址：www.baidu.com";

// 創建一個可以寫入的流，寫入到文件 output.txt 中
var writerStream = fs.createWriteStream("output.txt");

// 使用 utf8 編碼寫入數據
writerStream.write(data,"UTF8");

// 標記文件末尾
writerStream.end();

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

可以實現大文件的復制。

const fs = require("fs");
let rs = fs.createReadStream("input.txt");
let ws = fs.createWriteStream("output.txt");

// 管道讀寫操作
// 讀取input.txt,將內容寫入到output.txt文件中
rs.pipe(ws);

鏈式是通過連接輸出流到另外一個流并創建多個流操作鏈的機制。鏈式流一般用于管道操作。
接下來我們就是用管道和鏈式來壓縮和解壓文件。

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

Node.js 中的全局對象是 global，所有全局變量（除了 global 本身以外）都是 global 對象的屬性。
__filename :表示當前正在執行的腳本的文件名。（輸出文件所在的絕對路徑）
__ __dirnname __:表示當前執行腳本呢所在的目錄。
__ process __:它用于描述當前Node.js 進程狀態的對象。

util是一個node。js核心模塊，提供常用的函數的集合。

util.inherits(constructor,superConstructor) 是一個實現對象間原型繼承的函數。(構造函數中的屬性和函數不會被繼承)。

util.inspect(object,[showHidden],[depth],[colors]) 是一個將任意對象轉換 為字符串的方法，通常用于調試和錯誤輸出。

util.isArray(object) 判斷是否為一個數組。

util.isRegExp(object) 判斷是否為一個正則表達式。

util.isDate(object) 判斷是否為一個日期。

Node.js 提供一組標準的文件操作API。

var fs = require("fs");

fs.open(path,flags,[mode],callback);

path -文件路徑。

flags -文件打開的行為。（r r+ rs[同步] w a[追加]...）

mode - 設置文件模式(權限)，文件創建默認權限為 0666(可讀，可寫)。

callback - 回調函數，帶有兩個參數如：callback(err, fd)。

以下為通過異步模式獲取文件信息的語法格式：

fs.stat(path,callback) // 帶兩個參數：（err,stats）

可以通過stats類中的提供方法判斷文件的相關屬性。

stats.isFile() 如果是文件返回 true，否則返回 false。

stats.isDirectory() 如果是目錄返回 true，否則返回 false。

stats.isBlockDevice() 如果是塊設備返回 true，否則返回 false。

stats.isCharacterDevice() 如果是字符設備返回 true，否則返回 false。

stats.isSymbolicLink() 如果是軟鏈接返回 true，否則返回 false。

stats.isFIFO() 如果是FIFO，返回true，否則返回 false。FIFO是UNIX中的一種特殊類型的命令管道。

stats.isSocket() 如果是 Socket 返回 true，否則返回 false。

以下為異步模式下寫入文件的語法格式：

fs.writeFile(file, data,[options], callback)

如果文件存在，該方法寫入的內容會覆蓋舊的文件內容。

參數使用說明如下：

file - 文件名或文件描述符。

data - 要寫入文件的數據，可以是 String(字符串) 或 Buffer(流) 對象。

options - 該參數是一個對象，包含 {encoding, mode, flag}。默認編碼為 utf8, 模式為 0666 ， flag 為 "w"

callback - 回調函數，回調函數只包含錯誤信息參數(err)，在寫入失敗時返回。

以下為異步模式下讀取文件的語法格式：

fs.read(fd, buffer, offset, length, position, callback)

該方法使用了文件描述符來讀取文件。

參數使用說明如下：

fd - 通過 fs.open() 方法返回的文件描述符。

buffer - 數據寫入的緩沖區。

offset - 緩沖區寫入的寫入偏移量。

length - 要從文件中讀取的字節數。

position - 文件讀取的起始位置，如果 position 的值為 null，則會從當前文件指針的位置讀取。

callback - 回調函數，有三個參數err, bytesRead, buffer，err 為錯誤信息， + bytesRead 表示讀取的字節數，buffer 為緩沖區對象。

fs.close(fd,callback)

打開文件，讀取文件，關閉文件示例代碼：

var fs = require("fs");
var buf = new Buffer(1024);

console.log("準備打開文件！");
fs.open("input.txt", "r+", function(err, fd) {
   if (err) {
       return console.error(err);
   }
   console.log("文件打開成功！");
   console.log("準備讀取文件！");
   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }

      // 僅輸出讀取的字節
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }

      // 關閉文件
      fs.close(fd, function(err){
         if (err){
            console.log(err);
         } 
         console.log("文件關閉成功");
      });
   });
});

fs.unlink(path,callback);

fs.mkdir(path,[mode],callback);

fs.readdir(path,callback);  // callback(err,files[文件列表])         

fs.rmdir(path,callback);    

os模塊提供了一些基本的系統操作函數。

var os = require("os");

// CPU 的字節序
console.log("endianness : " + os.endianness());

// 操作系統名
console.log("type : " + os.type());

// 操作系統名
console.log("platform : " + os.platform());

// 系統內存總量
console.log("total memory : " + os.totalmem() + " bytes.");

// 操作系統空閑內存量
console.log("free memory : " + os.freemem() + " bytes.");

var path = require("path");

// 格式化路徑
console.log("normalization : " + path.normalize("/test/test1//2slashes/1slash/tab/..")); // normalization : /test/test1/2slashes/1slash

// 連接路徑
console.log("joint path : " + path.join("/test", "test1", "2slashes/1slash", "tab", "..")); // joint path : /test/test1/2slashes/1slash

// 轉換為絕對路徑
console.log("resolve : " + path.resolve("main.js")); // resolve : /web/com/1427176256_27423/main.js

// 路徑中文件的后綴名
console.log("ext name : " + path.extname("main.js")); // ext name : .js

dns.lookup(hostname,[options(4|6)],callback); // 解析域名

var dns = require("dns");

dns.lookup("www.github.com", function onLookup(err, address, family) {
   console.log("ip 地址:", address);
   dns.reverse(address, function (err, hostnames) {
   if (err) {
      console.log(err.stack);
   }

   console.log("反向解析 " + address + ": " + JSON.stringify(hostnames));
   });  
});