NodeJs 的fs模块

fs是filesystem的缩写，该模块提供本地文件的读写能力，基本上是POSIX文件操作命令的简单包装

readFile()，readFileSync()

readFile方法用于异步读取数据

fs.readFile('./image.png', function (err, buffer) {
  if (err) throw err;
  process(buffer);
});

readFile方法的第一个参数是文件的路径，可以是绝对路径，也可以是相对路径。注意，如果是相对路径，是相对于当前进程所在的路径（process.cwd()），而不是相对于当前脚本所在的路径。

readFile方法的第二个参数是读取完成后的回调函数。该函数的第一个参数是发生错误时的错误对象，第二个参数是代表文件内容的Buffer实例。

readFileSync方法用于同步读取文件，返回一个字符串。

var text = fs.readFileSync(fileName, 'utf8');
 
// 将文件按行拆成数组
text.split(/\r?\n/).forEach(function (line) {
  // ...
});

readFileSync方法的第一个参数是文件路径，第二个参数可以是一个表示配置的对象，也可以是一个表示文本文件编码的字符串。默认的配置对象是{ encoding: null, flag: ‘r’ }，即文件编码默认为null，读取模式默认为r（只读）。如果第二个参数不指定编码（encoding），readFileSync方法返回一个Buffer实例，否则返回的是一个字符串。

writeFile()，writeFileSync()

writeFile方法用于异步写入文件

fs.writeFile('message.txt', 'Hello Node.js', (err) => {
  if (err) throw err;
  console.log('It\'s saved!');
});

上面代码中，writeFile方法的第一个参数是写入的文件名，第二个参数是写入的字符串，第三个参数是回调函数。

回调函数前面，还可以再加一个参数，表示写入字符串的编码（默认是utf8）。

fs.writeFile('message.txt', 'Hello Node.js', 'utf8', callback);

writeFileSync方法用于同步写入文件

fs.writeFileSync(fileName, str, 'utf8');

它的第一个参数是文件路径，第二个参数是写入文件的字符串，第三个参数是文件编码，默认为utf8。

exists(path, callback)

exists方法用来判断给定路径是否存在，然后不管结果如何，都会调用回调函数。

fs.exists('/path/to/file', function (exists) {
  util.debug(exists ? "it's there" : "no file!");
});

上面代码表明，回调函数的参数是一个表示文件是否存在的布尔值。

需要注意的是，不要在open方法之前调用exists方法，open方法本身就能检查文件是否存在。

下面的例子是如果给定目录存在，就删除它。

if (fs.existsSync(outputFolder)) {
  console.log('Removing ' + outputFolder);
  fs.rmdirSync(outputFolder);
}

mkdir()，writeFile()，readFile()

mkdir方法用于新建目录。

var fs = require('fs');
 
fs.mkdir('./helloDir',0777, function (err) {
  if (err) throw err;
});

mkdir接受三个参数，第一个是目录名，第二个是权限值，第三个是回调函数。

writeFile方法用于写入文件。

var fs = require('fs');
 
fs.writeFile('./helloDir/message.txt', 'Hello Node', function (err) {
  if (err) throw err;
  console.log('文件写入成功');
});

readFile方法用于读取文件内容。

var fs = require('fs');
 
fs.readFile('./helloDir/message.txt','UTF-8' ,function (err, data) {
  if (err) throw err;
  console.log(data);
});

上面代码使用readFile方法读取文件。readFile方法的第一个参数是文件名，第二个参数是文件编码，第三个参数是回调函数。可用的文件编码包括“ascii”、“utf8”和“base64”。如果没有指定文件编码，返回的是原始的缓存二进制数据，这时需要调用buffer对象的toString方法，将其转为字符串。

var fs = require('fs');
fs.readFile('example_log.txt', function (err, logData) {
  if (err) throw err;
  var text = logData.toString();
});

readFile方法是异步操作，所以必须小心，不要同时发起多个readFile请求。

