nodejs 内置模块初学
nodejs 内置模块
文件操作
在 nodejs 中，提供了 fs 模块，来供我们操作文件。在 nodejs 中，操作文件都提供了同步和异步的方式，但是在实际的开发中，我们更多的还是使用异步来进行开发。
-
文件的写入
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');
-
文件的追加
正常的写入，是一个覆盖的效果，如果想要追加内容，可以使用
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');
- 文件的读取
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');
- 文件的复制
fs.copyFile()
具体示例如下：
const fs = require('fs');
fs.copyFile('./test.txt','./test5.txt',(err)=>{
if(err) throw err
})
- 获取文件信息
通过 fs 模块的 stat 方法可以拿到一个文件的具体信息。
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：判断是否为目录
- 删除文件
fs.unlink()
具体使用示例如下：
const fs = require('fs');
fs.unlink('./test.txt',(err)=>{
if(err) throw err;
console.log('delete OK!');
})
操作目录
- 创建目录
fs.mkdir
具体示例如下：
const fs = require('fs');
fs.mkdir('./yaoyao',(err)=>{
if(err) throw err;
console.log('created!');
})
- 读取目录
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('./yaoyao');
另一种方法：
const fs = require('fs');
function readdirFn(str) {
fs.readdir(str, {
withFileTypes: true
}, (err, data) => {
if (err) throw err;
for (let index in data) {
if(!data[index].isFile()){
readdirFn(str+data[index].name+'/')
}else{
console.log(data[index].name);
}
}
})
}
readdirFn('./yaoyao/')
作业：删除一个目录
注意：目录里面如果有文件，系统是不允许你删除的，也就是说，只能删除空目录，所以这里又会用到递归。
// 异步的版本
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("./yaoyao");
// 同步版本
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('Hello,Nodejs
');
res.end('这是我用 nodejs 搭建的服务器
'); // 关闭这一次连接
}).listen(3000);
console.log('服务器已经启动...');
通过上面的示例，我们就快速的搭建了一个服务器。接下来我们需要研究一下如何获取 get 和 post 请求的数据。
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('Hello,Nodejs
');
res.end('这是我用 nodejs 搭建的服务器
'); // 关闭这一次连接
}).listen(3000);
console.log('服务器已经启动...');
post 请求
const http = require('http');
const url = require('url'); // node 内置模块
let str = `
Document
`;
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、Stream 文件流。
Buffer
在最早的时候，js在浏览器里面运行，也就是说意味着 js 是在客户端运行，所以，那个时候，js只能操作字符串。随着node的出现，js 可以做服务器端的开发，所以也就有操作二进制数据的需求，Buffer 可以让我们操作二进制数据。
我们简单介绍一下Buffer 相关的方法。
Buffer相当于是在内存里面开辟了一段空间。我们程序员可以手动的去指定这段内存空间的大小。
let buf1 = new Buffer.alloc(5);
console.log(buf1); // 往buffer里面写入数据，如下：
let buf1 = new Buffer.alloc(5);
buf1.write('a');
console.log(buf1);
再来看一个buffer的示例：
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：可写流
前面我们学习了fs模块，在fs中，读取文件的api是readFile，但是这个api其实是nodejs已经给你封装过一次，其实读取文件的底层，仍然是采用流的操作来读取。接下来，我们来通过流的形式来读取文件：
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 方法，当我们处理大型文件，效率就要高一些，它相当于在两个流文件之间建立了一个管道。
接下来我们来使用 pipe 方法简化上面的文件操作的步骤：
const fs = require('fs');
// 创建一个可读流
const rs = fs.createReadStream('./test.txt');
// 创建一个可写流
const ws = fs.createWriteStream('./test3.txt');
rs.setEncoding('utf8');
rs.pipe(ws);
资源压缩
在做web 开发的时候，服务器端向客户端返回数据，往往这个数据需要将其压缩，
（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);