node中的模块导入和导出

  • 在node中使用module.exports导出一个模块

  • 在node中使用require导入一个模块 ```javascript function add(a,b){ return a+b; } module.exports = add//导出一个模块

const add=require(“./index”)//导入一个模块，其中require是一个函数，接收一个路径作为参数 const sum=add(10,20); console.log(sum)

//在导入模块的过程中可以按需导入，前提是导出的是一个对象=>es6中的解构赋值 const {name,add}=require(“./index”)

  4. <a name="fae773c5"></a>
  5. ### 在node中创建一个http服务
  7. - 
  8. 通过`http`模块创建一个http服务
  9. ```javascript
  10. //http.createServer创建一个http服务
  11. //获取请求头req.headers["content-type"]
  12. const server=http.createServer((req,res)=>{
  13.     // writeHead()方法用于设置响应数据的响应头headers
  14.     //第一个参数为响应的状态码，第二个参数为响应头
  15.     res.writeHead(200,{"content-type":"text/html"})//设置响应数据的响应头
  17.     res.end("<h1>hello word</h1>")//发送响应信息
  18. })
  20. //监听一个3000端口
  21. server.listen(3000,()=>{
  22.     console.log("创建一个http服务成功")
  23. })
  • 处理get请求 ```javascript const http = require(“http”); const querystring = require(“querystring”);

const server=http.createServer((req,res)=>{ console.log(req.method)//返回请求的方式 const url=req.url; console.log(“请求的url地址:”+url); req.query=querystring.parse(url.split(“?”)[1])//parse默认使用&分割查询字符串 console.log(req.query) res.end( JSON.stringify(req.query)//向前端返回json格式的数据 ) }) server.listen(3000,()=>{ console.log(“创建服务成功”) })

  3. - 
  4. 处理post请求
  5. ```javascript
  6. const http  = require("http");
  8. const server=http.createServer((req,res)=>{
  9.     if(req.method==='POST'){
  10.         //req的数据格式
  11.         console.log("req content-type："+req.headers['content-type'])
  12.     }
  13.     //接收到的数据
  14.     let postData="";
  16.     //监听请求数据的发送
  17.     req.on("data",chunk=>{
  18.         postData+=chunk.toString();
  19.     })
  20.     //监听数据发送结束
  21.     req.on("end",()=>{
  22.         console.log(postData)
  23.         res.end("请求发送成功")
  24.     })
  25. })
  26. server.listen(3000)
  • node综合处理get和post请求 ```javascript const http = require(“http”); const querystring = require(“querystring”);

const server=http.createServer((req,res)=>{ const method=req.method;//获取请求的方式

const url=req.url;//获取前端请求的url地址

const path=url.split(“?”)[0]//获取前端的网页地址

const query=querystring.parse(url.split(“?”)[1])//获取查询字符串

//设置返回的数据为json

//设置响应数据的响应头 res.setHeader(“Content-type”,”application/json”); //返回的数据 const resData={ method,url,path,query }

  1. if(method==='GET'){
  2.     res.end(
  3.         JSON.stringify(resData)//设置返回字符串的格式
  4.     )
  5. }
  6. else if(method==='POST'){
  7.     let postData=""
  8.     //监听前端发送过来的数据，当前端有数据发送过来时，传递给chunk
  9.     req.on("data",(chunk)=>{
  10.         postData=chunk.toString()
  11.     })
  13.     //监听前端发送数据结束，执行回调函数
  14.     req.on("end",()=>{
  15.         resData.postData=postData;
  16.         res.end(
  17.             JSON.stringify(resData)//设置返回字符串的格式
  18.         )
  19.     })
  20. }

}) server.listen(3000)

  4. <a name="202459f0"></a>
  5. ### nodemon使用
  7. - 
  8. nodemon检测文件变化，自动重启node
  9. ```javascript
  10. //安装nodemon     cnpm i nodemon -g
  11. //安装cross-env   cnpm i cross-env -S
  13. //配置
  14. "scripts": {
  15.     "test": "echo \"Error: no test specified\" && exit 1",
  16.     "dev":"cross-env NODE_ENV=dev nodemon ./bin/www.js",
  17.     "prd":"cross-env NODE_ENV=production nodemon ./bin/www.js"
  18. }
  20. //创建响应文件 ./bin/www.js
  • cross-env是用来设置不同的运行环境

