常用内置模块

Noode 当中的模块分为三种:内置模块,第三方模块以及自定义模块。 不论哪一种模块,在使用时都必须先引入模块。

1 模块引入方式

const 变量名 = require('模块名');

2 path 模块

path 模块用于处理路径,模块的常用方法如下:

方法名 描述
join() 用于连接路径,该方法的主要用途在于,会正确使用当前系统的路径分隔符,Unix系统是"/",Windows系统是"\"。
isAbsolute() 判断参数是否是绝对路径。
dirname() 返回路径中目录的部分 。
basename() 返回路径中的最后一部分,文件名部分。
extname() 返回路径中文件的后缀名。
resolv() 将路径或者路径片段序列化为绝对路径 (常用)。

3 url 模块

url 模块用于 URL 处理与解析。

const url = require("url");
const str = "http://www.fuming.site/a/b/index.html?id=12&type=1#one";

// 用法一 返回一个url信息组成的对象
url.parse(str);

// 用法二 实例化得到一个url信息组成的对象
const u = new url.URL(str);
// 解析之后得到的对象如下:
URL {
  href: 'http://www.fuming.site/a/b/index.html?id=12&type=1#one',
  origin: 'http://www.fuming.site',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'www.fuming.site',
  hostname: 'www.fuming.site',
  port: '',
  pathname: '/a/b/index.html',
  search: '?id=12&type=1',
  searchParams: URLSearchParams { 'id' => '12', 'type' => '1' },
  hash: '#one'
}

4 querystring 模块

querystring是一个内置模块。可以将查询字符串(如:a=1&b=2)转为对象,也可以将对象转为查询字符串,常用方法如下:

方法名 描述
parse() 将查询字符串解析为对象
stringify() 将对象转为查询字符串

5 fs 模块

在 NodeJS 中,所有与文件操作都是通过 fs 核心模块来实现的,包括文件目录的创建、删除、查询以及文件的读取和写入,在 fs 模块中,所有的方法都分为同步异步两种实现方式,具有 sync 后缀的方法为同步方法,不具有 sync 后缀的方法为异步方法 。

6.1 文件操作

方法 描述
readFile() 异步方式读取文件
readFileSync() 同步方式读取文件
writeFile() 异步方式写入文件,原来的内容会被覆盖
writeFileSync() 同步方式写入文件,原来的内容会被覆盖
appendFile() 异步方式追加写入文件
appendFileSync() 同步方式追加写入文件
rename() 异步方式重命名或移动文件
renameSync() 同步方式重命名或移动文件
copy() 异步方式复制文件
copySync() 同步方式复制文件
unlink() 异步方式删除文件
unlinkSync() 同步方式删除文件

① 读取文件

// 导入 fs 模块
const fs = require('fs');

// 异步方式读取文件内容
fs.readFile('文件路径', (err, data) => {
    if (err) {
        console.log('读取失败:', err.message);
        return;
    }
    console.log(data);   // buffer 类型的数据
    console.log(data.toString()); // 转为字符串显示
});

// 异步方式读取文件内容,自动根据编码去处理文件中的内容,回调函数直接返回字符串
fs.readFile('文件路径', 'utf8', (err, data) => {
    if (err) {
        console.log('读取失败:', err.message);
        return;
    }
    console.log(data);  // 字符串
});

// 同步方式读取文件内容 返回读取到的内容 默认返回的是 Buffer
fs.readFileSync('文件路径');

// 同步方式读取文件内容, 设置编码,返回值是 Buffer
fs.readFileSync('文件路径', 'utf-8');

② 写入文件

// 导入 fs 模块
const fs = require('fs');

// 异步方式向文件写入内容, 文件不存在自动创建,文件中原来的内容会被覆盖
fs.writeFile('文件路径', 字符串或Buffer, err => {
    if (err) {
        console.log('文件写入失败!');
        return;
    }
    console.log('文件写入成功!');
});

// 同步方式像文件写入内容,文件不存在自动创建,文件中原来的内容会被覆盖
fs.writeFileSync('文件路径', 字符串或Buffer);
// 导入 fs 模块
const fs = require('fs');

// 异步方式向文件追加写入内容, 文件不存在自动创建,在原内容后面追加
fs.appendFile('文件路径', 字符串或Buffer, err => {
    if (err) {
        console.log('文件写入失败!');
        return;
    }
    console.log('文件写入成功!');
});

// 同步方式像文件追加写入内容,文件不存在自动创建,在原内容后面追加
fs.appendFileSync('文件路径', 字符串或Buffer);

③ 重命名或移动文件

// 导入 fs 模块
const fs = require('fs');

// 异步方式命名文件
fs.rename('./data1.txt', './data2.txt', err => {
    if (err) {
        console.log('文件重命名失败!');
        return;
    }
    console.log('文件重命名成功!');
});

// 异步方式将文件 data2.txt 移动到上一级目录里
fs.rename('./data2.txt', '../data2.txt', err => {
    if (err) {
        console.log('文件移动失败!');
        return;
    }
    console.log('文件移动成功!');
});

// 同步方式重命名文件
fs.renameSync('./data1.txt', './data2.txt');


// 同步方式将文件 data2.txt 移动到上一级目录里
fs.renameSync('./data2.txt', '../data2.txt');

④ 复制文件

// 导入 fs 模块
const fs = require('fs');

// 异步方式复制文件
fs.copyFile('./data.txt', '../../data.txt', err => {
    if (err) {
        console.log('复制失败!');
        return;
    }
    console.log('复制成功!');
});

// 同步方式复制文件
fs.copyFileSync('./data.txt', '../../data.txt');

⑤ 删除文件

// 导入模块
const fs = require('fs');

