Node常用内置模块

Node常用内置模块

path-内置模块

path模块的常用方法

（1）获取路径信息

const path = require('path');

// 1.获取路径的信息
const filepath = '/User/why/abc.txt';

console.log(path.dirname(filepath)); //获取路径名
console.log(path.basename(filepath)); //获取文件名
console.log(path.extname(filepath)); //获取文件的扩展名

（2）join实现路径的拼接

const basepath = '../User/why';
const filename = './abc.txt';

const filepath1 = path.join(basepath, filename);
console.log(filepath1);

（3）resolve实现路径的拼接

const basepath = '../User/why';
const filename = './abc.txt';
const othername = './why.js';

// resolve会判断拼接的路径字符串中,是否有以/或./或../开头的路径并且将所有的路径都进行一个打印
const filepath2 = path.resolve(basepath, filename, othername);
console.log(filepath2);

fs-内置模块

由于fs内置模块的api非常多，因此我们只学习常用的一些方法就行了，别的api可自己查询文档。

但是这些API大多数都会提供三种操作方式：

方式一：同步操作文件：代码会被阻塞，不会继续执行。

const fs = require('fs');

// 案例: 读取文件的信息(注意：只是提取文件信息)
const filepath = "./abc.txt";

// 1.方式一: 同步操作
const info = fs.statSync(filepath);
console.log("后续需要执行的代码");
console.log(info);

方式二：异步回调函数操作文件：代码不会被阻塞，需要传入回调函数，当获取到结果时，回调函数被执行。

// 2.方式二: 异步操作
fs.stat(filepath, (err, info) => {
  if (err) {
    console.log(err);
    return;
  }
  console.log(info);
  console.log(info.isFile()); //是否是文件
  console.log(info.isDirectory()); //是否是文件夹
});
console.log("后续需要执行的代码");

方式三：异步Promise操作文件：代码不会被阻塞，通过fs.promises调用方法操作，会返回一个Promise，可以通过then、catch进行处理。

// 3.方式三: Promise
fs.promises.stat(filepath).then(info => {
  console.log(info);
}).catch(err => {
  console.log(err);
});

console.log("后续需要执行的代码");

操作文件

文件读取

(1) readFileSync（path，参数二）：同步读取方法

• 第二个参数为 options，默认值为 null，其中有 encoding（编码，默认为 null）和 flag（标识位，默认为 r），也可直接传入 encoding。
• 返回值为文件的内容，如果没有 encoding，返回的文件内容为 Buffer二进制数据，如果有则按照传入的编码解析。

const fs = require("fs");

//同步读取数据
let buf = fs.readFileSync("1.txt");
let data = fs.readFileSync("1.txt", "utf8");

console.log(buf); // <Buffer 48 65 6c 6c 6f>
console.log(data); // Hello

(2) readFile（path，options，callback）：异步读取方法

readFile 与 readFileSync 的前两个参数相同，最后一个参数为回调函数，回调函数内有两个参数 err（错误）和 data（数据），该方法没有返回值，回调函数在读取文件成功后执行。

const fs = require("fs");

//异步读取数据
fs.readFile("1.txt", "utf8", (err, data) => {
    console.log(err); // null
    console.log(data); // Hello
});

文件写入

(1) writeFileSync（path，参数二，options）：同步写入方法

• 第二个参数为写入的数据，类型为 String 或 Buffer。

const fs = require("fs");

//同步写入数据
fs.writeFileSync("2.txt", "Hello world");
let data = fs.readFileSync("2.txt", "utf8");

console.log(data); // Hello world

(2) writeFile（path，data，options，callback）：异步写入方法

const fs = require("fs");

//异步写入数据
fs.writeFile("2.txt", "Hello world", err => {
    if (!err) {
        fs.readFile("2.txt", "utf8", (err, data) => {
            console.log(data); // Hello world
        });
    }
});

文件追加写入

(1) appendFileSync（path，data，options）：同步追加写入方法

const fs = require("fs");

//同步追加写入
fs.appendFileSync("3.txt", " world");
let data = fs.readFileSync("3.txt", "utf8");

console.log(data); // Hello world

(2) appendFile（path，data，options，callback）：异步追加写入方法

const fs = require("fs");

//异步追加写入
fs.appendFile("3.txt", " world", err => {
    if (!err) {
        fs.readFile("3.txt", "utf8", (err, data) => {
            console.log(data); // Hello world
        });
    }
});

文件拷贝写入

(1) copyFileSync（参数一，参数二）：同步拷贝写入方法

参数一：第一个参数为被拷贝的源文件路径。

参数二：第二个参数为拷贝到的目标文件路径，如果目标文件不存在，则会创建并拷贝。