node中的cookie和session

cookie

  • 存储在浏览器中的一段字符串(最大5kb)
  • 跨域不共享

server操作cookie

  1. //获取cookie
  2. //解析cookie
  3. req.cookie={}
  4. const cookieStr=req.headers.cookie||""//cookie的格式是k1=1;k2=2;k3=3
  5. cookieStr.split(";").forEach(item=>{
  6.     if(!item){
  7.         return 
  8.     }
  9.     const arr=item.split("=")
  10.     const key=arr[0]
  11.     const val=arr[1]
  13.     req.cookie[key]=val
  14. })
  16. //设置cookie的值，path参数表示这个cookie可以在所有的网页都能访问，httpOnly参数限制cookie不能修改
  17. //expires参数设置cookie的过期时间
  18. const getCookieExpire = () => {
  19.     const d = new Date();
  20.     d.setTime(d.getTime() + (24 * 60 * 60 * 1000))
  21.     return d.toGMTString();
  22. }
  23. res.setHeader("Set-Cookie", `username=${data.username};path=/;httpOnly;expires=${getCookieExpire()}`)

session

  1. const SESSION_DATA = {}
  2.  //解析session
  3. let needSetCookie=false//标志userid是否已经存在
  4. let userId = req.cookie.userid
  5. if (userId) {
  6.     if (!SESSION_DATA[userId]) {
  7.         SESSION_DATA[userId] = {}
  8.     }
  9. }
  10. else {
  11.     needSetCookie=true
  12.     userId = `${Date.now()}_${Math.random()}`
  13.     SESSION_DATA[userId] = {}
  14. }
  15. req.session = SESSION_DATA[userId]
  16. //设置数据
  17. req.session.username=data.username;
  18. req.session.realName=data.realName;

redis

  • web server最常用的缓存数据库，数据存放在内存中

  • 相比于mysql，访问速度快（内存和硬盘不是一个数量级的）

  • 成本高，可存储的数据量小

  • 安装redishttps://github.com/microsoftarchive/redis/releases

  • 启动redis

    • 打开一个cmd窗口进入redis安装目录redis-server.exe redis.windows.conf
    • 在redis目录下再打开一个cmdredis-cli.exe -h 127.0.0.1 -p 6379

