一看就会的 nodejs 内置模块

文件操作

1.文件的写入 fs.writeFile()

示例

const fs = require('fs');
console.log('start');
fs.writeFile('./test.txt','this is a test',function(err){
    if(err) throw err;
    console.log('is writing!');
})
console.log('end');

2.文件的追加 fs.appendFile()

正常的写入，是一个覆盖的效果，如果想要追加内容，可以使用

示例

const fs = require('fs');
console.log('start');
fs.appendFile('./test.txt','this is a test',function(err){
    if(err) throw err;
    console.log('is writing!');
})
console.log('end');

3.文件的读取 fs.readFile()

示例

const fs = require('fs');
console.log('start');
fs.readFile('./test.txt',function(err,data){
    if(err) throw err;
    console.log(data.toString());
})
console.log('end');

4.文件的复制 fs.copyFile()

示例

const fs = require('fs');
fs.copyFile('./test.txt','./test5.txt',(err)=>{
    if(err) throw err
})

5.获取文件信息

示例

const fs = require('fs');
fs.stat('./test.txt',(err, status)=>{
    if(err) throw err;
    console.log(status);
});
// Stats {
//     dev: 16777222,
//     mode: 33188,
//     nlink: 1,
//     uid: 501,
//     gid: 20,
//     rdev: 0,
//     blksize: 4096,
//     ino: 12908241066,
//     size: 17,
//     blocks: 8,
//     atimeMs: 1600244238410.9111,
//     mtimeMs: 1600242358742.662,
//     ctimeMs: 1600244237825.9692,
//     birthtimeMs: 1600237795491.121,
//     atime: 2020-09-16T08:17:18.411Z,
//     mtime: 2020-09-16T07:45:58.743Z,
//     ctime: 2020-09-16T08:17:17.826Z,
//     birthtime: 2020-09-16T06:29:55.491Z }

拿到文件信息对象后，上面有几个方法比较常用：

• isFile：判断是否为文件
• isDirectory：判断是否为目录

6.删除文件 fs.unlink()

示例

const fs = require('fs');
fs.unlink('./test.txt',(err)=>{
    if(err) throw err;
    console.log('delete OK!');
})

目录操作

1.创建目录 fs.mkdir()

示例

const fs = require('fs');
fs.mkdir('./yaoyao',(err)=>{
    if(err) throw err;
    console.log('created!');
})

2.读取目录 fs.readdir()

示例

const fs = require('fs');
fs.readdir('./',(err,files)=>{
    if(err) throw err;
    console.log(files);
})
// [ '.DS_Store',
//   'index.js',
//   'node_modules',
//   'package-lock.json',
//   'package.json',
//   'test2.txt',
//   'test3.txt',
//   'test5.txt',
//   'yaoyao' ]

问：如何去读取一个目录里面所有的文件？

答：这里需要使用到递归。首先判断当前项目是否为文件，如果是文件，打印出来，如果是目录继续递归进入目录，然后进行判断

const fs = require('fs');
const path = require('path'); // nodejs 里面的一个内置，专门处理路径相关
const showFile = function(dir){
    // 首先第一步，通过 fs.readdir 方法来读取这个目录
    fs.readdir(dir,(err,files)=>{
        if(err) throw err;
        files.forEach(file=>{
            // 首先要获取到该文件的绝对路径
            let filedir = path.join(dir,file);
            fs.stat(filedir,(err,stat)=>{
                if(err) throw err;
                if(stat.isFile()){
                    // 如果进入到 if，说明是文件，那么直接打印出来
                    console.log(file);
                } else {
                    // 说明是目录
                    showFile(filedir);
                }
            })
        })
    })
}
showFile('./test');

删除指定的目录

注意：目录里面如果有文件，系统是不允许你删除的，也就是说，只能删除空目录，所以这里又会用到递归。

以下异步和同步版本示例