const fs = require("fs");

//文件同步拷贝写入
fs.copyFileSync("3.txt", "4.txt");
let data = fs.readFileSync("4.txt", "utf8");

console.log(data); // Hello world

(2) copyFile（src，des，callback）：异步拷贝写入方法

const fs = require("fs");

//文件异步拷贝写入
fs.copyFile("3.txt", "4.txt", () => {
    fs.readFile("4.txt", "utf8", (err, data) => {
        console.log(data); // Hello world
    });
});

删除文件操作

(1) unlinkSync（filepath）：同步删除文件方法

const fs = require("fs");

//同步删除文件
fs.unlinkSync("a/inde.js");

(2) unlink（filepath，callback）：异步删除文件方法

const fs = require("fs");

//异步删除方法
fs.unlink("a/index.js", err => {
    if (!err) console.log("删除成功");
});

异步打开文件 open（path，flag，mode，callback）

const fs = require("fs");

//异步打开文件
fs.open("4.txt", "r", (err, fd) => {
    console.log(fd);
    fs.open("5.txt", "r", (err, fd) => {
        console.log(fd);
    });
});

// 3
// 4

异步关闭文件 close（fd，callback）

const fs = require("fs");

//异步关闭文件
fs.open("4.txt", "r", (err, fd) => {
    fs.close(fd, err => {
        console.log("关闭成功");
    });
});

// 关闭成功

异步读取文件 read

read 与 readFile 不同之处在于，read方法一般针对于文件太大，无法一次性读取全部内容到缓存中或文件大小未知的情况，都是多次读取到 Buffer 中。

read 方法中有六个参数：

• fd：文件描述符，需要先使用 open 打开；
• buffer：要将内容读取到的 Buffer；
• offset：整数，向 Buffer 写入的初始位置；
• length：整数，读取文件的长度；
• position：整数，读取文件初始位置；
• callback：回调函数，有三个参数 err（错误），bytesRead（实际读取的字节数），buffer（被写入的缓存区对象），读取执行完成后执行。

const fs = require("fs");
let buf = Buffer.alloc(6);

// 打开文件
fs.open("6.txt", "r", (err, fd) => {
    // 读取文件
    fs.read(fd, buf, 0, 3, 0, (err, bytesRead, buffer) => {
        console.log(bytesRead);
        console.log(buffer);

        // 继续读取
        fs.read(fd, buf, 3, 3, 3, (err, bytesRead, buffer) => {
            console.log(bytesRead);
            console.log(buffer);
            console.log(buffer.toString());
        });
    });
});

// 3
// <Buffer e4 bd a0 00 00 00>

// 3
// <Buffer e4 bd a0 e5 a5 bd>
// 你好

操作文件目录

查看文件目录的操作权限

(1) accessSync（）：同步查看

accessSync 方法传入一个目录的路径，检查传入路径下的目录是否可读可写，当有操作权限的时候没有返回值，没有权限或路径非法时抛出一个 Error 对象，所以使用时多用 try…catch… 进行异常捕获。

const fs = require("fs");

//同步查看
try {
    fs.accessSync("a/b/c");
    console.log("可读可写");
} catch (err) {
    console.error("不可访问");
}

(2) access（filepath，callback）：异步查看

const fs = require("fs");

//异步查看
fs.access("a/b/c", err => {
    if (err) {
        console.error("不可访问");
    } else {
        console.log("可读可写");
    }
});

获取文件目录的 Stat 对象

文件目录的 Stat 对象存储着关于这个文件或文件夹的一些重要信息，如创建时间、最后一次访问的时间、最后一次修改的时间、文章所占字节和判断文件类型的多个方法等等。

(1) statSync（filepath）：同步获取

const fs = require("fs");

//同步获取
let statObj = fs.statSync("a/b/c.txt");
console.log(statObj.size); // 6

(2) stat（filepath，callback）：异步获取

const fs = require("fs");

//异步获取
fs.stat("a/b/c.txt", (err, statObj) => {
    console.log(statObj.size); // 6
});

创建文件目录

(1) mkdirSync（filepath）：同步创建目录方法

mkdirSync 方法参数为一个目录的路径，没有返回值，在创建目录的过程中，必须保证传入的路径前面的文件目录都存在，否则会抛出异常。

const fs = require("fs");

// 假设已经有了 a 文件夹和 a 下的 b 文件夹
fs.mkdirSync("a/b/c");

(2) mkdir（filepath，callback）：异步创建目录方法

const fs = require("fs");

// 假设已经有了 a 文件夹和 a 下的 b 文件夹
fs.mkdir("a/b/c", err => {
    if (!err) console.log("创建成功");
});