node中使用redis

  • 安装rediscnpm i redis -S
  1. //导入redis模块
  2. const redis=require("redis")
  4. //创建redis客户端 端口对应redis启动时的端口号
  5. const redisClient=redis.createClient(6379,"127.0.0.1")
  7. //监听redis客户端是否发生异常
  8. redisClient.on("error",err=>{
  9.     console.log(err)
  10. })
  12. //测试  redis.print设置了这个参数会打印出设置是否成功
  13. //向redis中添加数据
  14. redisClient.set("myname","张三",redis.print)
  16. //获取redis中的数据
  17. redisClient.get("myname",(err,val)=>{
  18.     if(err){
  19.         return console.log(err)
  20.     }
  21.     console.log(val)
  23.     //退出
  24.     redisClient.quit()
  25. })
  • 对获取数据和设置数据的封装 ```javascript function set(key, val) { //测试 redis.print设置了这个参数会打印出设置是否成功 if (typeof val === ‘object’) {
    1.   val = JSON.stringify(val)
    } redisClient.set(key, val, redis.print) }

function get(key) { return new Promise((resolve, reject) => { redisClient.get(key, (err, val) => { if (err) { return reject(err) }

  1.         if (val == null) {
  3.             return resolve(null)
  4.         }
  6.         try {
  7.             resolve(JSON.parse(val))
  8.         } catch (error) {
  9.             resolve(val)
  10.         }
  11.     })
  12. })

}

  4. <a name="nginx"></a>
  5. ### nginx
  7. - 
  8. [基本使用方式](https://blog.csdn.net/u011418717/article/details/52776090)
  10. - 
  11. 高性能的web服务器，开源免费
  13. - 
  14. 一般用于做静态服务，负载均衡
  16. - 
  17. 反向代理(对客户端不可见的代理,实现前后端跨域访问)
  19. - 
  20. 测试配置文件格式是否正确`nginx -t`
  22. - 
  23. 启动`start nginx`，重启`nginx -s reload`
  25. - 
  26. 停止`nginx -s stop`
  28. - 
  29. 配置
  30. ```javascript
  31. //通过server属性配置多个服务器的地址，当一个服务器不能使用，nginx自动检索下一个
  32. upstream local_tomcat {  
  33.     server localhost:8001;  
  34.     server localhost:4000;  
  35. } 
  36. server {
  37.     listen       8080;//nginx服务器的端口号
  38.     server_name  localhost;
  40.     location /{
  41.         proxy_pass http://localhost:8001;//当访问127.0.0.1:8080/时nginx服务器代理默认跳到http://localhost:8001
  42.         #proxy_pass http://local_tomcat =>upstream的使用
  43.     }
  44.     location /api/{
  45.         proxy_pass http://localhost:8000;//当访问127.0.0.1:8080/api/时nginx服务器代理默认跳到http://localhost:8000
  46.         proxy_set_header Host $host;//由于访问的地址是localhost:8080/api/...,而实际需要访问的地址是http://localhost:8000/api/...,两个的请求头localhost:8080(localhost:8000)不相同，如果后端设置有请求头限制比如只能访问localhost:8000，那么就会报错，所以设置proxy_set_header Host $host就是为了当在向后端发送请求时，指定请求头为 proxy_pass指定的值
  47.     }
  49. }