for(var i = 1; i <= 1000; i++) {
  fs.readFile('./'+i+'.txt', function() {
     // do something with the file
  });
}

上面代码会同时发起1000个readFile异步请求，很快就会耗尽系统资源。

mkdirSync()，writeFileSync()，readFileSync()

这三个方法是建立目录、写入文件、读取文件的同步版本。

fs.mkdirSync('./helloDirSync',0777);
fs.writeFileSync('./helloDirSync/message.txt', 'Hello Node');
var data = fs.readFileSync('./helloDirSync/message.txt','UTF-8');
console.log('file created with contents:');
console.log(data);

对于流量较大的服务器，最好还是采用异步操作，因为同步操作时，只有前一个操作结束，才会开始后一个操作，如果某个操作特别耗时（常常发生在读写数据时），会导致整个程序停顿。

readdir()，readdirSync()

readdir方法用于读取目录，返回一个所包含的文件和子目录的数组。

fs.readdir(process.cwd(), function (err, files) {
  if (err) {
    console.log(err);
    return;
  }
 
  var count = files.length;
  var results = {};
  files.forEach(function (filename) {
    fs.readFile(filename, function (data) {
      results[filename] = data;
      count--;
      if (count <= 0) {
        // 对所有文件进行处理
      }
    });
  });
});

readdirSync方法是readdir方法的同步版本。下面是同步列出目录内容的代码。

var files = fs.readdirSync(dir);
files.forEach(function (filename) {
  var fullname = path.join(dir,filename);
  var stats = fs.statSync(fullname);
  if (stats.isDirectory()) filename += '/';
  process.stdout.write(filename + '\t' +
    stats.size + '\t' +
    stats.mtime + '\n'
  );
});

stat()

stat方法的参数是一个文件或目录，它产生一个对象，该对象包含了该文件或目录的具体信息。我们往往通过该方法，判断正在处理的到底是一个文件，还是一个目录。

var fs = require('fs');
 
fs.readdir('/etc/', function (err, files) {
  if (err) throw err;
 
  files.forEach( function (file) {
    fs.stat('/etc/' + file, function (err, stats) {
      if (err) throw err;
 
      if (stats.isFile()) {
        console.log("%s is file", file);
      }
      else if (stats.isDirectory ()) {
      console.log("%s is a directory", file);
      }
    console.log('stats:  %s',JSON.stringify(stats));
    });
  });
});

watchfile()，unwatchfile()

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

var fs = require('fs');
 
fs.watchFile('./testFile.txt', function (curr, prev) {
  console.log('the current mtime is: ' + curr.mtime);
  console.log('the previous mtime was: ' + prev.mtime);
});
 
fs.writeFile('./testFile.txt', "changed", function (err) {
  if (err) throw err;
 
  console.log("file write complete");   
});

unwatchfile方法用于解除对文件的监听。

createReadStream()

createReadStream方法往往用于打开大型的文本文件，创建一个读取操作的数据流。所谓大型文本文件，指的是文本文件的体积很大，读取操作的缓存装不下，只能分成几次发送，每次发送会触发一个data事件，发送结束会触发end事件。

var fs = require('fs');
 
function readLines(input, func) {
  var remaining = '';
 
  input.on('data', function(data) {
    remaining += data;
    var index = remaining.indexOf('\n');
    var last  = 0;
    while (index > -1) {
      var line = remaining.substring(last, index);
      last = index + 1;
      func(line);
      index = remaining.indexOf('\n', last);
    }
 
    remaining = remaining.substring(last);
  });
 
  input.on('end', function() {
    if (remaining.length > 0) {
      func(remaining);
    }
  });
}
 
function func(data) {
  console.log('Line: ' + data);
}
 
var input = fs.createReadStream('lines.txt');
readLines(input, func);

createWriteStream()

createWriteStream方法创建一个写入数据流对象，该对象的write方法用于写入数据，end方法用于结束写入操作。

