node模块分类

最新推荐文章于 2024-05-21 19:09:41 发布

苦逼的猿宝

最新推荐文章于 2024-05-21 19:09:41 发布

阅读量776

点赞数 26

分类专栏： node 文章标签： vue.js javascript node es6

本文链接：https://blog.csdn.net/GAGGAAAAA/article/details/136516647

版权

node 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

模块

分类

在node种有很多模块，有我们自己写的javascript文件，也会有javascript自带的，还有我们可以下载别人写好的javascript。主要分为三大类。

1. 内置模块

在安装node的时候就自带的模块，比如说http、fs、path等。
内置模块一般在我们安装node的目录中,如果是默认安装，一般在C:\Program Files\nodejs\node_modules\npm\node_modules
引入内置模块require里面只需要写模块名称，node会自动给你找到模块的文件

util模块使用

Node中的工具方法模块

util.inspect是一个将任意对象转成为字符串的方法，通常用于调试和错误的输出

    const util = require('util')
    const obj = [
        {
            a: {
                b: {
                    c: 2
                }
            }
        }
    ]
    console.log(obj) // 带颜色，看不到最深的层级
    console.log(util.inspect(obj, false, 10)) // 不带颜色,查看更深的层级

http模块的使用

Node中提供了http模块，其中封装了高效的http服务器和http客户端（既可以作为客户端也可以作为服务端）

创建一个的HTTP服务器

使用http.Server类

    const http = require('http')
    // 创建一个实例
    const server = new http.Server()
    // 接受用户的请求
    server.on('request', (req,res)=>{
        // 查看前端请求地址、请求方式、请求头
        console.log(req.url)
        console.log(req.method)
        console.log(req.headers)
        // 书写响应状态码和响应的数据格式
        res.writeHead(200, {'Content-Type': 'text/html'})
        // 返回响应的内容
        res.write('hello world');
        // 结束响应，否则会一直等待结束
        res.end()
    })
    // 每启动一个服务都需要有一个端口号支持 此处我们使用的8080端口号
    server.listen(8080, ()=> {
        console.log('服务已在localhost:8080启动')
    })

使用http.createServer方法

    const http = require('http')
    const con = http.createServer((req,res)=>{
        // 查看前端请求地址、请求方式、请求头
        console.log(req.url)
        console.log(req.method)
        console.log(req.headers)
    // 书写响应状态码和响应的数据格式
    res.writeHead(200, {'Content-Type': 'text/html'})
    // 返回响应的内容
    res.write('hello world');
    // 结束响应，否则会一直等待结束
    res.end()
    })
    // 每启动一个服务都需要有一个端口号支持 此处我们使用的8081端口号
    con.listen(8081, ()=> {
        console.log('服务已在localhost:8081启动')
    })

接受get请求发送过来的数据，get请求的参数都是拼接在地址后面，Nodejs的url模块中的parse函数提供了这个功能

    const http = require('http')
    const url = require('url')
    http.createServer((req, res) => {
        // get方式在url地址后面，我们可以通过截取
        console.log(req.url)
        // 截取参数部分通过url模块
        console.log(url.parse(req.url).search)
        // 书写响应状态码和响应的数据格式
        res.writeHead(200, { 'Content-Type': 'text/html' })
        // 返回响应的内容
        res.write('hello world');
        res.end()
    }).listen(8080, () => {
        console.log('服务已在8080启动')
    })

接受post请求发送过来的数据，post请求的参数是在请求体里面，获取需要一段一段接受，Nodejs里面querystring模块parse函数可以解析获取到的数据

    <!-- 前端表单的方式模拟post请求 -->
    <form action="http://localhost:8080" method="post">
        <input type="text" name="username">
        <input type="password" name="password">
        <button>提交</button>
    </form>

    const http = require('http');
    const querystring = require('querystring')
    http.createServer((req, res) => {
        // post接受数据的方式是以流方式接收 一段一段接收
        // 定义一个变量用来保存所有数据
        let postData = ''
        req.on('data', function(chunk){
            console.log(chunk);
            // 将每一段数据拼接保留
            postData+=chunk
        })
        // 当我们将整个数据接受结束之后会执行这个函数
        req.on('end', function(){
            // 最终我们接受到的数据就是完整的数据
            console.log(postData)
            // 但是这个数据现在是字符串的格式
            console.log(typeof postData)
            // 需要利用node中自带模块querystring解析
            const data = querystring.parse(postData)
            console.log(data)
            // 这样我们就可以使用这个数据了
            console.log(data.username)
            console.log(data.password)
        })
        // 书写响应状态码和响应的数据格式
        res.writeHead(200, { 'Content-Type': 'text/html' })
        // 返回响应的内容
        res.write('hello world');
        res.end()
    }).listen(8080, () => {
        console.log('服务已在8080启动')
    })

