node.js基础知识

了解

常用的属性和方法
命令行输入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看模块

文件系统 方法参考手册

1. fs.rename(oldPath, newPath, callback)
   异步 rename().回调函数没有参数，但可能抛出异常。
2. fs.ftruncate(fd, len, callback)
   异步 ftruncate().回调函数没有参数，但可能抛出异常。
3. fs.ftruncateSync(fd, len)
   同步 ftruncate()
4. fs.truncate(path, len, callback)
   异步 truncate().回调函数没有参数，但可能抛出异常。
5. fs.truncateSync(path, len)
   同步 truncate()
6. fs.chown(path, uid, gid, callback)
   异步 chown().回调函数没有参数，但可能抛出异常。
7. fs.chownSync(path, uid, gid)
   同步 chown()
8. fs.fchown(fd, uid, gid, callback)
   异步 fchown().回调函数没有参数，但可能抛出异常。
9. fs.fchownSync(fd, uid, gid)
   同步 fchown()
10. fs.lchown(path, uid, gid, callback)
    异步 lchown().回调函数没有参数，但可能抛出异常。
11. fs.lchownSync(path, uid, gid)
    同步 lchown()
12. fs.chmod(path, mode, callback)
    异步 chmod().回调函数没有参数，但可能抛出异常。
13. fs.chmodSync(path, mode)
    同步 chmod().
14. fs.fchmod(fd, mode, callback)
    异步 fchmod().回调函数没有参数，但可能抛出异常。
15. fs.fchmodSync(fd, mode)
    同步 fchmod().
16. fs.lchmod(path, mode, callback)
    异步 lchmod().回调函数没有参数，但可能抛出异常。Only available on Mac OS X.
17. fs.lchmodSync(path, mode)
    同步 lchmod().
18. fs.stat(path, callback)
    异步 stat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。
19. fs.lstat(path, callback)
    异步 lstat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。
20. fs.fstat(fd, callback)
    异步 fstat(). 回调函数有两个参数 err, stats，stats 是 fs.Stats 对象。
21. fs.statSync(path)
    同步 stat(). 返回 fs.Stats 的实例。
22. fs.lstatSync(path)
    同步 lstat(). 返回 fs.Stats 的实例。
23. fs.fstatSync(fd)
    同步 fstat(). 返回 fs.Stats 的实例。
24. fs.link(srcpath, dstpath, callback)
    异步 link().回调函数没有参数，但可能抛出异常。
25. fs.linkSync(srcpath, dstpath)
    同步 link().
26. fs.symlink(srcpath, dstpath[, type], callback)
    异步 symlink().回调函数没有参数，但可能抛出异常。 type 参数可以设置为 ‘dir’, ‘file’, 或 ‘junction’ (默认为 ‘file’) 。
27. fs.symlinkSync(srcpath, dstpath[, type])
    同步 symlink().
28. fs.readlink(path, callback)
    异步 readlink(). 回调函数有两个参数 err, linkString。
29. fs.realpath(path[, cache], callback)
    异步 realpath(). 回调函数有两个参数 err, resolvedPath。
30. fs.realpathSync(path[, cache])
    同步 realpath()。返回绝对路径。
31. fs.unlink(path, callback)
    异步 unlink().回调函数没有参数，但可能抛出异常。
32. fs.unlinkSync(path)
    同步 unlink().
33. fs.rmdir(path, callback)
    异步 rmdir().回调函数没有参数，但可能抛出异常。
34. fs.rmdirSync(path)
    同步 rmdir().
35. fs.mkdir(path[, mode], callback)
    S异步 mkdir(2).回调函数没有参数，但可能抛出异常。 访问权限默认为 0777。
36. fs.mkdirSync(path[, mode])
    同步 mkdir().
37. fs.readdir(path, callback)
    异步 readdir(3). 读取目录的内容。
38. fs.readdirSync(path)
    同步 readdir().返回文件数组列表。
39. fs.close(fd, callback)
    异步 close().回调函数没有参数，但可能抛出异常。
40. fs.closeSync(fd)
    同步 close().
41. fs.open(path, flags[, mode], callback)
    异步打开文件。
42. fs.openSync(path, flags[, mode])
    同步 version of fs.open()。
43. fs.utimes(path, atime, mtime, callback)
44. fs.utimesSync(path, atime, mtime)
    修改文件时间戳，文件通过指定的文件路径。
45. fs.futimes(fd, atime, mtime, callback)
46. fs.futimesSync(fd, atime, mtime)
    修改文件时间戳，通过文件描述符指定。
47. fs.fsync(fd, callback)
    异步 fsync.回调函数没有参数，但可能抛出异常。
48. fs.fsyncSync(fd)
    同步 fsync.
49. fs.write(fd, buffer, offset, length[, position], callback)
    将缓冲区内容写入到通过文件描述符指定的文件。
50. fs.write(fd, data[, position[, encoding]], callback)
    通过文件描述符 fd 写入文件内容。
51. fs.writeSync(fd, buffer, offset, length[, position])
    同步版的 fs.write()。
52. fs.writeSync(fd, data[, position[, encoding]])
    同步版的 fs.write()。
53. fs.read(fd, buffer, offset, length, position, callback)
    通过文件描述符 fd 读取文件内容。
54. fs.readSync(fd, buffer, offset, length, position)
    同步版的 fs.read。
55. fs.readFile(filename[, options], callback)
    异步读取文件内容。
56. fs.readFileSync(filename[, options])
57. fs.writeFile(filename, data[, options], callback)
    异步写入文件内容。
58. fs.writeFileSync(filename, data[, options])
    同步版的 fs.writeFile。
59. fs.appendFile(filename, data[, options], callback)
    异步追加文件内容。
60. fs.appendFileSync(filename, data[, options])
    The 同步 version of fs.appendFile。
61. fs.watchFile(filename[, options], listener)
    查看文件的修改。
62. fs.unwatchFile(filename[, listener])
    停止查看 filename 的修改。
63. fs.watch(filename[, options][, listener])
    查看 filename 的修改，filename 可以是文件或目录。返回 fs.FSWatcher对象。
64. fs.exists(path, callback)
    检测给定的路径是否存在。
65. fs.existsSync(path)
    同步版的 fs.exists。
66. fs.access(path[, mode], callback)
    测试指定路径用户权限。
67. fs.accessSync(path[, mode])
    同步版的 fs.access。
68. fs.createReadStream(path[, options])
    返回ReadStream 对象。
69. fs.createWriteStream(path[, options])
    返回 WriteStream 对象。
70. fs.symlink(srcpath, dstpath[, type], callback)
    异步 symlink().回调函数没有参数，但可能抛出异常。