var out = fs.createWriteStream(fileName, {
  encoding: 'utf8'
});
out.write(str);
out.end();

createWriteStream方法和createReadStream方法配合，可以实现拷贝大型文件。

function fileCopy(filename1, filename2, done) {
  var input = fs.createReadStream(filename1);
  var output = fs.createWriteStream(filename2);
 
  input.on('data', function(d) { output.write(d); });
  input.on('error', function(err) { throw err; });
  input.on('end', function() {
    output.end();
    if (done) done();
  });
}

NodeJs 里面的fs模块

Node.js 提供一组类似 UNIX（POSIX）标准的文件操作API。 Node 导入文件系统模块(fs)语法如下所示：

var fs = require("fs")

对文件的操作

文件读取

Node.js 文件系统（fs 模块）模块中的方法均有异步和同步版本，例如读取文件内容的函数有异步的 fs.readFile() 和同步的 fs.readFileSync()。

异步的方法函数最后一个参数为回调函数，回调函数的第一个参数包含了错误信息(error)。

建议使用异步方法，比起同步，异步方法性能更高，速度更快，而且没有阻塞。

同步

//同步 所有同步的函数都是函数后面加Sync；
 var res = fs.writeFileSync("1.txt","我是写入内容");

异步

//文件的读取
fs.readFile("1.txt",function (err,data) {
     if (err){
        console.log(err)
     }else {
         console.log(data.toString())
     }
 })

文件写入

//创建： writeFile(文件名，写入内容，配置参数，回调函数) 异步
//配置参数：
/*
* a ：追加
* w ：写入
* r ：读取
* */
fs.writeFile("2.txt","我是2.txt",{flag:"a"},function (err) {
    if(err){
        console.log(err);
    }else {
        console.log("写入成功");
    }
})
 
// 追加写入
fs.appendFile("2.txt","我是追加的字符",function (err) {
    if(err){
      return  console.log(err);
    }else {
        console.log("追加成功");
    }
})

文件名修改

//文件修改（文件名的修改） 
 fs.rename("5.txt","1.txt",function (err) {
     if(err){
         console.log(err)
     }else {
         console.log("修改成功");
     }
 })

文件名删除

//文件删除
 fs.unlink("2.txt",function (err) {
     if(err){
         return console.log(err)
     }else {
         console.log("删除成功")
     }
 })

对文件夹的操作

文件夹的操作/目录操作

// 目录创建：
// 1、1：执行-x 2、2：写-w 3、4:读-r
fs.mkdir("10",0666,function (err) {
    if(err){
        console.log(err)
    }else {
        console.log("创建成功");
    }
})

判断文件或者文件夹是否存在

fs.exists("10",function (exists) {
    if(exists){
        console.log("文件夹已存在");
    }else {
        fs.mkdir("10",0777,function (err) {
            if(err){
                return console.log(err);
            }else{
                console.log("创建成功");
            }
        })
    }
})

删除文件夹 : 只能删除空文件夹

fs.rmdir("10",function (err) {
    if(err){
        return console.log(err)
    }else {
        console.log("删除成功");
    }
})

读取文件夹

fs.readdir("10",function (err,data) {
    if(err){
        console.log(err);
    }else {
        console.log(data);
    }
})

显示文件的详细信息：

//针对详细信息来判断是否是文件
fs.stat("10",function (err,data) {
    if(err){
       return console.log(err)
    }else {
        // console.log(data);
        //判断是否是文件
        var res = data.isFile();
        //判断是否是文件夹
        // data.isDirectory();
        if(res){
            console.log("是文件")
        }else {
            console.log("是文件夹")
        }
    }
})

由于node.js中没有删除包含文件的文件夹的函数，因此我们仿写一个函数来删除包含文件的文件的函数