http.request是一个HTTP客户端工具

利用http.get方法发起get请求，此处以获取千峰官网为例，其实这就可以做个简单的爬虫了

    const http = require('http')
    http.get('http://www.mobiletrain.org/?pinzhuanbdtg=biaoti', (res)=>{
        let html = ''
        res.on('data', (chunk)=>{
            html+=chunk
        })
        res.on('end', ()=>{
            console.log(html)
        })
    })

利用http.request可以发起post和get请求

    const http = require('http')
    const querystring = require('querystring')
    const postData = querystring.stringify({
        'a': 1
    });

    const options = {
        hostname: 'localhost',
        port: 8080,
        path: '/',
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Content-Length': Buffer.byteLength(postData)
        }
    };

    const req = http.request(options, (res) => {
        console.log(`状态码: ${res.statusCode}`);
        console.log(`响应头: ${JSON.stringify(res.headers)}`);
        res.setEncoding('utf8');
        res.on('data', (chunk) => {
            console.log(`响应主体: ${chunk}`);
        });
        res.on('end', () => {
            console.log('响应中已无数据。');
        });
    });
    req.on('error', (e) => {
        console.error(`请求遇到问题: ${e.message}`);
    });
    req.end();

fs模块的使用

fs模块用于对系统文件及目录进行读写操作。
fs设计到文件的操作，文件操作会受到文件大小的影响，所以代码执行的时间是无法预估的，node提供了同步和异步的操作方式。
同步
- fs.mkdirSync 创建目录
- fs.rmdirSync 删除目录
- …

异步

fs.mkdir 创建目录

    const fs = require('fs')
    fs.mkdir('./logs', function(err){
        console.log('done...')
    })

fs.rmdir 删除目录

    const fs = require('fs')
    fs.rmdir('./logs', function(err){
        console.log('done...')
    })

fs.readFile 读取文件

    // 使用回调函数
    var fs=require("fs");
    fs.readFile("E:\\test\\test10\\server\\config.json","utf8",function(err,data){
        console.log(err);
        console.log(data.toString());
    })

    // 使用promise方式
    const fs = require('fs')
    function getText(){
        return new Promise((resolve,reject)=>{
            fs.readFile('./logs/log-0.txt', 'utf-8', function(err,data){
                if(err) reject(err)
                resolve(data)
            })
        })
    }
    getText().then(res=>{
        console.log(res)
    })

    // 使用async await方式
    const fs = require('fs')
    function getText(){
        return new Promise((resolve,reject)=>{
            fs.readFile('./logs/log-0.txt', 'utf-8', function(err,data){
                if(err) reject(err)
                resolve(data)
            })
        })
    }
    async function fn(){
        const res = await getText()
        console.log(res)
    }
    fn()

fs.writeFile 写入文件文件不存在会自动创建会覆盖之前文件内容

    fs.writeFile('a.txt', '文本内容', 'utf8', function(err){
    });

fs.appendFile 追加写入文件文件不存在会自动创建会在原来内容的后面追加
```
    fs.appendFile('a.txt', '文本内容', 'utf8', function(err){
    });
```

path模块的使用

node为了解决本地路径提出的一个方法集
属性
- __dirname 获取当前运行文件的文件夹地址
- __filename 获取当前运行文件的文件名地址

方法

path.join 使用平台特定的分隔符作为定界符将所有给定的 path 片段连接在一起，然后规范化生成的路径。

    const path = require('path');
    const str=path.join('/foo', 'bar', 'baz/asdf');
    console.log(str);

path.basename 返回路径中最后的部分,可以去掉扩展名。

    var str=path.join('/foo', 'bar', 'baz/asdf.txt');
    console.log(path.basename(str));
    console.log(path.basename(str,".txt"))

path.dirname 返回路径中目录名

    var str=path.join('/foo', 'bar', 'baz/asdf.txt');
    console.log(path.dirname(str));

path.extname 返回路径中的扩展名

    var str=path.join('/foo', 'bar', 'baz/asdf.txt');
    console.log(path.extname(str));

path.resolve 相当于cd命令

    path.resolve(__dirname, '..')

path.parse 将字符串对象转换为对象

    const path = require('path');
    var str='D:\\node\\qf-admin\\logs\\log-0.txt';
    console.log(path.parse(str)); 
    /* 
        {
            root: 'D:\\',
            dir: 'D:\\node\\qf-admin\\logs',
            base: 'log-0.txt',
            ext: '.txt',
            name: 'log-0'
        }
    */

path.format 将path对象转换为字符串

    var str=path.join('/foo', 'bar', 'baz/asdf.txt');
    var obj=path.parse(str);
    console.log(path.format(obj))

url模块的使用

node为了解决线上地址提出的一个方法