node操作文件

  • 读取文件
  1. //读取文件的模块
  2. const fs=require("fs")
  3. //拼接文件路径的模块
  4. const path=require("path")//用于拼接路径，由于不能的系统路径不一样，因此使用这个模块，能够保证路径的统一
  5. const filename=path.resolve(__dirname,"data.txt")//获取当前目录下的data.txt文件的路径名
  7. //读取文件内容
  8. //参数1为文件的路径，参数2为回调函数
  9. fs.readFile(filename,(err,data)=>{
  10.     if(err){
  11.         return console.log(err)
  12.     }
  13.     console.log(data.toString())
  14. })
  • 写入文件
  1. const fs=require("fs")
  3. const path=require("path")//用于拼接路径，由于不能的系统路径不一样，因此使用这个模块，能够保证路径的统一
  5. const filename=path.resolve(__dirname,"data.txt")//获取当前目录下的data.txt文件的路径名
  7. //写入文件
  8. const content="11111111111111111111111111111111"
  9. const opt={
  10.     flag:'a',//追加写入,覆盖用'w'
  11. }
  12. //参数1是写入文件的路径，
  13. //参数2为向文件写入的内容，
  14. //参数3为写入的方式，a表示追加写入，w覆盖写入
  15. //参数4是一个回调函数
  16. fs.writeFile(filename,content,opt,(err)=>{
  17.     if(err){
  18.         return console.log(err)
  19.     }
  20. })
  • 判断文件是否存在
  1. //判断文件是否存在
  2. fs.exists(filename,(exist)=>{
  3.     console.log(exist)//文件存在返回true，否则为false
  4. })
  • stream操作文件
  1. const fs = require("fs")
  2. const path = require("path")
  3. //被读取的文件路径
  4. const filename1 = path.resolve(__dirname, "data1.txt")
  5. //写入内容的文件路径
  6. const filename2 = path.resolve(__dirname, "data2.txt")
  8. //读取文件的stream对象
  9. const readStream = fs.createReadStream(filename1);
  10. //写入文件的stream对象
  11. const writeStream = fs.createWriteStream(filename2);
  13. //执行拷贝，通过pipe
  14. readStream.pipe(writeStream);
  15. //拷贝结束
  16. readStream.on("end",(err)=>{
  17.     if(err){
  18.         console.log(err)
  19.     }
  20. })
  • 请求读取文件
    1. const path=require("path")
    2. const fs=require("fs")
    3. const http=require("http")
    4. const filename1 = path.resolve(__dirname, "data1.txt")
    5. const filename2 = path.resolve(__dirname, "data2.txt")
    6. http.createServer((req,res)=>{
    7.   if(req.method==="POST"){
    8.       let postData="";
    9.       req.on("data",chuck=>{
    10.           postData=chuck.toString();//json格式的字符串
    11.       })
    12.       req.on("end",()=>{
    13.           postData=JSON.parse(postData)
    14.           if(postData.filename==="data1"){
    15.               //读取文件的stream对象
    16.               const readStream = fs.createReadStream(filename1);
    17.               readStream.pipe(res)
    18.           }
    19.           else{
    20.              //读取文件的stream对象
    21.              const readStream = fs.createReadStream(filename2);
    22.              readStream.pipe(res) 
    23.           }
    24.       })
    25.   }
    26. }).listen(8000)
  • node向文件中写日志
    1. const fs=require("fs")
    2. const path=require("path")
    3. //写日志
    4. function writeLog(writeStream,log){
    5.   writeStream.write(log+"\n")
    6. }
    7. //生成write Stream
    8. function createWriteStream(fileName){
    9.   //日志文件的存储地址
    10.   const fullFileName=path.resolve(__dirname,"../","../","logs",fileName)
    11.   const writeStream=fs.createWriteStream(fullFileName,{flags:'a'})
    12.   return writeStream;
    13. }
    14. //写访问日志
    15. const accessWriteStream=createWriteStream('access.log')
    16. function access(log){
    17.   writeLog(accessWriteStream,log)
    18. }
    19. module.exports={
    20.   access
    21. }

node中的md5加密

  1. const crypto=require("crypto");
  3. //密匙
  4. const SECRET_KEY="123456"
  6. //md5加密
  7. function md5(content){
  8.     let md5=crypto.createHash("md5");//创建一个hash对象，创建hash对象使用的算法是md5
  9.     //md5.update(content)使用给定的content更新hash对象的内容，.digest("hex")使用相应的字符编码返回hash值
  10.     return md5.update(content).digest("hex")
  11. }
  13. //加密函数
  14. function getPassword(password){
  15.     const str=`password=${password}&key=${SECRET_KEY}`
  16.     return md5(str)
  17. }
  18. console.log(getPassword(123))

node中连接数据库

  • 安装mysql模块cnpm i mysql -S

  • mysql模块的简介

    1. //导入mysql模块
    2. const mysql=require("mysql")
    3. //创建数据库连接对象
    4. const conn=mysql.createConnection({
    5.   host:"localtion",
    6.   host:"localhost",//数据库连接的ip地址
    7.   user:"root",//连接数据库的用户名
    8.   password:"root",//连接数据库的密码
    9.   port:"3306",//数据库的端口号
    10.   database:"myblog"//数据库的名称
    11. })
    12. //开始连接数据库
    13. conn.connect((err)=>{
    14.   if(err)console.log(err)
    15. })
    16. //封装的一个进行增删改查的函数
    17. function exec(sql){
    18.   return new Promise((resolve,reject)=>{
    19.       con.query(sql,(err,result)=>{
    20.           if(err){
    21.               return reject(err)
    22.           }
    23.           resolve(result)
    24.       })
    25.   })
    26. }

express框架

安装express

  1. cnpm i express-generator -g //安装express脚手架
  2. express express-test //创建express应用
  3. npm start //运行应用

