node.js基礎知識

GET/POST請求

瞭解

常用的屬性和方法
命令行輸入node進入交互模式，可以在終端執行語句；
node file.js執行JS文件；
node是單線程，回調執行異步，提高了性能
回調在最後參數位置；
回調函數中第一參數是錯誤，第二個是成功；

檢測window系統中path設置，cmd輸入path

npm i <pkg>本地安裝
npm i <pkg> -g全局安裝
npm list <pkg>查看安裝的包的版本信息

使用淘寶鏡像
npm install -g cnpm --registry=https://registry.npm.taobao.org

交互式解釋器REPL

終端輸入node進入交互模式，支持多行輸入，自動識別多行語句；
下劃線_變量：獲取上一個表達式的結果；
REPL 命令：

ctrl + c - 退出當前終端。
ctrl + c 按下兩次 - 退出 Node REPL。
ctrl + d - 退出 Node REPL.
向上/向下鍵 - 查看輸入的歷史命令
tab 鍵 - 列出當前命令
.help - 列出使用命令
.break - 退出多行表達式
.clear - 退出多行表達式
.save filename - 保存當前的 Node REPL 會話到指定文件
.load filename - 載入當前 Node REPL 會話的文件內容

EventEmitter

所有產生事件的對象，都是events.EventEmitter的實例
events模塊唯一一個對象：events.EventEmitter
=> 事件觸發與事件監聽器功能的封裝

events.EventEmitter的方法：

on(event,listener) 爲指定事件註冊監聽器，傳入回調函數
once(event,listener) 一次監聽器
addListener(event,listener) 爲指定事件額外添加監聽器，傳入回調函數
removeListener(event,listener) 移除指定監聽器的指定的回調函數
removeAllListener([event]) 移除所有監聽器，或指定事件所有監聽器
setMaxListener(n) 默認10個監聽器
listener(event) 返回指定事件的監聽器數組
emit(event,[arg1],[arg2],[...]) 執行事件的監聽器數組，有註冊返回true，沒false

類方法：

events.EventEmitter.listenerCount(eventName) 事件監聽器數量, 已廢除
events.emitter.listenerCount(eventName) 事件監聽器數量

事件：

newListener 添加時
removeListener 刪除時
error 錯誤時
我們一般要爲會觸發 error 事件的對象設置監聽器，避免遇到錯誤後整個程序崩潰。

繼承：
大多數時候我們不會直接使用 EventEmitter，而是在對象中繼承它

Buffer緩衝區

JS只有字符串數據類型，沒有二進制數據類型
處理TCP流或者文件流，須要二進制數據，所以buffer二進制緩衝區

在v6.0之前創建Buffer對象直接使用new Buffer()構造函數來創建對象實例，
但是Buffer對內存的權限操作相比很大，可以直接捕獲一些敏感信息，
所以在v6.0以後，官方文檔裏面建議使用 Buffer.from() 接口去創建Buffer對象。

Node.js 目前支持的字符編碼包括：

ascii : 僅支持 7 位 ASCII 數據。如果設置去掉高位的話，這種編碼是非常快的。
utf8 : 多字節編碼的 Unicode 字符。許多網頁和其他文檔格式都使用 UTF-8 。
utf16le : 2 或 4 個字節，小字節序編碼的 Unicode 字符。支持代理對（U+10000 至 U+10FFFF）。
ucs2 : utf16le 的別名。
base64 : Base64 編碼。
latin1 : 一種把 Buffer 編碼成一字節編碼的字符串的方式。
binary : latin1 的別名。
hex : 將每個字節編碼爲兩個十六進制字符

創建Buffer類
var buf = null