// 删除文件夹的函数 同步
var removeDir = function(src) {
   // 获取到文件夹里的内容
   var arr = fs.readdirSync(src);
   //判断是否是文件，如果是文件就删除；如果是文件夹再执行相同过程
    for(var i=0;i<arr.length;i++){
       //子文件的详细信息
       // 组装文件或者文件夹的路径
        var url = src+"/"+arr[i];
        var data = fs.statSync(url);
        //判断每个元素是文件或者是文件夹
        if(data.isFile()){
            //是文件
            fs.unlinkSync(url);
        }else {
            //是文件夹
            removeDir(url)
        }
    }
    //删除空文件夹
    fs.rmdirSync(src);
}

NodeJs 的path模块

获取 /路径/文件名/扩展名

获取路径：path.dirname(filepath)
获取文件名：path.basename(filename)
获取扩展名：path.extname(filepath)

获取所在路径

const path=require("path");
var filepath='/node/base/path/test.js';
console.log(
    path.dirname(filepath)
)
//输出/node/base/path

获取文件名

path.basename(filepath)实际上是获取了路径的最后一部分，
而不是真正的获取到了文件名，但是在实际应用中最后的字符往往就是我们的文件名

const path = require("path");
console.log(path.basename("/node/base/path/test.js"));
//输出    test.js
console.log(path.basename("/node/base/path/test/"));
//输出    test
console.log(path.basename("/node/base/path/test"));
//输出    test

如果只想获取文件名，不需要扩展名则可以使用第二个参数，第二个参数就是指定的文件扩展名

const path = require("path");
console.log(path.basename("/node/base/path/test.js",".js"));
//输出    test

获取文件扩展名

const path = require("path");
console.log(path.extname("/node/base/path/test.js",".js"));
//输出    .js

更详细的规则是如下：（假设 path.basename(filepath) === B ）

从B的最后一个.开始截取，直到最后一个字符。
如果B中不存在.，或者B的第一个字符就是.，那么返回空字符串。

案例

path.extname('index.html')
// Returns: '.html'

path.extname('index.coffee.md')
// Returns: '.md'

path.extname('index.')
// Returns: '.'

path.extname('index')
// Returns: ''

path.extname('.index')
// Returns: ''

文件路径分解/组合

path.join([…paths])
path.resolve([…paths])

path.join([…paths])

接收多个路劲字符串参数，把路径参数拼接起来然后再执行一下normalize

const path=require("path");
path.join("/temp",'node','/js/test.js')
//输出    \temp\node\js\test.js
path.join("/temp",'node','/js/test.js/','..')
//输出    \temp\node\js

path.resolve([…paths])

这个接口的作用就相当于在shell命令下，从左到右运行一遍cd path命令，
最终获取的绝对路径/文件名，就是这个接口所返回的结果了。

var path = require('path');

// 假设当前工作路径是 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path

// 输出 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path
console.log( path.resolve('') )

// 输出 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path
console.log( path.resolve('.') )

// 输出 /foo/bar/baz
console.log( path.resolve('/foo/bar', './baz') );

// 输出 /foo/bar/baz
console.log( path.resolve('/foo/bar', './baz/') );

// 输出 /tmp/file
console.log( path.resolve('/foo/bar', '/tmp/file/') );

// 输出 /Users/a/Documents/git-code/nodejs-learning-guide/examples/2016.11.08-node-path/www/js/mod.js
console.log( path.resolve('www', 'js/upload', '../mod.js') );

路径解析

path.normalize(filepath)

如果路径为空，返回.，相当于当前的工作路径。
将对路径中重复的路径分隔符（比如linux下的/)合并为一个。
对路径中的. 、…进行处理。（类似于shell里的cd …）
如果路径最后有/，那么保留该/。

var path = require('path');
var filepath = '/tmp/demo/js/test.js';

var index = 0;

var compare = function(desc, callback){
  console.log('[用例%d]：%s', ++index, desc);
  callback();
  console.log('\n');
};

compare('路径为空', function(){
  // 输出 .
  console.log( path.normalize('') );
});