中间件

  • 使用app.use()注册中间件
  • next()上一个中间件触发下一个中间件
  1. const express = require('express');
  2. const cookieParser = require('cookie-parser');
  3. const app=express()
  5. //处理表单提交数据,将处理后的数据挂载到req.body中
  6. app.use(express.urlencoded({ extended: false }))
  8. //处理json格式的数据
  9. app.use(express.json())
  11. //处理cookie
  12. app.use(cookieParser())
  14. //创建一个路由
  15. const router=express.Router();
  17. //注册路由
  18. const blogRouter = require('./routes/blog');
  19. app.use('/api/blog', blogRouter);
  21. //通过express-session处理session数据
  22. //安装 cnpm i express-session -S
  23. //注册
  25. const session =require("express-session")
  26. var cookieParser = require('cookie-parser');
  27. app.use(cookieParser());
  29. app.use(session({
  30.   secret:"qwe",
  31.   cookie:{
  32.     path:"/",//任意路径都能访问
  33.     httpOnly:true,//是否允许修改
  34.     maxAge:24*60*60*1000//过期时间
  35.   }
  36. }))
  37. //获取session
  38. req.session
  • 路由 ```javascript var express = require(‘express’); var router = express.Router();

router.get(‘/list’, function (req, res, next) { res.json({

  1. })

});

router.get(“/detail”,(req,res,next)=>{

})

module.exports = router;

  4. <a name="7b79f329"></a>
  5. #### 使用redis
  7. ```javascript
  8. //安装redis connect-redis模块
  9. //cnpm i redis connect-redis -S
  11. //redis的配置
  12. REDIS_CONF={
  13.     port:6379,
  14.     host:"127.0.0.1"
  15. }
  16. //创建redis客户端
  17. const redis = require("redis")
  18. const { REDIS_CONF } = require("../config/db")
  19. //创建客户端
  20. const redisClient = redis.createClient(REDIS_CONF.port, REDIS_CONF.host)
  21. //监听redis客户端是否产生异常
  22. redisClient.on("error", err => {
  23.     console.log(err)
  24. })
  25. module.exports=redisClient
  27. //将redis与session进行关联
  28. const session =require("express-session")
  29. const RedisStore=require("connect-redis")(session)
  31. const redisClient=require("./db/redis")
  32. const sessionStore=new RedisStore({
  33.   client:redisClient
  34. })
  35. app.use(session({
  36.   secret:"qwe",
  37.   cookie:{
  38.     path:"/",//任意路径都能访问
  39.     httpOnly:true,//是否允许修改
  40.     maxAge:24*60*60*1000//过期时间
  41.   },
  42.   store:sessionStore
  43. }))