Buffer.alloc(size[, fill[, encoding]])：返回一個指定大小的 Buffer 實例，如果沒有設置 fill，則默認填滿 0
Buffer.allocUnsafe(size)：返回一個指定大小的 Buffer 實例，但是它不會被初始化，所以它可能包含敏感的數據
`Buffer.allocUnsafeSlow(size)
Buffer.from(array)：返回一個被 array 的值初始化的新的 Buffer 實例（傳入的 array 的元素只能是數字，不然就會自動被 0 覆蓋）
Buffer.from(arrayBuffer[, byteOffset[, length]])：返回一個新建的與給定的 ArrayBuffer 共享同一內存的 Buffer。
Buffer.from(buffer)：複製傳入的 Buffer 實例的數據，並返回一個新的 Buffer 實例
Buffer.from(string[, encoding])：返回一個被 string 的值初始化的新的 Buffer 實例

寫入緩衝區

buf.write(string[, offset[, length]][, encoding]) (字符串，開始的索引默認0，長度默認最大，編碼默認urf8)；大小超過的部分不會被接入；返回實際寫入的大小(長度)
buf.writeUIntLE(value, offset, byteLength[, noAssert])
buf.writeUIntBE(value, offset, byteLength[, noAssert])
buf.writeIntLE(value, offset, byteLength[, noAssert])
buf.writeIntBE(value, offset, byteLength[, noAssert])
buf.writeUInt8(value, offset[, noAssert])
buf.writeUInt16LE(value, offset[, noAssert])
buf.writeUInt16BE(value, offset[, noAssert])
buf.writeUInt32LE(value, offset[, noAssert])
buf.writeUInt32BE(value, offset[, noAssert])
buf.writeInt8(value, offset[, noAssert])
buf.writeInt16LE(value, offset[, noAssert])
buf.writeInt16BE(value, offset[, noAssert])
buf.writeInt32LE(value, offset[, noAssert])
buf.writeInt32BE(value, offset[, noAssert])
buf.writeFloatLE(value, offset[, noAssert])
buf.writeFloatBE(value, offset[, noAssert])
buf.writeDoubleLE(value, offset[, noAssert])
buf.writeDoubleBE(value, offset[, noAssert])

讀取

buf.toString([encoding[, start[, end]]]) 默認開始-末尾；返回編碼後的字符串
buf.readUIntLE(offset, byteLength[, noAssert])
buf.readUIntBE(offset, byteLength[, noAssert])
buf.readIntLE(offset, byteLength[, noAssert])
buf.readIntBE(offset, byteLength[, noAssert])
buf.readUInt8(offset[, noAssert])
buf.readUInt16LE(offset[, noAssert])
buf.readUInt16BE(offset[, noAssert])
buf.readUInt32LE(offset[, noAssert])
buf.readUInt32BE(offset[, noAssert])
buf.readInt8(offset[, noAssert])
buf.readInt16LE(offset[, noAssert])
buf.readInt16BE(offset[, noAssert])
buf.readInt32LE(offset[, noAssert])
buf.readInt32BE(offset[, noAssert])
buf.readFloatLE(offset[, noAssert])
buf.readFloatBE(offset[, noAssert])
buf.readDoubleLE(offset[, noAssert])
buf.readDoubleBE(offset[, noAssert])
buf[index] 獲取或設置指定字節

轉爲JSON

buf.toJSON() 當字符串化一個 Buffer 實例時，JSON.stringify(buf) 會隱式地調用該 toJSON()。

緩衝區合併

Buffer.concat(list[, totalLength]) (buf數組，指定總長度)

比較

buf.compare(otherBuffer) 和另一個buf對象比較，返回0爲相同，<0爲之前，>0爲之後
buf.equals(otherBuffer) 是否相等

拷貝插入

buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]]) 將target插入覆蓋替換掉指定位置，（插入的buf，插入點，插入後保留開始點，結尾點）

裁剪

buf.slice([start[, end]]) 返回淺拷貝的指定裁剪段

緩衝區長度

buf.length

填充

buf.fill(value[, offset][, end]) 可重複填充，覆蓋替換指定位置

stream流

四種流類型： Readable（可讀操作）、 Writable（可寫操作）、 Duplex（可讀可寫操作）、 Transform（操作被寫入數據，然後讀出結果）。
所有的 Stream 對象都是 EventEmitter 的實例；
常用的事件有：data（當有數據可讀時觸發）、end（沒有更多的數據可讀時觸發）、error（在接收和寫入過程中發生錯誤時觸發）、finish（所有數據已被寫入到底層系統時觸發）。

讀取流

    var fs = require("fs");
    var data = "";
    //創建流
    var readerStream = fs.createReadStream("<file.txt>");
    //設置編碼
    readerStream.setEncoding("UTF8");
    //處理事件流 ==> data,end,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 = "寫入的內容";
    //創建流
    var writerStream = fs.createWritetream("<file.txt>");
    //寫入，編碼
    writerStream.write(data,"UTF8");
    //標記文件末尾
    writerStream.end();

    //處理事件流 ==> finish,error
    writerStream.on("finish",function(chunk){
        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");

readerStream.pipe(writerStream)

鏈式流
用於管道操作；

示例：壓縮和加壓文件

var fs = require("fs")
var zlib = require("zlib")
//讀取，壓縮，寫入
fs.createReadStream("input.txt")
    .pipe(zlib.createGzip())
    .pipe(fs.createWriteStream("input.txt.gz"));
//讀取，解壓，寫入
fs.createReadStream("input.txt.gz")
    .pipe(zlib.createGunzip())
    .pipe(fs.createWriteStream("input.txt"))

模塊系統

一個 Node.js 文件就是一個模塊，這個文件可能是JavaScript 代碼、JSON 或者編譯過的C/C++ 擴展。
exports公開模塊，require引入模塊

//hello.js
exports.yo = function(){
    console.log("hello world ~ !");
}
//main.js
var hello = require("./hello.js");
hello.yo();

module.exports = name 代替 exports.name ，輸出的是對象，而不是exports；
如果要對外暴露屬性或方法，就用exports就行，要暴露對象(類似class，包含了很多屬性和方法)，就用module.exports。

//hello.js
function yo(){
    var name;
    this.setName = function(thyName){
        name = thyName;
    },
    this.sayHello = function(){
        console.log("hello" + name)
    }
}
module.exports = yo;
//main.js
var Hello = require("./hello.js")
hello = new Hello();
hello.setName("yoho");
hello.sayName();//yoho

模塊優先級：
文件模塊緩存 > 原生模塊 > 文件加載

require方法接受以下幾種參數的傳遞：

http、fs、path等，原生模塊。
./mod或…/mod，相對路徑的文件模塊。
/pathtomodule/mod，絕對路徑的文件模塊。
mod，非原生模塊的文件模塊。

NodeJS函數

傳參可以是函數本身，函數使用另一個函數，甚至是匿名函數；

路由

獲取url路徑，對不同路由做出不同處理函數，封裝模塊

//server.js
var http = require("http")
var url = require("url")
function start(route){
    function onRequest(req,res){
        var pathname = url.parse(req.url).pathname;
        console.log("pathname:" + pathname)

        route(pathname)

        res.writeHead(200,{"Content-Type":"text/plain"})
        res.write("Hello World")
        res.end()
    }

    http.createRequest(onRequest).listen(8888)
    console.log("Server has started.")
}

exports.start = start;

//router.js
function route(pathname){
    console.log("this is a route : " + pathname)
}
exports.route = route

//index.js
var server = require("./server")
var router = require("./router")

server.start(router.route)

全局對象

瀏覽器JavaScript中是window，node的JavaScript中是global；所有的全局變量都是global的屬性；
不用var定義變量以避免引入全局變量，因爲全局變量會污染命名空間，提高代碼的耦合風險

__filename 當前執行的腳本文件名
__dirname 當前執行的腳本所在目錄
setTimeout(cb,ms) 在指定毫秒(ms)後執行函數(cb)，只執行一次
clearTimeout(t) 停止指定計時器(t)
setInterval(cb,ms) 在指定毫秒(ms)循環執行函數(cb)
clearInterval(t) 清除定時器(t)
console 向標準輸出流或標準錯誤流輸出字符

console.log([data][,...]) 只有一個參數，則輸出這個參數的字符串形式。如果有多個參數，則以類似於C 語言 printf() 命令的格式輸出。
console.info([data][, ...])、console.error([data][, ...])、console.warn([data][, ...])；
console.dir(obj[, options]) 對一個對象進行檢查inspect；
console.time(label)、console.timeEnd(label) 計時開始時間/結束時間；
console.trace(message[, ...]) 當前代碼在堆棧中的調用地址；
console.assert(value[, message][, ...]) 判斷是否爲真，false輸出message；

process 進程狀態

– 事件：
exit 進程退出時觸發；
beforeExit node清空事件循環，且沒其他安排；異步調用；
uncaughtException 異常冒泡回到事件循環觸發；如果給異常添加了監視器，默認的操作（打印堆棧跟蹤信息並退出）就不會發生。
signal 進程接收到信號觸發

process.on("exit" ,function(){
    ...
})

– 退出狀態碼

– 屬性
stdout 標準輸出流
stderr 標準錯誤流
stdin 標準輸入流
argv 執行腳本時的各種參數
execPath 當前腳本的二進制文件絕對路徑
execArgv 執行腳本的命令行參數
env 當前shell的環境變量
exitCode 進程退出時的代碼，如果進程優通過process.exit()退出，不需要指定退出碼。
version node版本
versions node版本和依賴
config 編譯node的執行配置
pid 進程號
title 進程名，默認node
arch 當前CPU架構
platform 當前平臺系統
mainModule require.main 的備選方法

– 方法
abort() 中斷
chdir(directory) 改變當前進程的目錄
cwd() 返回當前的工作目錄
exit([code]) 結束進程
kill(pid[,signal]) 發送信號給進程
memoryUsage() 返回進程所用的內存狀況
nextTick(callback) 當前事件結束，馬上調用回調
umask([mask]) 設置或讀取進程的掩碼
uptime() 返回node已運行秒數
hrtime() 返回當前進程的高分辨時間，通過精確的時間間隔，衡量程序的性能
//以下僅在POSIX平臺上可用
getgid() 獲取進程的羣組標識
setgid(id) 設置進程的羣組標識
getuid() 獲取進程的用戶標識
setuid(id) 設置進程的用戶標識
getgroups() 返回進程的羣組ID數組
setgroups(groups) 設置進程的羣組ID
initgroups(user,extra_group) 讀取/etc/group，並初始化訪問列表

常用工具

util.inherits(constructor,superConstructor) 對象間的繼承

JavaScript 沒有提供對象繼承的語言級別特性，而是通過原型複製來實現的。
util.inspect(object,[showHidden],[depth],[colors]) 任意對象轉換爲字符串，用於調試和錯誤輸出，(obj，是否顯示更多隱藏信息，遞歸層數，是否ANSI顏色編碼)

util.isArray(object) 返回是否爲數組
util.isRegExp(obj) 返回是否爲正則表達式
util.isData(obj) 返回是否爲日期
util.isError(obj) 返回是否爲錯誤對象

文件系統

Node.js 提供一組類似 UNIX（POSIX）標準的文件操作API，引入fs模塊，均有異步和同步版本

打開文件
fs.open(path,flags[,mode],callback) ：
path：文件路徑
flags：r讀、r+讀，可寫、rs同步讀、rs+同步讀，可寫、w寫，不存在就創建、w+寫，可讀，不存在就創建、wx寫，已存在就報錯、wx+寫，可讀，已存在就報錯、a追加，不存在就創建、a+追加，可讀可寫，不存在就創建、ax追加，已存在就報錯、ax+追加，可讀可寫，已存在就報錯
mode：設置文件模式(權限)，文件創建默認權限爲0666(讀寫)
callback(err,fd)：回調函數
讀取文件信息
fs.stat(path,callback)：
callback(err,stats)：stats是fs.Stats對象，判斷文件的相關屬性，例如stats.isFile()；

stats中的方法：
stats.isFile() 是否爲文件
stats.isDirectory() 是否爲目錄
stats.isBlockDevice() 是否爲塊設備
stats.isCharacterDevice() 是否爲字符設備
stats.isSymbolicLink() 是否爲軟連接
stats.isFIFO() 是否爲FIFO（UNIX中的命令管道）
stats.isSocket() 是否爲Socket

讀取文件
fs.read(fd,buffer,offset,length,position,callback)：
fs：fs.open()返回的文件描述符
buffer：寫入的緩衝區
offset：緩衝區寫入的偏移量
length：讀取的字節數
position：讀取的起始位置
callback(err,bytesRead,buffer)：
寫入文件
fs.writeFile(file,data[,options],callback)：默認w模式打開，所以寫入會覆蓋原內容
file：文件名或文件描述符
data：寫入的數據，字符串或緩衝區對象
options：{encoding,mode,flag}，默認{utf8,0666,w}
callback(err)：失敗時返回
關閉文件
fs.close(fd,callback)：通過fs.open回調中的文件描述符fd關閉文件
截取文件
fs.ftruncate(fd,len,callback)：異步模式下通過fs.open回調中的文件描述符fd截取文件
刪除文件
fs.unlink(path,callback)：回調沒有傳參
創建目錄
fs.mkdir(path[,options],callback)：
path：文件路徑
options：{recursive，mode}，{是否遞歸方式創建，權限}，默認{false,0777}
callback：回調沒有傳承
讀取目錄
fs.readdir(path,callback)：
path：路徑
callback(err,files)：files爲目錄下文件數組列表
刪除目錄
fs.rmdir(path,callback)

GET/POST請求

獲取GET請求內容

var http = require("http")
var url = require("url")
var util = require("util")

http.createServer(function(req,res){
    res.writHead(200,{"Content-Type":"text/plain;charset=utf-8"});
    res.end(util.inspect(url.parse(req.url,true)));
}).listen(3000);

獲取URL的參數

//訪問https://www.xxx.com:8080?name=xxx&url=www.xxx.com
var http = require("http")
var url = require("url")

http.createServer(function(req,res){
    res.writeHead(200,{"Content-Type":"text/plain"})
    //解析URL參數
    var params = url.parse(req.url,true).query
    res.write("網絡名："+ params.name);
    res.write("\n")
    res.write("網站URL：" + params.url )
    res.end()
}).listen(3000)

獲取POST請求內容
node.js 默認是不會解析請求體的，當你需要的時候，需要手動來做。

var http = require("http")
var querystring = require("querystring")
var util = require("util")

http.createServer(function(req,res){
    //存儲請求體的變量
    var post = "";
    //監聽，每次請求體的數據，累加的post中
    req.on("data",function(chunk){
        post += chunk
    })
    //end觸發後，解析後返回客戶端
    req.on("end",function(){
        post = querystring.parse(post);
        res.end(util.inspect(post));
    })
}).listen(3000)

Web模塊

目前最主流的三個Web服務器是Apache、Nginx、IIS。

搭建服務器

var http = require("http")
var fs = require("fs")
var url = require("url")

http.createServer(function(req,res){
  var pathname = url.parse(req.url).pathname;
  console.log("pathname: "+ pathname)
  fs.readFile(pathname.substr(1),function(err,data){
    if(err){
      console.log(err)
      res.writeHead(404,{"Content-Type":"text/html"})
    }else{
      res.writeHead(200,{"Content-Type":"text/html"})
      res.write(data.toString())
    }
    res.end()
  })
}).listen(8080);
console.log("Server running at http://localhost:8080/")

服務器文件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <h1>Hello World</h1>
    <p>yo yo qie ke nao ,you say yes  i say no ~</p>
</body>
</html>

web客戶端node程序，獲取文件

var http = require("http")
var options = {
    host:"localhost",
    port:"8080",
    path:"/index.html"
}

var callback = function (res){
    var body = ""
    res.on("data",function(data){
        body += data;
    })
    res.on("end",function(){
        console.log(body)
    })
}

var req = http.request(options,callback);
req.end();

Express框架
安裝：npm i express --sava，
重要模塊：body-parser，cookie-paser，multer
npm i body-parser --save
npm i cookie-parser --save
npm i multer --save
EXPRESS–菜鳥教程

RESTful API
REST即表述性狀態傳遞（英文：Representational State Transfer，簡稱REST），一組架構約束條件和原則，是設計風格而不是標準。REST 通常使用 JSON 數據格式。
基於REST架構的Web Services即是RESTful。

多進程
node.js是單線程，多個子進程，提高性能。使用child_process模塊-
child_process.exec(command[, options], callback)
child_process.spawn(command[, args][, options])
child_process.fork(modulePath[, args][, options])

JXcore打包
MySQL
MongoDB

工具模塊

OS模塊

方法

os.empdir() 操作系統的臨時文件夾
os.endianness() CPU字節序，“BE”或"LE"
os.hostname() 操作系統的主機名
os.type() 操作系統名
os.platform() 編譯時的操作系統名
os.arch() CPU架構，“x64”、“arm”、“ia32”
os.release() 操作系統的發行版本
os.uptime 操作系統運行的時間
os.loadavg() 1，5，15分鐘平均負載的數組
os.totalmm() 系統內存總量
os.freemem() 空閒內存總量
os.cpus() CPU/內核的信息的數組
os.networkInterfaces() 網絡接口列表

屬性

os.EOL 定義操作系統的行尾符的常量

Path模塊

方法：

path.normalize(p) 規範化路徑
path.join([path1][,path2][,...]) 連接路徑，Unix系統是"/"，Windows系統是""
path.resolve([form...],to) 將to參數解析爲絕對路徑
path.isAbsolute(path) 是否爲絕對路徑
path.relative(from,to) 將to參數的絕對路徑轉換爲相對路徑，
path.dirname(p) 返回路徑p中，代表文件夾的部分
path.basename(p[,ext]) 返回路徑p中的最後一部分
path.extname(p) 返回路徑p中的文件後綴名，沒有返回空
path.parse(pathString) 返回路徑字符串的對象
path.format(pathObj) 返回對象中路徑字符串，和path.parse()相反

屬性

path.sep 文件路徑分隔符，\\或/
path.delimiter 分隔符，;或:
path.posix 以 posix 兼容的方式交互
path.win32 以 win32 兼容的方式交互

Net模塊
DNS模塊
Domain看模塊

文件系統方法參考手冊

fs.rename(oldPath, newPath, callback)
異步 rename().回調函數沒有參數，但可能拋出異常。
fs.ftruncate(fd, len, callback)
異步 ftruncate().回調函數沒有參數，但可能拋出異常。
fs.ftruncateSync(fd, len)
同步 ftruncate()
fs.truncate(path, len, callback)
異步 truncate().回調函數沒有參數，但可能拋出異常。
fs.truncateSync(path, len)
同步 truncate()
fs.chown(path, uid, gid, callback)
異步 chown().回調函數沒有參數，但可能拋出異常。
fs.chownSync(path, uid, gid)
同步 chown()
fs.fchown(fd, uid, gid, callback)
異步 fchown().回調函數沒有參數，但可能拋出異常。
fs.fchownSync(fd, uid, gid)
同步 fchown()
fs.lchown(path, uid, gid, callback)
異步 lchown().回調函數沒有參數，但可能拋出異常。
fs.lchownSync(path, uid, gid)
同步 lchown()
fs.chmod(path, mode, callback)
異步 chmod().回調函數沒有參數，但可能拋出異常。
fs.chmodSync(path, mode)
同步 chmod().
fs.fchmod(fd, mode, callback)
異步 fchmod().回調函數沒有參數，但可能拋出異常。
fs.fchmodSync(fd, mode)
同步 fchmod().
fs.lchmod(path, mode, callback)
異步 lchmod().回調函數沒有參數，但可能拋出異常。Only available on Mac OS X.
fs.lchmodSync(path, mode)
同步 lchmod().
fs.stat(path, callback)
異步 stat(). 回調函數有兩個參數 err, stats，stats 是 fs.Stats 對象。
fs.lstat(path, callback)
異步 lstat(). 回調函數有兩個參數 err, stats，stats 是 fs.Stats 對象。
fs.fstat(fd, callback)
異步 fstat(). 回調函數有兩個參數 err, stats，stats 是 fs.Stats 對象。
fs.statSync(path)
同步 stat(). 返回 fs.Stats 的實例。
fs.lstatSync(path)
同步 lstat(). 返回 fs.Stats 的實例。
fs.fstatSync(fd)
同步 fstat(). 返回 fs.Stats 的實例。
fs.link(srcpath, dstpath, callback)
異步 link().回調函數沒有參數，但可能拋出異常。
fs.linkSync(srcpath, dstpath)
同步 link().
fs.symlink(srcpath, dstpath[, type], callback)
異步 symlink().回調函數沒有參數，但可能拋出異常。 type 參數可以設置爲 ‘dir’, ‘file’, 或 ‘junction’ (默認爲 ‘file’) 。
fs.symlinkSync(srcpath, dstpath[, type])
同步 symlink().
fs.readlink(path, callback)
異步 readlink(). 回調函數有兩個參數 err, linkString。
fs.realpath(path[, cache], callback)
異步 realpath(). 回調函數有兩個參數 err, resolvedPath。
fs.realpathSync(path[, cache])
同步 realpath()。返回絕對路徑。
fs.unlink(path, callback)
異步 unlink().回調函數沒有參數，但可能拋出異常。
fs.unlinkSync(path)
同步 unlink().
fs.rmdir(path, callback)
異步 rmdir().回調函數沒有參數，但可能拋出異常。
fs.rmdirSync(path)
同步 rmdir().
fs.mkdir(path[, mode], callback)
S異步 mkdir(2).回調函數沒有參數，但可能拋出異常。訪問權限默認爲 0777。
fs.mkdirSync(path[, mode])
同步 mkdir().
fs.readdir(path, callback)
異步 readdir(3). 讀取目錄的內容。
fs.readdirSync(path)
同步 readdir().返回文件數組列表。
fs.close(fd, callback)
異步 close().回調函數沒有參數，但可能拋出異常。
fs.closeSync(fd)
同步 close().
fs.open(path, flags[, mode], callback)
異步打開文件。
fs.openSync(path, flags[, mode])
同步 version of fs.open()。
fs.utimes(path, atime, mtime, callback)
fs.utimesSync(path, atime, mtime)
修改文件時間戳，文件通過指定的文件路徑。
fs.futimes(fd, atime, mtime, callback)
fs.futimesSync(fd, atime, mtime)
修改文件時間戳，通過文件描述符指定。
fs.fsync(fd, callback)
異步 fsync.回調函數沒有參數，但可能拋出異常。
fs.fsyncSync(fd)
同步 fsync.
fs.write(fd, buffer, offset, length[, position], callback)
將緩衝區內容寫入到通過文件描述符指定的文件。
fs.write(fd, data[, position[, encoding]], callback)
通過文件描述符 fd 寫入文件內容。
fs.writeSync(fd, buffer, offset, length[, position])
同步版的 fs.write()。
fs.writeSync(fd, data[, position[, encoding]])
同步版的 fs.write()。
fs.read(fd, buffer, offset, length, position, callback)
通過文件描述符 fd 讀取文件內容。
fs.readSync(fd, buffer, offset, length, position)
同步版的 fs.read。
fs.readFile(filename[, options], callback)
異步讀取文件內容。
fs.readFileSync(filename[, options])
fs.writeFile(filename, data[, options], callback)
異步寫入文件內容。
fs.writeFileSync(filename, data[, options])
同步版的 fs.writeFile。
fs.appendFile(filename, data[, options], callback)
異步追加文件內容。
fs.appendFileSync(filename, data[, options])
The 同步 version of fs.appendFile。
fs.watchFile(filename[, options], listener)
查看文件的修改。
fs.unwatchFile(filename[, listener])
停止查看 filename 的修改。
fs.watch(filename[, options][, listener])
查看 filename 的修改，filename 可以是文件或目錄。返回 fs.FSWatcher對象。
fs.exists(path, callback)
檢測給定的路徑是否存在。
fs.existsSync(path)
同步版的 fs.exists。
fs.access(path[, mode], callback)
測試指定路徑用戶權限。
fs.accessSync(path[, mode])
同步版的 fs.access。
fs.createReadStream(path[, options])
返回ReadStream 對象。
fs.createWriteStream(path[, options])
返回 WriteStream 對象。
fs.symlink(srcpath, dstpath[, type], callback)
異步 symlink().回調函數沒有參數，但可能拋出異常。

node.js基礎知識