// 异步的版本
const fs = require('fs')
const path = require('path')
function delDir(dir) {
    fs.readdir(dir, (err, files) => {
        // 如果有文件或者目录
        if (files) {
            files.forEach(file => {
                let filedir = path.join(dir, file); // 拼接完整的路径
                // 获取文件的状态，是文件还是目录
                fs.stat(filedir, (err, status) => {
                    // 如果是目录就继续递归，如果是文件就是将其删除掉
                    if (status && status.isDirectory()) {
                        delDir(filedir);
                    } else {
                        fs.unlink(filedir, err => { });
                    }
                });
            });
        }
        // 退出 if 后，这就是一个空目录，将其删除即可
        fs.rmdir(dir, err => {
            if (fs.existsSync(dir)) {
                delDir(dir);
            }
        });
    });
}
delDir("./test);

// 同步版本
const fs = require('fs');
const path = require('path');
const delDir = (dir) => {
    // 判断目录是否存在
    if (fs.existsSync(dir)) {
        // 获取到该目录下的所有内容，返回的是一个数组
        const files = fs.readdirSync(dir);
        // 遍历该数组，如果是目录，递归进去；如果是文件，直接删除掉
        files.forEach(function (file, index) {
            const curPath = path.join(dir, file); // 获取绝对路径
            if (fs.statSync(curPath).isDirectory()) {
                delDir(curPath); // 因为是目录，所以再次递归进去
            } else {
                fs.unlinkSync(curPath); // 删除文件
            }
        });
        // 数组遍历完之后，该目录已经变成了一个空目录，将此目录删除掉
        fs.rmdirSync(dir);
    }
}
delDir('./test');

http模块

在 nodejs 中，提供了一个叫做 http 的内置模块，使用这个模块，我们可以快速的搭建一个web服务器。

const http = require('http');
http.createServer((req,res)=>{
    // req 代表 http 请求，res 就代表响应
    res.writeHead(200, {'Content-type' : 'text/html;charset=utf-8'}); // 修改响应头里面的某些键值对
    res.write('<h1>Hello,Nodejs</h1>');
    res.end('<p>这是我用 nodejs 搭建的服务器</p>'); // 关闭这一次连接
}).listen(3000);
console.log('服务器已经启动...');

get请求

const http = require('http');
const url = require('url'); // node 内置模块
http.createServer((req,res)=>{
    // req 代表 http 请求，res 就代表响应
    res.writeHead(200, {'Content-type' : 'text/html;charset=utf-8'}); // 修改响应头里面的某些键值对
    const params = url.parse(req.url,true).query;
    console.log(params);
    res.write('<h1>Hello,Nodejs</h1>');
    res.end('<p>这是我用 nodejs 搭建的服务器</p>'); // 关闭这一次连接
}).listen(3000);
console.log('服务器已经启动...');

post请求

const http = require('http');
const url = require('url'); // node 内置模块

let str = `
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <form action="" method="POST">
        <div>
            用户名：<input type="text" name="username" id="username">
        </div>
        <div>
            密码：<input type="password" name="userpwd" id="userpwd">
        </div>
        <button>提交</button>
    </form>
</body>
</html>
`;
http.createServer((req,res)=>{
   let body = ''; // 用于接收 post 请求传递过来的数据
   // data 事件会在客户端有数据传递过来的时候触发
   req.on('data',function(chunk){
        body += chunk;
   });
   // end 事件会在 post 请求的数据接收完毕之后触发
   req.on('end',function(){
        console.log(body);
        res.writeHead(200,{'Content-Type' : 'text/html;charset=utf-8'});
        if(body){
            res.end('服务器已经接收到客户端post请求内容：' + body);
        } else {
            res.end(str);
        }
   })
}).listen(3000);
console.log('服务器已经启动...');

在传递中文的时候，浏览器会自动对中文进行编码的转换，导致在服务器拿到的中文是转码后的内容。

如果想要重新转换回中文，可以使用 decodeURI 这个方法。

使用 http 模块来实现简单的爬虫

所谓爬虫，就是用来爬取网页的内容。

在 nodejs 中，可以使用 http 和 https 模块来实现简单爬虫。会使用到一个模块，cheerio 模块。该模块可以将返回的字符串转为 jQuery 中的 $ 对象，从而可以使用 jQuery 中的各种方法。

示例

const https = require('https');
const cheerio = require('cheerio');

// 爬虫的思路很简单，其实就是发送 http 请求，去请求那个页面
// 接下来拿到响应的内容，然后筛选有用的信息

https.get('https://tuijian.hao123.com/hotrank',(req)=>{
    let data = ''; // 装回来的数据
    req.on('data',(chunk)=>{
        data += chunk
    });
    req.on('end',()=>{
        filter(data);
    })
})

function filter(data){
    let result = []; // 存放筛选后的数据
    const $ = cheerio.load(data); // 将字符串传递给 cheerio 模块，会生成一个 jQuery 对象，我们就可以在服务器端使用 jQuery 方法
    const temp_arr = $('[monkey="ss"]').find('.point-bd').find('.point-title')
    temp_arr.each((index,item)=>{
        result.push($(item).text());
    })
    console.log(result);
}

数据IO操作相关模块

buffer

在最早的时候，js在浏览器里面运行，也就是说意味着 js 是在客户端运行，所以，那个时候，js只能操作字符串。随着node的出现，js 可以做服务器端的开发，所以也就有操作二进制数据的需求，Buffer 可以让我们操作二进制数据。

Buffer相当于是在内存里面开辟了一段空间。我们程序员可以手动的去指定这段内存空间的大小。

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

往buffer里面写入数据，如下：

let buf1 = new Buffer.alloc(5);
buf1.write('a');
console.log(buf1);

示例

let buf = new Buffer.alloc(26);
for(let i=0;i<26;i++){
    buf[i] = i + 97;
}
console.log(buf.toString());

Stream 文件流

流的概念
所谓流，就像水流一样。例如，我们在网上在线看电影，或者下载电影，不是说电影这个资源一瞬间就达到我们客户端，而是以流的形式，一点一点过来的。这里其实就涉及到了流的概念。

理想的方式，读一部分，写一部分，不管文件有多大，只要时间允许，总会处理完。

在 nodejs 中，就允许我们来操作这个流。

模块名为 stream，提供了几个常用的事件：

• data：当有数据可读时触发
• end：没有更多的数据可读时会触发
• error：发生错误的时候，会触发
• finish：所有数据写入底层的时候会触发

在stream中，常见的流有2块：

• readable：可读流
• writable：可写流

通过流的形式来读取文件

const fs = require('fs');
// 创建一个可读流
const rs = fs.createReadStream('./test.txt');
rs.setEncoding('utf8');
rs.on('data',(chunk)=>{
    console.log(chunk);
    console.log('-----------------------------');
})

可写流

通过可写流来复制文件。

const fs = require('fs');
// 创建一个可读流
const rs = fs.createReadStream('./test.txt');
// 创建一个可写流
const ws = fs.createWriteStream('./test2.txt');
rs.setEncoding('utf8');
rs.on('data',(chunk)=>{
    ws.write(chunk);
})
rs.on('end',()=>{
    console.log('复制完成！');
})

使用pipe方法来处理流

使用 pipe 方法，当我们处理大型文件，效率就要高一些，它相当于在两个流文件之间建立了一个管道。

示例

const fs = require('fs');
// 创建一个可读流
const rs = fs.createReadStream('./test.txt');
// 创建一个可写流
const ws = fs.createWriteStream('./test3.txt');
rs.setEncoding('utf8');
rs.pipe(ws);

资源压缩

1. 要明确浏览器端是否接受压缩文件

在浏览器发送http请求的时候，请求头里面会有一个键值对，Accept-Encoding，表示我这个浏览器可以接收的编码格式，如果里面包含 gzip，说明该浏览器可以接收压缩文件

2. nodejs里面如何对文件进行压缩

会使用nodejs里面的一个内置模块zlib。

示例

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

// 创建一个压缩文件的对象，这个对象负责压缩文件
const gzip = zlib.createGzip();
const rs = fs.createReadStream('./test.txt'); // 创建了一个可读流
const ws = fs.createWriteStream('./test.txt.gz'); // 创建了一个可写流

rs.pipe(gzip).pipe(ws);

解压缩示例

const zlib = require('zlib');

// 创建一个压缩文件的对象，这个对象负责压缩文件
const gunzip = zlib.createGunzip();
const rs = fs.createReadStream('./test.txt.gz');
const ws = fs.createWriteStream('./test10.txt');

rs.pipe(gunzip).pipe(ws);

3.实际应用

在实际开发中，我们需要首先判断用户的浏览器是否支持压缩文件，示例代码如下：

const fs = require('fs');
const zlib = require('zlib');
const http = require('http');

const filePath = './index2.html'; // 假设这是我要向客户端返回的文件

http.createServer((req,res)=>{
    // 获取 accept-encoding 的值
    const acceptEncoding = req.headers['accept-encoding'];
    if(acceptEncoding.indexOf('gzip')!=-1){
        // 进入 if，说明存在 gzip 字符，也就是说，支持压缩
        res.writeHead(200,{'Content-type':'gzip'})
        const gzip = zlib.createGzip();
        fs.createReadStream(filePath).pipe(gzip).pipe(res);
    } else {
        // 说明不支持
        fs.createReadStream(filePath).pipe(res);
    }
}).listen(3000);