nodejs 内置模块初学

nodejs 内置模块

文件操作

在 nodejs 中,提供了 fs 模块,来供我们操作文件。在 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');
  1. 文件的追加

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

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');
  1. 文件的读取
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');
  1. 文件的复制
fs.copyFile()

具体示例如下:

const fs = require('fs');
fs.copyFile('./test.txt','./test5.txt',(err)=>{
     
    if(err) throw err
})
  1. 获取文件信息

通过 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:判断是否为目录
  1. 删除文件
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!');
})
  1. 读取目录
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);

你可能感兴趣的:(NodeJS,nodejs,javascript,js)