日志

  • 使用模块morgan完成日志的输出 ```javascript //morgan的简介https://github.com/expressjs/morgan const logger = require(‘morgan’); / 环境类型 “scripts”: { “start”: “node ./bin/www”, “dev”: “cross-env NODE_ENV=dev nodemon ./bin/www.js”, “prd”: “cross-env NODE_ENV=production nodemon ./bin/www.js” } /

const ENV=process.env.NODE_ENV//获取环境类型 if(ENV!==”production”){ //开发环境/测试环境 app.use(logger(‘dev’)); } else{ //线上环境 const logFilename=path.join(__dirname,”logs”,”access.log”)//拼接文件路径 const writeStream=fs.createWriteStream(logFilename,{ flags:”a” })//创建一个文件日志写入流 app.use(logger(“combined”,{ stream:writeStream//将日志写文件 })) }

  4. <a name="1b2326dc"></a>
  5. #### express实现原理
  7. ```javascript
  8. const http=require("http");
  10. const slice=Array.prototype.slice;
  12. class LikeExpress{
  13.     constructor(){
  14.         //存放中间件的列表
  15.         this.router={
  16.             all:[],//存放使用use注册的中间件
  17.             get:[],//存放使用get注册的中间件
  18.             post:[]//存放使用post注册的中间件
  19.         }
  20.     }
  22.     register(path){
  23.         const info={}
  24.         if(typeof path==="string"){
  25.             info.path=path;
  27.             //从第二个函数开始，转换为数组，存入stack中
  28.             info.stack=slice.call(arguments,1) //数组
  31.             //arguments是类数组对象，有一些数组中的方法它们是没有的
  32.         }
  33.         else{
  34.             info.path="/"
  35.             //从第二个函数开始，转换为数组，存入stack中
  36.             info.stack=slice.call(arguments,0) //数组
  37.         }
  39.         return info;
  40.     }
  42.     use(){
  43.         const info=this.register.apply(this,arguments)
  44.         this.router.all.push(info)
  45.     }
  47.     get(){
  48.         const info=this.register.apply(this,arguments)
  49.         this.router.get.push(info)
  50.     }
  52.     post(){
  53.         const info=this.register.apply(this,arguments)
  54.         this.router.post.push(info)
  55.     }
  57.     match(method,url){
  58.         let stack=[]
  60.         if(url==='/favicon.ico'){
  61.             return stack;
  62.         }
  64.         //获取routes
  65.         let curRoutes=[]
  66.         curRoutes=curRoutes.concat(this.router.all)
  67.         curRoutes=curRoutes.concat(this.router[method])
  70.         curRoutes.forEach(item=>{
  71.             if(url.indexOf(item.path)===0){
  72.                 stack=stack.concat(item.stack)
  73.             }
  74.         })
  76.         return stack;
  77.     }
  79.     //核心的next机制
  80.     handle(req,res,stack){
  81.         const next=()=>{
  82.             //第一个匹配的中间件
  83.             const middleware=stack.shift()
  85.             if(middleware){
  86.                 //执行中间件函数
  87.                 middleware(req,res,next)
  88.             }
  89.         }
  90.         next()
  91.     }
  94.     callback(){
  95.         return (req,res)=>{
  96.             res.json=(data)=>{
  97.                 res.setHeader("Content-type","application/json")
  98.                 res.end(
  99.                     JSON.stringify(data)
  100.                 )
  101.             }
  103.             const url=req.url
  104.             const method=req.method.toLowerCase()
  107.             const resultList=this.match(method,url)
  109.             this.handle(req,res,resultList)
  110.         }
  111.     }
  113.     listen(...args){
  114.         const server=http.createServer(this.callback())
  115.         server.listen(...args)
  116.     }
  117. }
  120. //工厂函数
  121. module.exports=()=>{
  122.     return new LikeExpress();
  123. }
  126. //流程前端发送请求->listen->callback->match->handle

koa2框架

  • express中间件是异步回调，koa2原生支持async/await
  • 简介

安装

  1. koa2的脚手架 npm i koa-generator -g
  2. 初始化环境 Koa2 koa2-test(文件架名字)
  3. 启动 npm i & npm run dev

