node.js的部分内置模块

node.js的内置模块就是node本身提供的模块，不用下载，直接使用require引入就可以使用这些模块的方法了。

详情可以查看node.js的官方文档,修改地址中v后面的数字就可以查看不同的版本了

https://nodejs.org/dist/latest-v11.x/docs/api/

下面我来简单介绍几个常用的模块

File System模块

就是文件和文件夹的操作模块，主要对两部分进行操作，一个是文件夹，另一个就是文件

首先引入模块

const fs=require("fs");

对文件夹的操作：新建文件夹，删除文件夹，读取文件夹，判断是否是文件夹

对文件的操作：新建文件，删除文件，读取文件，判断文件

文件夹：

新建文件夹：

首先是异步的写法

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

//有三个参数，第一个参数是地址，就是你创建的文件夹存放的地址
//第二个参数不是必填的参数, options 参数可以是一个整数，用于指定文件的模式（权限与粘滞位）。 也可以是一个对象，其中 recursive 属性指定是否创建父目录。
//第三个参数是回调函数，参数就是err错误

fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
  if (err) throw err;
});

异步都有回调函数，在node中，回调函数都有一个规范，错误优先的原则，回调函数的第一个参数都是err，表示是不是错误，默认的都是null，没有错误。

然后是同步的写法

fs.mkdirSync(path[, options])

//同步和异步的区别就不多说了，在写法上的不用就是同步的方法没有回调函数，同步创建目录


//同步调用若是出错，都会终止执行，必须用try catch来捕获错误
拿同步新建文件夹举例：
try{
    let result=mkdirSync("./test2");
}catch(e){
    console.log(new Error("错误"));
}

删除文件夹：

异步的写法：

fs.rmdir(path,callback);
//与新建类似，先是路径后面是回调函数
fs.rmdir("./test2",(err)=>{
    console.log(err);
})

//注意：fs.rmdir在删除文件夹的时候，不存在在的文件夹或者是不为空的文件不能删除

同步的写法：

fs.rmdirSync(path);

可以删除有内容的文件夹：https://mp.csdn.net/postedit/84641316 

读取文件夹：

异步的写法：

fs.readdir(path[,options],callback);
//读取文件夹的时候，回调函数中会有两个参数，一个是错误，另一个就是读取的文件
//如果 options 是一个字符串，则指定字符编码。 如果 encoding 设为 'buffer'，则返回的文件名是 Buffer,可以定义为 utf8。

fs.readdir("./test",(err,file)=>{
    console.log(err);
    console.log(file); // 文件夹中的文件，以数组的形式存放
})

同步的写法：

fs.readdirSync(path[, options])

//如果 options 是一个字符串，则指定字符编码。 如果 encoding 设为 'buffer'，则返回的文件名是 Buffer，可以定义为 utf8。

判断是否为文件夹或者文件：

检测一个文件或者文件夹的状态：

fs.stat(path[, options], callback);

fs.stat("./test2",(err,state)=>{
    err:错误
    state.isFile(); 状态是否是文件，返回值为布尔值
    state.isDirectory(); 状态是否是文件夹，返回值为布尔值
})

/*callback 有两个参数 (err, stats)，其中 stats 是一个 fs.Stats。

如果发生错误，则 err.code 会是常见系统错误之一。

不建议在调用 fs.open()、fs.readFile() 或 fs.writeFile() 之前使用 fs.stat() 检查文件是否存在。 应该直接打开、读取或写入文件，当文件无效时再处理错误。

如果要检查文件是否存在但不操作它，建议使用 fs.access()。*/

文件：

写入（新建）文件：

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

创建一个新的文件，也就是说这个方法谢同一个文件是会覆盖的。

以上是异步的写法，同步的写法与上面文件夹介绍的各个同步的方法没啥不一样，就是少了回调函数，返回值是undefined。

写入（持续）文件：

fs.appendFile("./file.txt",data,(err)=>{
    console.log(err);
})

就是writeFile换成了appendFile，就可以不覆盖的写入内容了

删除文件：

文件夹中的删除是rmdir，而文件的删除并不是rm

fs.unlink(path,callback);
fs.unlink("./file.txt",(err)=>{
    console.log(err);
})

用的是unlink，删除一个不存在的文件会报错。

读取文件：

fs.readFile(file,callback);

