Node.js学习总结

摘要：表示当前正在执行的脚本的文件名。默认编码为模式为，为回调函数，回调函数只包含错误信息参数，在写入失败时返回。参数使用说明如下通过方法返回的文件描述符。

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));
   });  
});