day32 node的模块讲解

1.node的模块划分

内置模块（不需要安装）

• http (提供http服务的)
• fs （fileSystem 文件系统）
• url （url地址）
• path （路径）
• event （事件源）
• net （通信）
• io （流）
• .....

第三方模块（需要安装）

• express
• md5
• jwt
• ...

2.node的模块化

基于 common.js ( 服务端的模块技术 ) 主要使用到的是 require.js

3.require.js的相关操作

导入 require

const 变量名 = require('路径地址')

//require导出 他可以省略对应的js后缀 导入的是文件夹默认去找文件夹下index.js文件
// const obj = require('./require.js的基本使用')
const {age,name,arr,sayHello} = require('./require.js的基本使用')
const obj = require('./hello')
// console.log(obj.age);
// console.log(obj.arr);
// console.log(obj.name);
// obj.sayHello()
sayHello()
console.log(obj.name);

导出 module.export

module.exports = 导出的内容

//导出的内容
//只能导出一遍
module.exports = {
    name:'jack',
    age:18,
    arr:[1,2,3],
    sayHello(){
        console.log('hello');
    }
}

注意事项（如果需要导入 必须先导出）

4.HTTP模块讲解

http 模块是提供 http 服务的，他可以提供对应的接口供对应的客户端（ http 请求）来访问

入门使用

1. 导入对应的模块包

const http = require('http')//所有的不是自己书写的模块填入对应的对应的模块名（自己书
写的模块必须填入路径名 携带./）

2. 创建对应的服务（监听对应的ip地址和端口号）

let server = http.createServer()
//必须传入端口号 主机名默认为localhost （1-65525）
server.listen('8888',()=>{
console.log('server is running at localhost:8888')
})

3. 相关处理（在对应的服务创建的时候传入对应的处理函数进行处理）