compare('路径结尾是否带/', function(){
  // 输出 /tmp/demo/js/upload
  console.log( path.normalize('/tmp/demo/js/upload') );

  // /tmp/demo/js/upload/
  console.log( path.normalize('/tmp/demo/js/upload/') );
});

compare('重复的/', function(){
  // 输出 /tmp/demo/js
  console.log( path.normalize('/tmp/demo//js') );
});

compare('路径带..', function(){
  // 输出 /tmp/demo/js
  console.log( path.normalize('/tmp/demo/js/upload/..') );
});

compare('相对路径', function(){
  // 输出 demo/js/upload/
  console.log( path.normalize('./demo/js/upload/') );

  // 输出 demo/js/upload/
  console.log( path.normalize('demo/js/upload/') );
});

compare('不常用边界', function(){
  // 输出 ..
  console.log( path.normalize('./..') );

  // 输出 ..
  console.log( path.normalize('..') );

  // 输出 ../
  console.log( path.normalize('../') );

  // 输出 /
  console.log( path.normalize('/../') );

  // 输出 /
  console.log( path.normalize('/..') );
});

文件路径分解/组合

path.format(pathObject)：将pathObject的root、dir、base、name、ext属性，按照一定的规则，组合成一个文件路径。
path.parse(filepath)：path.format()方法的反向操作。

path.format(pathObject)

const path = require("path");
//root+base
var p1 = {
    root: "/temp/",
    base: "test.js"
}
path.format(p1)  //输出   /temp/test.js
//dir+name+ext
var p2 = {
    dir: "/temp",
    name: 'test',
    ext: '.js'
}
path.format(p2) //输出    /temp/test.js

path.parse(filepath)

path.format(pathObject) 的反向操作，也就是把一个路径转换为具有 root/dir/name/ext/base 等属性的对象

path.parse('/home/user/dir/file.txt')
// returns
// {
//    root : "/",
//    dir : "/home/user/dir",
//    base : "file.txt",
//    ext : ".txt",
//    name : "file"
// }

获取相对路径

接口：path.relative(from, to)

如果from、to指向同个路径，那么，返回空字符串。
如果from、to中任一者为空，那么，返回当前工作路径。

const path = require('path');

var p1 = path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
console.log(p1);  
// 输出 "../../impl/bbb"

var p2 = path.relative('/data/demo', '/data/demo');
console.log(p2);  
// 输出 ""

var p3 = path.relative('/data/demo', '');
console.log(p3);  
// 输出 ..\..\Study\Nodejs\mycode\path

NodeJs 的http模块

http 模块：封装了http server 和 client的功能，就是说可以充当server处理请求，也可以发出请求

http.createServer：创建server对象
http.get：执行http get请求

 const http = require('http')
  
  const server = http.createServer((req, res)=>{
     console.log(`url: ${req.url}  method: ${req.method}`)
  
      res.writeHead(200, {'Content-Type':'text/plain;charset=utf-8'})
      res.end('收到了请求')
      router(req, res)
  });
  // 执行get请求
  http.get("http://www.baidu.com", (res)=>{
      console.log(res);
      res.setEncoding('utf-8')
 
      let data = ''
      res.on('data', (chunk)=>{
          data += chunk
      })
      res.on('end', ()=>{
          console.log(data);
      })
  })

http.request(options,callback)

options是一个类似关联数组的对象，表示请求的参数，callback作为回调函数，需要传递一个参数，为http.ClientResponse的实例，http.request返回一个http.ClientRequest的实例。

options常用的参数有host、port（默认为80）、method（默认为GET）、path（请求的相对于根的路径，默认是“/”，其中querystring应该包含在其中，例如/search?query=byvoid）、headers（请求头内容）

var http=require("http");

var options={
    hostname:"cn.bing.com",
    port:80
}

var req=http.request(options,function(res){
    res.setEncoding("utf-8");
    res.on("data",function(chunk){
        console.log(chunk.toString())
    });
    console.log(res.statusCode);
});
req.on("error",function(err){
    console.log(err.message);
});
req.end();

http.get(options,callback)