callback回调函数中有两个参数，一个是err，另一个是data，读取的数据，一般data的格式都要改变，两种方法

1. 可以写成data.toString;
2. 可以调用方法的时候多加一个参数，改变数值类型的（file,"utf8",callback);

URL模块

url：统一资源定位符

┌─────────────────────────────────────────────────────────────────────────────────────────────┐
│                                            href                                             │
├──────────┬──┬─────────────────────┬─────────────────────┬───────────────────────────┬───────┤
│ protocol │  │        auth         │        host         │           path            │ hash  │
│          │  │                     ├──────────────┬──────┼──────────┬────────────────┤       │
│          │  │                     │   hostname   │ port │ pathname │     search     │       │
│          │  │                     │              │      │          ├─┬──────────────┤       │
│          │  │                     │              │      │          │ │    query     │       │
"  https:   //    user   :   pass   @ sub.host.com : 8080   /p/a/t/h  ?  query=string   #hash "
│          │  │          │          │   hostname   │ port │          │                │       │
│          │  │          │          ├──────────────┴──────┤          │                │       │
│ protocol │  │ username │ password │        host         │          │                │       │
├──────────┴──┼──────────┴──────────┼─────────────────────┤          │                │       │
│   origin    │                     │       origin        │ pathname │     search     │ hash  │
├─────────────┴─────────────────────┴─────────────────────┴──────────┴────────────────┴───────┤
│                                            href                                             │
└─────────────────────────────────────────────────────────────────────────────────────────────┘
(请忽略字符串中的空格，它们只是为了排版需要，此图来自node.js官方文档)

 方法一：将一个url地址变成一个对象

url.parse(urlString,[,options]);

第一个参数填的是一个ulr地址

第二个参数默认是false，如果你设置成true,那就可以将上图中url组成的query转成对象的形式

第三个参数默认也是false，如果设置成true，就可以解析前面没有协议的地址，不然就得不到端口号等

方法二：将对象（格式正确）转化成一个url地址

url.format(URL[, options])

• options <Object>

  • auth <boolean> 如果序列化的URL字符串应该包含用户名和密码为true，否则为false。默认为true。
  • fragment <boolean> 如果序列化的URL字符串应该包含分段为true，否则为false。默认为true。
  • search <boolean> 如果序列化的URL字符串应该包含搜索查询为true，否则为false。默认为true。
  • unicode <boolean> true 如果出现在URL字符串主机元素里的Unicode字符应该被直接编码而不是使用Punycode编码为true，默认为false。

返回一个WHATWG URL对象的可自定义序列化的URL字符串表达。

虽然URL对象的toString()方法和href属性都可以返回URL的序列化的字符串。然而，两者都不可以被自定义。而url.format(URL[, options])方法允许输出的基本自定义。

const { URL } = require('url');
const myURL = new URL('https://a:b@你好你好?abc#foo');

console.log(myURL.href);
  // 输出 https://a:b@xn--6qqa088eba/?abc#foo

console.log(myURL.toString());
  // 输出 https://a:b@xn--6qqa088eba/?abc#foo

console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));
  // 输出 'https://你好你好/?abc'

 

queryString模块

queryString就是查询字符串，模块提供了一些实用函数，用于解析与格式化 URL 查询字符串

const qs = require('querystring');

下面介绍四个方法

 方法一：querystring.escape(str)

对给定的 str 进行 URL 编码。

 方法二：querystring.unescape(str)

对给定的 str 进行 URL 解码。

方法三：querystring.stringify(obj[, sep[, eq[, options]]])

将对象转化成字符串

• sep         第二个参数    用于界定查询字符串中的键值对的子字符串。默认为 '&'。
• eq   第三个参数 用于界定查询字符串中的键与值的子字符串。默认为 '='。

• options

  • encodeURIComponent <Function> 把对象中的字符转换成查询字符串时使用的函数。默认为 querystring.escape()。该方法通过遍历给定的 obj 对象的自身属性，生成 URL 查询字符串。

// 假设存在 gbkEncodeURIComponent 函数。
querystring.stringify({ w: '中文', foo: 'bar' }, null, null,
                      { encodeURIComponent: gbkEncodeURIComponent });

方法四：querystring.parse(str[, sep[, eq[, options]]])

将query字符串装华为对象