let server = http.createServer((req,res)=>{
//req表示请求（用来获取相关的请求详情） res表示响应（设置相关内容给到别人）
console.log(req.url) //获取请求地址
console.log(req.method) //获取请求方式
res.end() //响应结束

代码

//导入模块
const http = require('http')
//创建服务 使用createServer方法 传入一个处理函数 处理函数内容会存在俩个参数 分别是请求对象和响应对象
let server = http.createServer((req,res)=>{
    console.log(req.url) //获取请求地址
	console.log(req.method) //获取请求方式
	res.end('hello node!!') //响应结束
})
//监听端口号
server.listen('8888',()=>{
    console.log('server is running at localhost:8888')
})

浏览器访问 localhost:8888

中文乱码解决

//中文会出现乱码 乱码的原因是我响应出去的数据格式和对应的浏览器不一致
//设置响应出去的内容格式
//通过响应来设置一个内容格式的响应头
res.setHeader('Content-type','text/html;charset=utf-8')

路由处理

使用对应的 url 模块的 parse 方法获取对应的路由地址

//导入模块
const http = require('http')
//url模块 用于处理对应的url
const {parse} = require('url')
//创建服务 使用createServer方法 传入一个处理函数 处理函数内容会存在俩个参数 分别是请求对象和响应对象
let server = http.createServer((req, res) => {
    res.setHeader('Content-type', 'text/html;charset=utf-8')
    //得到路由地址
    let router = parse(req.url).pathname
    console.log(router);
    switch (router) {
        case '/user':
            res.end('用户页面')
            break;
        case '/home':
            res.end('主页')
            break;
        case '/list':
            res.end('列表页')
            break;
        default:
            res.end('欢迎来到某某系统')
    }

})
//监听端口号
server.listen('8888', () => {
    console.log('server is running at localhost:8888')
})

利用http模块完成一个登录注册案例

根据 id 来获取对应的用户

case "/searchByID"://根据id查找对应的用户 get
//监听请求数据传递 获取传递的数据id http://127.0.0.1:9999/searchByID?id=1
// req.url存在传递的数据 对于的数据里面?传递的参数进行提取
// console.log(queryByUrl(req.url));
//得到get传递的参数
// let params = queryByUrl(req.url)
let params = parse(req.url,true).query
//通过参数去找对应的uers里面的数据 返回对应的数据
let filterArr = users.filter(user=>user.id == params.id)
if(filterArr[0]){//有这个id
//只能写字符串和buffer类型
res.write(JSON.stringify({
code:200,
message:'OK',
data:filterArr[0]
}))
}else{//没有这个id
res.write(JSON.stringify({
code:200,
message:'OK',
data:null
}))
}
res.end()
break;

自定义封装的获取url里面参数的方法

//提取对应url地址的数据 返回参数对象
const queryByUrl = (url)=>{
let params = {}
//http://127.0.0.1:9999/searchByID?id=1&name='jack' ===> {id:1}
let strArr = url.split('?')[1].split('&') //id=1 name='jack'
//遍历字符串数组
strArr.forEach(str => {
params[str.split('=')[0]] = str.split('=')[1]
});
return params
}

通过url模块的parse方法来获取get传递的参数

let params = parse(req.url,true).query

登录

case "/login"://登录 post
//获取数据 body里面 观察者模式（event对象 http模块里面导入了event模块）
//body里面的数据是分段传递的
//监听请求数据的传递 
req.on('data',(chunk)=>{
    params += chunk
})
//监听请求结束
req.on('end',()=>{
    //queryString 自动将对应的请求字符串转为对象
    let {username,password} = decode(params)
    //根据获取的参数进行对应的操作（验证）
    let filter = users.filter(user=>{
        return username == user.username && password == user.password
    })
    if(filter[0]){
        res.write(JSON.stringify({
            code:'200',
            message:'登录成功',
            data:filter[0]
        }))
    }else{
        res.write(JSON.stringify({
            code:'200',
            message:'登录失败',
            data:null
        }))
    }
    res.end()
})
break;

获取post请求的参数

• 监听请求的data事件（分段传递）
• 监听请求的end事件 （得到是请求体的字符串）
• 利用querystring模块里面decode方法将字符串转为对象

注册

case "/register"://注册 post
//获取数据
req.on('data',(chunk)=>{
    params += chunk
})
req.on('end',()=>{
    //将对应的数据转换对象
    let {username,password,sex,address} = decode(params)
    //判断当前用户是否已经注册
    if(users.some(user=>user.username == username)){
        //当前用户已经存在
        res.write(JSON.stringify({
            code:200,
            message:'当前用户已经注册',
            data:null
        }))
    }else{
        //创建一个新的用户
        let user = {
            id:v4(),
            username,
            password,
            sex:sex?sex:'男',
            address:address?address:'中国北京',
            createTime:new Date()
        }
        //添加用户
        users.push(user)
        res.write(JSON.stringify({
            code:200,
            message:'注册成功',
            data:user
        }))
    }
    res.end()
})
break;

5.uuid第三库使用

安装

npm i uuid -S

导入

const {v4} = require('uuid')

使用对应的方法

id:v4()

热启动（自动监听对应的文件更新）

nodemon 插件

npm i nodemon -g
nodemon 文件名

supervisor插件

npm i supervisor -g
supervisor 文件名

md5加密模块的使用

安装

npm i md5 -S

导入

const md5 = require('md5')

使用

md5(需要加密的字符串)

解决跨域

给后端设置响应头

res.setHeader('Access-Control-Allow-Origin','*')
res.setHeader('Access-Control-Allow-Origin-Method','*')

完整登录注册

//实现登录注册功能
//导入模块
const http = require('http')
const {
    parse
} = require('url')
//内置querystring parse decode encode
const {
    decode
} = require('querystring')
//第三方模块 uuid 生成id的 生成一个32位的id（不重复的）
const {
    v4
} = require('uuid')
const {
    resolve
} = require('path')
//导入加密的模块 md5 (hash加密法 被破解 加盐（为了安全）)
const md5 = require('md5')
//创建一个users数组来装对应的用户
let users = []
//创建服务
http.createServer((req, res) => {
    //设置响应头
    res.setHeader('content-type', 'text/json;charset=utf-8')
    //解决跨域问题
    res.setHeader('Access-Control-Allow-Origin','*')
    res.setHeader('Access-Control-Allow-Origin-Method','*')
    //解构拿出对应的路由地址和get的参数
    let {
        pathname,
        query
    } = parse(req.url, true)
    //根据路由的路径进行判断
    switch (pathname) {
        case "/login": //登录 post
            getPostParams(req).then(({
                username,
                password
            }) => {
                //根据获取的参数进行对应的操作（验证）
                let filter = users.filter(user => {
                    return username == user.username && md5(password+user.slat) == user.password
                })
                if (filter[0]) {
                    res.write(JSON.stringify({
                        code: '200',
                        message: '登录成功',
                        data: filter[0]
                    }))
                } else {
                    res.write(JSON.stringify({
                        code: '200',
                        message: '登录失败',
                        data: null
                    }))
                }
                res.end()
            })
            break;
        case "/register": //注册 post
            getPostParams(req).then(({
                username,
                password,
                sex,
                address
            }) => {
                //判断当前用户是否已经注册
                if (users.some(user => user.username == username)) {
                    //当前用户已经存在
                    res.write(JSON.stringify({
                        code: 200,
                        message: '当前用户已经注册',
                        data: null
                    }))
                } else {
                    let slat = Math.ceil(Math.random()*1000+1000).toString(36)
                    //创建一个新的用户
                    let user = {
                        id: v4(),
                        username,
                        password:md5(password+slat),
                        sex: sex ? sex : '男',
                        address: address ? address : '中国北京',
                        createTime: new Date(),
                        slat //为了解密
                    }
                    //添加用户
                    users.push(user)
                    res.write(JSON.stringify({
                        code: 200,
                        message: '注册成功',
                        data: user
                    }))
                }
                res.end()
            })
            break;
        case "/searchByID": //根据id查找对应的用户 get
            //监听请求数据传递 获取传递的数据id http://127.0.0.1:9999/searchByID?id=1
            // req.url存在传递的数据 对于的数据里面?传递的参数进行提取
            // console.log(queryByUrl(req.url));
            //得到get传递的参数
            // let params = queryByUrl(req.url) 
            //通过参数去找对应的uers里面的数据 返回对应的数据
            let filterArr = users.filter(user => user.id == query.id)
            if (filterArr[0]) { //有这个id
                //只能写字符串和buffer类型
                res.write(JSON.stringify({
                    code: 200,
                    message: 'OK',
                    data: filterArr[0]
                }))
            } else { //没有这个id
                res.write(JSON.stringify({
                    code: 200,
                    message: 'OK',
                    data: null
                }))
            }
            res.end()
            break;
    }
}).listen('9999', '127.0.0.1', () => {
    console.log('server is running,at 127.0.0.1:9999')
})
//封装返回对应的post请求的数据
const getPostParams = (req) => {
    return new Promise((resolve, reject) => {
        let params = ''
        //获取数据 body里面 观察者模式（event对象 http模块里面导入了event模块）
        //body里面的数据是分段传递的
        //监听请求数据的传递 
        req.on('data', (chunk) => {
            params += chunk
        })
        //监听请求结束
        req.on('end', () => {
            //queryString 自动将对应的请求字符串转为对象
            resolve(decode(params))
        })
        //监听请求出错
        req.on('error', (error) => {
            reject(error)
        })
    })
}