这个方法是http.request方法的简化版，唯一的区别是http.get自动将请求方法设为了GET请求，同时不需要手动调用req.end()，但是需要记住的是，如果我们使用http.request方法时没有调用end方法，服务器将不会收到信息。因为http.get和http.request方法都是放回一个http.ClientRequest对象，所以我们来看一下这两个对象。

http.ClientRequest

http.ClientRequest是由http.request或者是http.get返回产生的对象，表示一个已经产生而且正在进行中的HTPP请求，提供一个response事件，也就是使用http.get和http.request方法中的回调函数所绑定的对象，可以显式地绑定这个事件的监听函数

var http=require("http");

var options={
    hostname:"cn.bing.com",
    port:80
}

var req=http.request(options);
req.on("response",function(res){
        res.setEncoding("utf-8");
    res.on("data",function(chunk){
        console.log(chunk.toString())
    });
    console.log(res.statusCode);
})

req.on("error",function(err){
    console.log(err.message);
});
req.end();

http.ClientRequest也提供了write和end函数，用于向服务器发送请求体，通常用于POST、PUT等操作，所有写操作都必须调用end函数来通知服务器，否则请求无效。此外，这个对象还提供了abort()、setTimeout()等方法

http.ClientReponse

与http.ServerRequest相似，提供了三个事件，data、end、close，分别在数据到达、传输结束和连接结束时触发，其中data事件传递一个参数chunk，表示接受到的数据。其属性如下
在这里插入图片描述
此外，这个对象提供了几个特殊的函数

response。setEncoding([encoding])：设置默认的编码，当data事件被触发时，数据将会以encoding编码，默认值是null，也就是不编码，以buffer形式存储
response.pause()：暂停结束数据和发送事件，方便实现下载功能
response.resume()：从暂停的状态中恢复

NodeJs 的Buffer模块

在Node中，应用需要处理网络协议、操作数据库、处理图片、接收上传文件等，在网络流和文件的操作中，还要处理大量二进制数据，Buffer类被引入作为NodejsAPI的一部分，使其可以在TCP流和文件系统操作等场景中处理二进制数据流。

因为Buffer在全局对象global上，因此无需通过require()引入，就可以直接使用。

实例化

let buf = new Buffer(5);
console.log(buf);//<Buffer 00 00 00 00 00>

新版本中使用Buffer.alloc(size[, fill[, encoding]])代替，来分配一个大小为 size 字节的新建的没有用0填充的Buffer，encoding为字符编码，默认为utf-8。

Buffer.alloc(size[, fill[, encoding]])

	let buf = Buffer.alloc(5);
	console.log(buf);//<Buffer 00 00 00 00 00>

Buffer.allocUnsafe(size)

以这种方式创建的 Buffer 实例的底层内存是未初始化的。新创建的 Buffer 的内容是未知的，可能包含敏感数据。

	let buf = Buffer.allocUnsafe(5);
	console.log(buf);//<Buffer 48 2a 59 31 00>

Buffer.from(array)，使用八位字节数组 array 分配一个新的 Buffer。

	let buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
	console.log(buf.toString());//buffer

Buffer.from(string[, encoding]),创建一个包含 string 的新 Buffer。 encoding 参数指定 string 的字符编码。

	let buf = Buffer.from('hello','utf8');
	console.log(buf);//<Buffer 68 65 6c 6c 6f>

功能方法

Buffer.byteLength(string[, encoding]),返回字符串的实际字节长度。

	let buf = Buffer.from("中国");
	console.log(Buffer.byteLength(buf));//6

Buffer.isEncoding(encoding),如果 encoding 是支持的字符编码，则返回 true，否则返回 false。

	console.log(Buffer.isEncoding('utf8'));//true
	console.log(Buffer.isEncoding('gbk'));//false

Buffer.isBuffer(obj),如果 obj 是一个 Buffer，则返回 true，否则返回 false。

	let buf = Buffer.from('hello');
	console.log(Buffer.isBuffer(buf));//true
	console.log(Buffer.isBuffer({}));//false