// 异步方式删除文件
fs.unlink('./data.txt', err => {
    if (err) {
        console.log('删除失败!', err);
        return;
    }
    console.log('删除成功!');
});

// 同步方式删除文件
fs.unlinkSync('./data.txt');

6.2 目录操作

方法名 描述
mkdir() 异步方式创建目录
mkdirSync() 同步方式创建目录
rmdir() 异步方式删除目录
rmdirSync() 同步方式删除目录
readdir() 异步方式读取目录
readdirSync() 同步方式读取目录

① 创建目录

// 导入模块
const fs = require('fs');

// 异步方式创建目录,创建单层目录
fs.mkdir('./images', err => {
    if (err) {
        console.log('目录创建失败!', err);
        return;
    }
    console.log('目录创建成功!');
});

// 异步方式创建目录,创建多层目录,递归创建
fs.mkdir('./assets/dist/images', {recursive: true}, err => {
    if (err) {
        console.log('目录创建失败!', err);
        return;
    }
    console.log('目录创建成功!');
});

// 同步方式创建目录,创建单层目录
fs.mkdirSync('./images');

// 同步方式创建目录,创建多层目录,递归创建
fs.mkdirSync('./assets/dist/images', {recursive: true});

② 删除目录

// 导入模块
const fs = require('fs');

// 异步方式删除空目录,假设 images 目录是空目录
fs.rmdir('./images', err => {
    if (err) {
        console.log('删除目录失败!');
        return;
    }
    console.log('删除目录成功!');
});


// 异步方式删除非空的目录,递归删除,假设 assets 目录是非空目录
fs.rmdir('./assets', {recursive: true}, err => {
    if (err) {
        console.log('删除目录失败!', err);
        return;
    }
    console.log('删除目录成功!');
});

// 同步方式删除空目录,假设 images 目录是空目录
fs.rmdirSync('./images');


// 同步方式删除非空的目录,递归删除,假设 assets 目录是非空目录
fs.rmdirSync('./assets', {recursive: true});

③ 读取目录

// 导入模块
const fs = require('fs');

// 异步方式读取目录
fs.readdir('目录路径', (err, files) => {
    if (err) {
        console.log('读取失败!');
        return;
    }
      console.log(files);   // 得到一个由目录中的子目录或文件组成的数组
});

// 同步方式读取目录,返回一个由目录中的子目录或文件组成的数组
const files = fs.readdir('目录路径');

6.3 文件目录通用操作

方法名 描述
exists() 异步方式判断文件或目录是否存在,该方法已经弃用,可用 access() 代替
existsSync() 同步方式判断文件或目录是否存在
access() 异步方式判断文件或目录的可访问性
accessSync() 同步方式判断文件或目录的可访问性
stat() 异步方式获取文件或目录信息
statSync() 同步方式获取文件或目录信息

① 判断文件或目录是否存在

const fs = require('fs');
const file = 'package.json';

// 检查当前目录中是否存在该文件。
fs.access(file, fs.constants.F_OK, (err) => {
  console.log(`${file} ${err ? 'does not exist' : 'exists'}`);
});

// 检查文件是否可读。
fs.access(file, fs.constants.R_OK, (err) => {
  console.log(`${file} ${err ? 'is not readable' : 'is readable'}`);
});

// 检查文件是否可写。
fs.access(file, fs.constants.W_OK, (err) => {
  console.log(`${file} ${err ? 'is not writable' : 'is writable'}`);
});

// 检查文件是否可读可写。
fs.access(file, fs.constants.R_OK | fs.constants.W_OK, (err) => {
  console.log(`${file} ${err ? 'is not' : 'is'} readable and writable`);
});

② 获取文件或目录信息,可以用于判断是文件还是目录

// 导入 fs 模块
const fs = require('fs');

// 获取某个文件的特性
fs.stat(__dirname + '/lessons', (err, stats) => {
    if (err) throw err;
    if (stats.isDirectory()) {
        console.log('该文件是目录!');
    } else if (stats.isFile()) {
        console.log('该文件是文件!');
    } else {
        console.log('该文件是其他类型!');
    }
});

6.4 流操作 —— 大文件读写

方法 描述
createReadStream() 创建一个读取流,返回一个 readStream 对象
createWriteStream() 创建一个写入流,返回一个 writeStream 对象

① 流式读取文件

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

// 流式读取
const rs = fs.createReadStream(path.resolve(__dirname,"./1.mp4"));
rs.on("error",function (){
    console.log("异常时执行");
})
rs.on("open",function (){
    console.log("打开读取的文件时执行");
})
rs.on("ready",function (){
    console.log("准备就绪");
})
rs.on("data",function (chunk){
    console.log("读取数据",chunk.length)
})
rs.on("end",function (){
    console.log("读取完毕")
})

② 流式写入文件

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

// 流式写入
const ws = fs.createWriteStream(path.resolve(__dirname,"./one.txt"));
ws.on("open",function (){
    console.log("打开写入的文件");
})
ws.on("close",function(){
    console.log("关闭写入的文件");
})
ws.write("a");
ws.write("b");
ws.write("c");
ws.write("d");
ws.write("e")
ws.close();

③ 流式复制文件

const rs = fs.createReadStream(rFilePath);
const ws = fs.createWriteStream(path.join(__dirname,"/four.mp4"));
rs.on("end",function (){
    console.log("读取完毕");
    ws.close();
})
rs.on("data",function (chunk){
    ws.write(chunk);
})
const rs = fs.createReadStream(rFilePath);
const ws = fs.createWriteStream(path.join(__dirname,"/four.mp4"));

rs.on("end",function (){
    console.log("读取完毕");
})

// 利用管道
rs.pipe(ws);

results matching ""

    No results matching ""