node--koa学习

1、基础用法

const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = 'Hello World';
});

app.listen(3000);

（1）创建对象

const Koa = require('koa');
const app = new Koa();

（2）app.use()
将给定的中间件方法添加到此应用程序。app.use() 返回 this, 因此可以链式表达.
（3）app.context
（4）错误处理
（5）上下文（context）
（6）请求(Request)
（7）响应(Response)
学习链接：https://koa.bootcss.com/

2、中间件

使用app.use()注册的函数。每次客户端的请求，koa都会调用。
基本格式

//ctx：上下文，核心对象
//next：将处理的控制权转交给下一个中间件
app.use(async (ctx, next)=>{
  //...
  await next()    //等待下个中间件运行结束，才运行当前中间件的后续代码
  //...
})

学习链接：https://www.jianshu.com/p/9838ee0501e4

3、koa常见用法学习

（1）get请求接收的实现

//ctx、ctx.request都具备相同的query、querystring
//query：返回的是格式化好的参数对象
//querystring：返回的是请求字符串
const Koa = require('koa');
const app = new Koa();
app.use(async(ctx)=>{
    let url =ctx.url;
 
    //从request中获取GET请求
    let request =ctx.request;
    let req_query = request.query;
    let req_querystring = request.querystring;
 
    //从上下文中直接获取
    let ctx_query = ctx.query;
    let ctx_querystring = ctx.querystring;
 
    ctx.body={
        url,
        req_query,
        req_querystring,
        ctx_query,
        ctx_querystring
    }
});
 
app.listen(3000,()=>{
    console.log('[demo] server is starting at port 3000');
});

（2）ctx.request和ctx.req的区别
ctx.request:是Koa2中context经过封装的请求对象，它用起来更直观和简单。
ctx.req:是context提供的node.js原生HTTP请求对象。这个虽然不那么直观，但是可以得到更多的内容，适合我们深度编程。
（3）koa-bodyparser实现post请求

const Koa = require('koa');
const app = new Koa();
const bodyParser = require('koa-bodyparser');
 
app.use(bodyParser());
 
app.use(async(ctx)=>{
    if(ctx.url === '/' && ctx.method === 'GET'){
        //显示表单页面
        let html=`
            <h1>Koa2 request POST</h1>
            <form method="POST" action="/">
                <p>userName</p>
                <input name="userName" /><br/>
                <p>age</p>
                <input name="age" /><br/>
                <button type="submit">submit</button>
            </form>
        `;
        ctx.body=html;
    }else if(ctx.url === '/' && ctx.method === 'POST'){
         let postData = ctx.request.body;
         ctx.body = postData;
    }else{
        ctx.body = '<h1>404!</h1>';
    }
});

app.listen(3000, () => {
    console.log('[demo] server is starting at port 3000');
});

（4）路由实现
基础格式

const Koa = require('koa');
const Router = require('koa-router');
 
const app = new Koa();
const router = new Router();
 
//实现 '/'、'/koa'两个路由层级
router
    .get('/',(ctx,next)=>{
        ctx.body="Index page";
    })
    .get('/koa',(ctx,next)=>{
        ctx.body="Koa page";
    });
 
app
  .use(router.routes())
  .use(router.allowedMethods());
  
app.listen(3000,()=>{
    console.log('starting at port 3000');
});

路由层级–全局层级

//所有路由必须加上一个tony父层级，才能被访问
const router = new Router({
      prefix: '/tony'
})

路由层级–局部层级

const Koa = require('koa');
const app = new Koa();
const Router = require('koa-router');

//实现'/home'、'/page'两个子路由层级，以及各自的两个孙子路由层级

//子路由
let home = new Router();
home
    .get('/',async(ctx)=>{
        ctx.body="Home";
    })
    .get('/one',async(ctx)=>{
        ctx.body="Home one";
    })
    .get('/two',async(ctx)=>{
        ctx.body ='Home two';
    })

let page = new Router();
page
    .get('/',async(ctx)=>{
        ctx.body="Page";
    })
    .get('/one',async(ctx)=>{
        ctx.body="Page one";
    })
    .get('/two',async(ctx)=>{
        ctx.body ='Page two';
    })

//总路由，装载子路由
let router = new Router();
router.use('/home',home.routes(),home.allowedMethods());
router.use('/page',page.routes(),page.allowedMethods());

//加载路由中间件
app.use(router.routes()).use(router.allowedMethods());

app.listen(3000,()=>{
    console.log('[demo] server is starting at port 3000');
});

学习链接：https://www.jianshu.com/p/5ba990127978
https://www.jianshu.com/p/f69852835699#fnref2
https://www.jianshu.com/p/4a458e14cb73

4、ctx了解

· ctx.req：原生的req对象
· ctx.res：原生的res对象
· ctx.request：koa自己封装的request对象
· ctx.response：koa自己封装的response对象
console.log(ctx.query); //原生中需要经过url.parse(p,true).query才能得到的query对象
console.log(ctx.path); //原生中需要经过url.parse(p).pathname才能得到的路径（url去除query部分）
ctx.state.变量 = **    //变量随便写，意思是把“变量存储起来”
ctx.state.变量           //获取变量的值