Buffer.concat(list[, totalLength]),返回一个合并了 list 中所有 Buffer 实例的新 Buffer。

	let buf1 = Buffer.alloc(3);
	let buf2 = Buffer.alloc(5);
	let buf3 = Buffer.concat([buf1,buf2]);
	console.log(Buffer.byteLength(buf3));//8

实例方法

buf.write(string[, offset[, length]][, encoding])

根据 encoding 指定的字符编码将 string 写入到 buf 中的 offset 位置。 length 参数是要写入的字节数。如果 buf 没有足够的空间保存整个字符串，则只会写入 string 的一部分。只编码了一部分的字符不会被写入。

	let buf = Buffer.alloc(5);
	buf.write("hello",2,3);
	console.log(buf);<Buffer 00 00 68 65 6c>
	console.log(buf.toString());//llo

buf.slice([start[, end]])

返回一个新的 Buffer，它引用与原始的 Buffer 相同的内存，但是由 start 和 end 索引进行偏移和裁剪。

	let buf = Buffer.from("hello");
	let res = buf.slice(2,4);
	console.log(res.toString());//ll

buf.toString([encoding[, start[, end]]])

根据 encoding 指定的字符编码将 buf 解码成字符串。传入 start 和 end 可以只解码 buf 的子集。

	let buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
	console.log(buf.toString());//buffer

buf.toJSON()

返回 buf 的 JSON 格式。当字符串化 Buffer 实例时，JSON.stringify() 会调用该函数。

	// toJSON方法不需要显式调用，当JSON.stringify方法调用的时候会自动调用toJSON方法
	let buf = Buffer.from("hello");
	let json = JSON.stringify(buf);
	console.log(json);//{"type":"Buffer","data":[104,101,108,108,111]}

NodeJs 的global全局对象

function global() {
    // 全局变量。__filename 表示当前正在执行的脚本的文件名。
    console.info('__filename: ' + __filename ); // __filename: D:\github\nodejs-test\requestHandlers.js

    // 全局变量。__dirname 表示当前执行脚本所在的目录。
    console.info('__dirname : ' + __dirname  ); // __dirname : D:\github\nodejs-test

    // 全局函数。setTimeout(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。setTimeout() 只执行一次指定函数。返回一个代表定时器的句柄值。
    setTimeout(function () {
        console.info('setTimeout: 我只执行一次。');
    }, 2000);

    // 全局函数。clearTimeout( t ) 全局函数用于停止一个之前通过 setTimeout() 创建的定时器。 参数 t 是通过 setTimeout() 函数创建的定时器。
    let t = setTimeout(function () {
        console.info('clearTimeout: 我没办法执行了。');
    }, 2000);
    clearTimeout(t); // 清除定时器

    // 全局函数。setInterval(cb, ms) 全局函数在指定的毫秒(ms)数后执行指定函数(cb)。
    let tt = setInterval(function () {
        console.info('setInterval: 我每2秒执行一次。');
    }, 2000);

    // 全局函数。setInterval() 方法会不停地调用函数，直到 clearInterval() 被调用或窗口被关闭。
    setTimeout(function () {
        clearInterval(tt); // 清除定时器
    }, 5000);

    // 全局对象。console
    console.info('console: 我也属于global。');

    // 全局变量。global 对象的属性。process
    console.info('process 当前目录: ' + process.cwd()); // 输出当前目录
    console.info('process 当前版本: ' + process.version); // 输出当前版本
    console.info('process 平台信息: ' + process.platform); // 输出平台信息
}

NodeJs 的exports全局对象

nodejs模块中的exports对象，你可以用它创建你的模块。

例如：（假设这是rocker.js文件）

function abc() {
  console.log("function abc.");
}
exports.test = abc;

在另一个文件中你这样引用：

var rocker = require('./rocker.js');
//在文件引入进来之后调用时记得不要遗漏（）括号；
rocker.test(); // 'function abc.'