// 创建成功

读取文件目录

(1) readdirSync（filepath，options）：同步读取文件目录

• 返回值为一个存储文件目录中成员名称的数组。

const fs = require("fs");

//同步读取文件目录
let data = fs.readdirSync("a/b");
console.log(data); // [ 'c', 'index.js' ]

(2) readdir（filepath，options，callback）：异步读取文件目录

const fs = require("fs");

//异步读取文件目录
fs.readdir("a/b", (err, data) => {
    if (!err) console.log(data);
});

// [ 'c', 'index.js' ]

删除文件目录

无论同步还是异步，删除文件目录时必须保证文件目录的路径存在，且被删除的文件目录为空，即不存在任何文件夹和文件。

(1) rmdirSync（filepath）：同步删除文件目录

const fs = require("fs");

//同步删除文件目录
fs.rmdirSync("a/b");

(2) rmdir（filepath，callback）：异步删除文件目录

const fs = require("fs");

//异步删除文件目录
fs.rmdir("a/b", err => {
    if (!err) console.log("删除成功");
});

// 删除成功

注意：flag选项

flag的值有很多：

（1）w 打开文件写入，写入时的默认值。

（2）w+ 打开文件进行读写，如果不存在则创建文件。

（3）r 打开文件读取，读取时的默认值。

（4）r+ 打开文件进行读写，如果不存在那么抛出异常。

（5）a 打开要写入的文件，将流放在文件末尾。如果不存在则创建文件。

（6）a+ 打开文件以进行读写，将流放在文件末尾。如果不存在则创建文件。

读取文件夹的所有文件

const fs = require('fs');
const path = require('path');

// 1.创建文件夹
const dirname = './why';

function getFiles(dirname) {
  fs.readdir(dirname, { withFileTypes: true }, (err, files) => {
    for (let file of files) {
      // fs.stat(file) 可以, 但是有点麻烦
      if (file.isDirectory()) {
        const filepath = path.resolve(dirname, file.name);
        getFiles(filepath);
      } else {
        console.log(file.name);
      }
    }
  });
}

getFiles(dirname);

文件的重命名

// 3.重命名
fs.rename("./why", "./kobe", err => {
  console.log(err);
})

events模块

events的常用方法

const EventEmitter = require("events");

// 1.创建事件发射器
const emitter = new EventEmitter();

// 2.监听某一个事件
// addListener是on的alias简写
emitter.on('click', (args) => {
  console.log("监听1到click事件", args);
})

const listener2 = (args) => {
  console.log("监听2到click事件", args);
}
emitter.on('click', listener2)

// 3.发出一个事件以及取消该事件
setTimeout(() => {
  emitter.emit("click", "coderwhy", "james", "kobe");
  emitter.off("click", listener2);
  emitter.emit("click", "coderwhy", "james", "kobe");
}, 2000);

events获取信息

const EventEmitter = require('events');

// 1.创建发射器
const emitter = new EventEmitter();

// 2.监听某一个事件
// addListener是on的alias简写
emitter.on('click', (args) => {
  console.log("监听1到click事件", args);
})

const listener2 = (args) => {
  console.log("监听2到click事件", args);
}
emitter.on('click', listener2)

emitter.on("tap", (args) => {
  console.log(args);
})

// 3.获取注册的事件
console.log(emitter.eventNames());
console.log(emitter.listenerCount("click"));
console.log(emitter.listeners("click"));

events不常用的方法

const EventEmitter = require("events");

// 1.创建发射器
const emitter = new EventEmitter();

// 2.监听某一个事件
// addListener是on的alias简写
// 只执行一次
emitter.once('click', (arg1, arg2, arg3) => {
  console.log("监听1到click事件", arg1, arg2, arg3);
})

const listener2 = function(arg1, arg2, arg3) {
  // 特点: 绑定this, 也不绑定arguments数组
  console.log(arguments);
  console.log(this);
  console.log("监听2到click事件", arg1, arg2, arg3);
}

emitter.on('click', listener2)

// 将本次监听放到最前面
emitter.prependListener('click', (arg1, arg2, arg3) => {
  console.log("监听3到click事件", arg1, arg2, arg3);
})

emitter.on("scroll", (args) => {
  console.log("监听到scroll方法");
})

// 3.发出一个事件
setTimeout(() => {
  // emitter.removeAllListeners("click");
  emitter.emit("click", "coderwhy", "james", "kobe");
  emitter.emit("click", "coderwhy", "james", "kobe");
  emitter.emit("scroll", "coderwhy", "james", "kobe");
}, 2000);

console.log(arguments);
console.log(this);