方法

url.parse(网址) 将一个网址解析成一个对象，对象里面的key就是网址各个组成部分

    const url = require('url');
    console.log(url.parse('https://jack:123456@www.baidu.com:443/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&rqlang=cn&rsv_enter=1&rsv_dl=tb&rsv_btype=t&inputT=3647&rsv_sug3=20#hash'))

   const url = require('url');
   console.log(url.parse('https://jack:123456@www.baidu.com:443/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&rqlang=cn&rsv_enter=1&rsv_dl=tb&rsv_btype=t&inputT=3647&rsv_sug3=20#hash', true))

url.format(对象) 将一个对象转换成网址

    const url = require('url');
    var urlObj = {
        protocol: 'https:',
        slashes: true,
        auth: 'jack:123456',
        host: 'www.baidu.com:443',
        port: '443',
        hostname: 'www.baidu.com',
        hash: '#hash',
        search: '?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&rqlang=cn&rsv_enter=1&rsv_dl=tb&rsv_btype=t&inputT=3647&rsv_sug3=20',
        query: 'ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&rqlang=cn&rsv_enter=1&rsv_dl=tb&rsv_btype=t&inputT=3647&rsv_sug3=20',  
        pathname: '/s',
        path: '/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&rqlang=cn&rsv_enter=1&rsv_dl=tb&rsv_btype=t&inputT=3647&rsv_sug3=20',
        href: 'https://jack:123456@www.baidu.com:443/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=baidu&rqlang=cn&rsv_enter=1&rsv_dl=tb&rsv_btype=t&inputT=3647&rsv_sug3=20#hash'
    }
    console.log(url.format(urlObj))

url.resolve 返回从根目录指定到当前目录的绝对路径url。返回结果去除参数和锚点，返回结果标准url路径格式

    var url=require('url');  
    //指定相对路径  
    var url1=url.resolve('http://qingk.cn/one/two/three','four');  
    console.log(url1); //http://qingk.cn/one/two/four  
    //指定根目录的相对路径  
    var url3=url.resolve('http://qingk.cn/one/two/three','/four');  
    console.log(url3); //http://qingk.cn/four  
    //带参数的相对路径  
    var url2=url.resolve('http://qingk.cn/one/two/three?name=zhangsan','four');  
    console.log(url2); //http://qingk.cn/one/two/four  
    //非标准分隔符的原路径  
    var url4=url.resolve('http://qingk.cn\\one#name1','/four');  
    console.log(url4);//http://qingk.cn/four  
    //非标准分隔符的相对路径  
    var url5=url.resolve('http://qingk.cn/one','\\two\\three');  
    console.log(url5);//http://qingk.cn/two/three 
        ```

querystring的使用

node中处理地址参数的模块

querystring.parse 把一个URL参数解析成一个键值对的集合

    const queryStr = require('querystring')
    let url = 'name=lxc&age=20&height=&weight=120'
    console.log(queryStr.parse(url))

querystring.stringify 此方法是 querystring.parse方法的逆向操作

querystring.escape 对传入的字符串进行编码

    console.log(queryStr.escape('name=lxc&age=20'))

querystring.unescape 对传入的字符串进行解码

    console.log(queryStr.unescape('name%3Dlxc%26age%3D20'))

2. 第三方模块

第三方模块也称为第三方依赖，一般我们使用的时候需要下载，然后才能使用
下载也不需要我们自己去网上找然后下载，只需要通过npm工具
比如说我们后来会使用到的mysql，默认node并没有自带，用的时候需要安装
引入第三方模块require里面也只需要写模块名称，node会自动给你找到模块的文件

3. 自定义模块

自定义模块是我们自己实现业务逻辑的javascript文件
og(queryStr.escape(‘name=lxc&age=20’))

querystring.unescape 对传入的字符串进行解码

    console.log(queryStr.unescape('name%3Dlxc%26age%3D20'))

2. 第三方模块

第三方模块也称为第三方依赖，一般我们使用的时候需要下载，然后才能使用
下载也不需要我们自己去网上找然后下载，只需要通过npm工具
比如说我们后来会使用到的mysql，默认node并没有自带，用的时候需要安装
引入第三方模块require里面也只需要写模块名称，node会自动给你找到模块的文件

3. 自定义模块

自定义模块是我们自己实现业务逻辑的javascript文件
引入自定义模块需要在require里面写文件的相对地址

苦逼的猿宝

关注

26
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
0
评论
node模块分类

自定义模块是我们自己实现业务逻辑的javascript文件querystring.unescape 对传入的字符串进行解码 console.log(queryStr.unescape('name%3Dlxc%26age%3D20'))自定义模块是我们自己实现业务逻辑的javascript文件引入自定义模块需要在require里面写文件的相对地址。
复制链接

扫一扫