koa学习笔记

import和export在node中使用
mongodb学习
1 mongoose的学习
2 先运行mongo.exe再运行项目
3 学完node ,再去看看nuxt和ssr
4 只提供封装好http上下文、请求、响应，以及基于async/await的中间件容器。
利用ES7的async/await的来处理传统回调嵌套问题和代替koa@1的generator，但是需要在node.js 7.x的harmony模式下才能支持async/await。
中间件只支持 async/await 封装的，如果要使用koa@1基于generator中间件，需要通过中间件koa-convert封装一下才能使用。
5 pug和ejs等模板渲染

11 function parseQueryStr( queryStr ) {
  let queryData = {}
  let queryStrList = queryStr.split('&') //数组
  console.log( queryStrList )
  //queryStrList.entries() entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
  //迭代对象中数组的索引值作为 key， 数组元素作为 value。
  for (  let [ index, queryStr ] of queryStrList.entries()  ) {
    let itemList = queryStr.split('=')
    queryData[ itemList[0] ] = decodeURIComponent(itemList[1])
  }
  return queryData
}

6 Node.js 的基础知识
http 模块的使用
fs 模块使用
path 模块使用
Buffer 类型
7 node.js或许真是js+node API+第三方生态圈 的学习
8 测试框架和express egg
9 import和export
10 上传文件和图片 增删改查 **实现

koa 中间件引擎
中间件原理
中间件在await next()前后操作，像数据结构栈，先进后出
1 有统一context
2 操作先进后出
3 有控制先进后出的机制next
4 有提前结束机制
利用promise可以实现中间件流程，但是可读性和可维护性不好

Promise.resolve(middleware1(context, async() => {
  return Promise.resolve(middleware2(context, async() => {
    return Promise.resolve(middleware3(context, async() => {
      return Promise.resolve();
    }));
  }));
}))
  .then(() => {
    console.log('end');
    console.log('context = ', context);
  });

现在用async/await 实现
主要思路
1每个中间件需要封装一个promise
2 洋葱模型的先进后出操作，对于promise.resolve前后操作

function compose(middleware){
return function(ctx,next){
  let index=-1
  function dispatch(i){
      if(i<index){
          return Promise.reject(new Error('next() called multiple times'))
      }
      index=i;
      let fn=middleware[i]
  if(i===middleware.length){
    fn=next
  }
  if(!fn){
    return Promise.resolve()
  }
  try{
    return Promise.resolve(fn(ctx,()=>{
      return dispath(i+1)
    }))
  }catch(err){
    return Promise.reject(err)
  }
  }
}
}

普通中间件式http服务实现
用原生的node.js实现纯回调的中间件的http服务
服务类封装

  const http=require('http')
  const Emitter=require('events)

  class WebServer extends Emitter{
    constructor(){
      super();
      this.middleware=[]
      this.context=Object.create({})
    }
    //服务事件监听
    listen(..args){
      const server=http.createServer(this.callback())
      return server.listen(...args)
    }
    //注册使用中间件
    use(fn){
      if(typeof fn==='function'){
        this.middleware.push(fn)
      }
    }
    //中间件总回调方法
    callback(){
      let that=this
      if(this.listeners('error).length===0){
        this.on('error',this.onerror)
      }
      const handleRequest=(req,res)=>{
        let context that.createContext(req,res)
        this.middleware.forEach((cb,idx)=>{
          try{
            cb(context)
          }catch(err){
            that.onerror(err)
          }
          if(idx+1>=this.middleware.length){
            if(res&&typeof res.end==='function'){
              res.end()
            }
          }
        })
      }
      return handleRequest
    }
    /*异常处理监听*/
    onerror(err){
      console.log(err)
    }
    /*****创建通用上下文***/
    createContext(req,res){
      let context=Object.create(this.context)
      context.req=req;
      context.res=res
      return context
    }

  }
  module.exports=WebServer

//最简koa.js实现

  callback(){
    let that=this;
    if(this.listeners('error').length===0){
      this.on('error',this.onerror)
    }
    const handleRequest=(req,res)=>{
      let context=that.createContext(req,res)
      this.middleware.forEach( (cb,idx)=>{
        try{
          cb(context)
        }catch(err){
          that.onerror(err)
        }
      })
    }
    if(idx+1>=this.middleware.length){
      if(res&&typeof res.end==='function'){
        res.end()
      }
    }
    return handleRequest
  }