中间件

  1. const Koa = require('koa')
  2. const app = new Koa()
  4. //出路json格式数据
  5. const json = require('koa-json')
  6. //错误处理
  7. const onerror = require('koa-onerror')
  8. //处理表单提交的数据
  9. const bodyparser = require('koa-bodyparser')
  10. // 日志美化
  11. const logger = require('koa-logger')
  13. //引入路由
  14. const blog=require("./routes/blog")
  16. // error handler
  17. onerror(app)
  19. // 处理表单提交
  20. app.use(bodyparser({
  21.   enableTypes:['json', 'form', 'text']
  22. }))
  24. //处理json格式数据
  25. app.use(json())
  27. //处理日志
  28. app.use(logger())
  31. // 日志处理
  32. app.use(async (ctx, next) => {
  33.   const start = new Date()
  34.   await next()
  35.   const ms = new Date() - start
  36.   console.log(`${ctx.method} ${ctx.url} - ${ms}ms`)
  37. })
  39. // 路由注册
  40. app.use(blog.routes(), blog.allowedMethods())
  42. // 错误处理
  43. app.on('error', (err, ctx) => {
  44.   console.error('server error', err, ctx)
  45. });
  47. module.exports = app
  • 路由 ```javascript const router = require(‘koa-router’)()

router.prefix(“/api/blog”);//设置请求路径的前缀

router.get(‘/list’, function (ctx, next) { const query = ctx.query;//相等于req.query返回查询字符串 ctx.body = {//相当于 error: 0, query, data: [“获取博客列表”] } })

module.exports = router

  4. <a name="75106630"></a>
  5. #### koa中的session
  7. - 
  8. 基于koa-generic-session和koa-redis
  9. ```javascript
  10. //安装插件 cnpm i koa-generic-session koa-redis redis -S
  12. //处理session
  13. const session =require("koa-generic-session")
  15. //处理redis，这个模块依赖redis
  16. const redisStore=require("koa-redis")
  18. // 设置签名的密钥
  19. app.keys=["123"]
  20. //设置session，并将session与redis关联
  21. app.use(session({
  22.   cookie:{
  23.     path:"/",//所有的路由都能使用
  24.     httpOnly:true,//不允许前端修改
  25.     maxAge:24*60*60*1000//有效时间
  26.   },
  27.   store:redisStore({
  28.     all:'127.0.0.1:6379'
  29.   })//配置redis
  30. }))

日志

  1. //安装兼容模块（morgan是express中的模块）cnpm i koa-morgan -S
  2. /*
  3.     环境类型
  4.     "scripts": {
  5.     "start": "node ./bin/www",
  6.     "dev": "cross-env NODE_ENV=dev nodemon ./bin/www.js",
  7.     "prd": "cross-env NODE_ENV=production nodemon ./bin/www.js"
  8.   }
  9. */
  10. const path=require("path")
  12. const fs=require("fs")
  14. const morgan=require("koa-morgan")
  16. const ENV=process.env.NODE_ENV
  17. if(ENV!=="production"){
  18.   //开发环境
  19.   app.use(morgan('dev'));
  20. }
  21. else{
  22.   //线上环境
  24.   const logFilename=path.join(__dirname,"logs","access.log")
  25.   const writeStream=fs.createWriteStream(logFilename,{
  26.     flags:"a"
  27.   })
  28.   app.use(morgan("combined",{
  29.     stream:writeStream
  30.   }))
  31. }

koa2实现原理

  1. const http=require("http")
  2. //组合中间件
  3. function compose(middlewareList){
  4.     return function(ctx){
  5.         //中间的调用
  7.         function dispatch(i){
  8.             const fn=middlewareList[i]
  10.             try{
  11.                 return Promise.resolve(
  12.                     fn(ctx,dispatch.bind(null,i+1))
  13.                 )
  14.             }catch(err){
  15.                 return Promise.reject(
  16.                     err
  17.                 )
  18.             }
  19.         }
  21.         return dispatch(0)
  22.     }
  23. }
  24. class LikeKoa2{
  25.     constructor(){
  26.         this.middlewareList=[]
  27.     }
  29.     use(fn){
  30.         this.middlewareList.push(fn)
  31.         return this
  32.     }
  34.     createContext(req,res){
  35.         const ctx={
  36.             req,res
  37.         }
  39.         return Object.assign(ctx,req,res)
  40.     }
  43.     handleRequest(ctx,fn){
  44.         return fn(ctx)
  45.     }
  47.     callback(){
  48.         const fn=compose(this.middlewareList)
  50.         return (req,res)=>{
  51.             const ctx=this.createContext(req,res)
  52.             return this.handleRequest(ctx,fn)
  54.         }
  55.     }
  57.     listen(...args){
  58.         const server=http.createServer(this.callback())
  60.         server.listen(...args)
  61.     }
  62. }
  63. module.exports=LikeKoa2