再看一个例子：

module.exports = function(name, age) {
    this.name = name;
    this.age = age;
    this.about = function() {
        console.log(this.name +' is '+ this.age +' years old');
    };
};

可以这样应用它：

var Rocker = require('./rocker.js');
var r = new Rocker('Ozzy', 62);
r.about(); // Ozzy is 62 years old

下面例子中，你的模块是一个数组：

var Rocker = require('./rocker.js');
var r = new Rocker('Ozzy', 62);
r.about(); // Ozzy is 62 years old

可以这样应用它：

var rocker = require('./rocker.js');
console.log('Rockin in heaven: ' + rocker[2]); //Rockin in heaven: Ronnie James Dio

NodeJs 的querystring模块

querystring.stringify

将一个对象序列化为一个查询的字符串，中间使用 & 和 = 分别为字符串中的分隔符和赋值符

简单的案例

 querystring.stringify({name:'pkcms',author:'zh',date:''})
//'name=pkcms&author=zh&date='

stringify 同样也能转换包含数组的JSON

   querystring.stringify({name:'pkcms',author:['zh','hhy'],date:''})
  //'name=pkcms&author=zh&author=hhy&date='

stringify 中的第2个参数是用来修改 & 分隔符为其他符号，如下示例的英文逗号

querystring.stringify({name:'pkcms',author:'zh',date:''},',')
//'name=pkcms,author=zh,date='

stringify 中不但能修改默认的 & 分隔符，也可以修改 = 赋值符，如下示例

querystring.stringify({name:'pkcms',author:'zh',date:''},',',':')
//'name:pkcms,author:zh,date:'

querystring.parse

将一个查询的字符串反序列化为一个对象，也就是说它与 querystring.stringify 是起相反作用的关系

简单示例

querystring.parse('name=pkcms&author=zh&date=')
//{ name: 'pkcms', author: 'zh', date: '' }

相同的参数名会反序列化为一个数组

querystring.parse('name=pkcms&author=zh&author=hhy&date=')
//{ name: 'pkcms', author: [ 'zh', 'hhy' ], date: '' }

第2个参数是用来指明分隔符是用了哪个字符

querystring.parse('name=pkcms,author=zh,date=',',')
//{ name: 'pkcms', author: 'zh', date: '' }

第3个参数是用来指明赋值符是用了hash字符

querystring.parse('name:pkcms,author:zh,date:',',',':')
//{ name: 'pkcms', author: 'zh', date: '' }

querystring.escape

将一个字符转义成一个编码

  querystring.escape('<哈哈>')
  //'%3C%E5%93%88%E5%93%88%3E'

querystring.usescape

将一个编码反转义成一个字符

  querystring.unescape('%3C%E5%93%88%E5%93%88%3E')
  //'<哈哈>'

关于nodejs的基础知识点

NodeJs 的fs模块

readFile()，readFileSync()

writeFile()，writeFileSync()

exists(path, callback)

mkdir()，writeFile()，readFile()

mkdirSync()，writeFileSync()，readFileSync()

readdir()，readdirSync()

stat()

watchfile()，unwatchfile()

createReadStream()

createWriteStream()

NodeJs 里面的fs模块

对文件的操作

文件读取

文件写入

文件名修改

文件名删除

对文件夹的操作

文件夹的操作/目录操作

判断文件或者文件夹是否存在

删除文件夹 : 只能删除空文件夹

读取文件夹

显示文件的详细信息：

NodeJs 的path模块

获取 /路径/文件名/扩展名

文件路径分解/组合

路径解析

文件路径分解/组合

获取相对路径

NodeJs 的http模块

NodeJs 的Buffer模块

实例化

功能方法

实例方法

NodeJs 的global全局对象

NodeJs 的exports全局对象

NodeJs 的querystring模块

querystring.stringify

querystring.parse

querystring.escape

querystring.usescape

猜你喜欢