• sep   第二个参数     用于界定查询字符串中的键值对的子字符串。默认为 '&'。
• eq           第三个参数  用于界定查询字符串中的键与值的子字符串。默认为 '='。

• options <Object>

  • decodeURIComponent <Function> 解码查询字符串的字符时使用的函数。默认为 querystring.unescape()。
  • maxKeys <number> 指定要解析的键的最大数量。指定为 0 则不限制。默认为 1000。

path模块

__dirname  表示的是获取当前文件所在目录的绝对路径

path模块通常会和fs模块配合使用，然后fs模块写路径是配合该模块的方法就变成了绝对路径

方法一：path.join([...paths])

路径的拼接

智能拼接，通常配合__dirname使用生成绝对路径

方法二：path.isAbsolute(path)

判断path是否是绝对路径，返回值是布尔值

方法三：path.dirname(path)

获取一个路径中的文件夹名

方法四：path.basename(path)

获取一个路径中的文件名

方法五：path.extname(path)

返回 path 的扩展名，即从 path 的最后一部分中的最后一个 .（句号）字符到字符串结束。 如果 path 的最后一部分没有 . 或 path 的文件名（参考 path.basename()）的第一个字符是 .，则返回一个空字符串。

events模块

events就是事件触发器

所有能触发事件的对象都是 EventEmitter 类的实例。 这些对象有一个 eventEmitter.on() 函数，用于将一个或多个函数绑定到命名事件上。 事件的命名通常是驼峰式的字符串。

events模块调用比较复杂，需要三步

const EventEmitter = require('events');  //引用

class MyEmitter extends EventEmitter {}  //继承

const myEmitter = new MyEmitter();       //实例化对象

 事件的侦听和触发

const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('触发事件');
});


myEmitter.emit('event');

事件的移除

emitter.removeListener(eventName, listener)  单个移除

从名为 eventName 的事件的监听器数组中移除指定的 listener。

const callback = (stream) => {
  console.log('已连接');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

 emitter.removeAllListeners([eventName])   全部移除

移除全部的事件侦听

传参数与 `this` 到监听器

eventEmitter.emit() 方法可以传任意数量的参数到监听器函数。 当监听器函数被调用时，this 关键词会被指向监听器所绑定的 EventEmitter 实例。

const myEmitter = new MyEmitter();
myEmitter.on('event', function(a, b) {
  console.log(a, b, this, this === myEmitter);
  // 打印:
  //   a b MyEmitter {
  //     domain: null,
  //     _events: { event: [Function] },
  //     _eventsCount: 1,
  //     _maxListeners: undefined } true
});
myEmitter.emit('event', 'a', 'b');

也可以使用 ES6 的箭头函数作为监听器，但我们都知道，箭头函数 this 关键词不会指向 EventEmitter 实例，但是e.currentTarget是指向实例的。

const myEmitter = new MyEmitter();
myEmitter.on('event', (a, b) => {
  console.log(a, b, this);
  // 打印: a b {}
});
myEmitter.emit('event', 'a', 'b');

 Stream--流

几乎所有的 Node.js 应用都在某种程度上使用了流，流就是一种数据的传输方式。

let read=fs.createReadStream('./events.js')// 创建可读的流

let  writestream=fs.createWriteStream('./events3.js')//创建可写的流

三种copy的模式

//整体写入

let data=''
read.on('data',(chunk)=>{
	data+=chunk
	console.log(chunk)
})
read.on('end',()=>{
	fs.writeFileSync('./events2.js', data);
})

//读写流配合

const fs=require('fs')
let read=fs.createReadStream('./events.js')// 创建可读的流
let  writestream=fs.createWriteStream('./events3.js') 创建可写的流
read.on('data',(chunk)=>{
writestream.write(chunk)	
})

//读写流配合pipe

const fs=require('fs')
let read=fs.createReadStream('./events.js')// 创建可读的流
let  writestream=fs.createWriteStream('./events4.js') 创建可写的流
read.pipe(writestream)

zlib模块

zlib就是文档压缩，zlib模块提供通过 Gzip 和 Deflate/Inflate 实现的压缩功能

const gzip = zlib.createGzip();
const fs = require('fs');
const inp = fs.createReadStream('input.txt');
const out = fs.createWriteStream('input.txt.gz');

inp.pipe(gzip).pipe(out);

压缩或者解压数据流(例如一个文件)通过zlib流将源数据流传输到目标流中来完成。