zoukankan html css js c++ java

koa2

koa就是一种简单好用的web框架
require引入外部文件
request获取请求参数（请求(Request)）
响应(Response)

一、基本用法

1、架设HTTP服务

koa架设一个HTTP服务

  const Koa = require('koa');
  const app = new Koa();
  app.listen(3000);

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

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

app.listen(3000);

2、Content对象

*Koa提供一个Context对象，表示一次对话的上下文（包括HTTP 请求和HTTP回复）。通过加工这个对象，就可以控制返回给用户的内容。
Context.response.body属性就是发送给用户的内容

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

const main = ctx => {
  ctx.response.body = 'Hello World';
};

app.use(main);
app.listen(3000);

main函数用来设置ctx.response.body。然后app.use方法加载main函数
ctx.response代表HTTP Response ,同样地ctx.request代表HTTP Request.

3、HTTP Response的类型

Koa默认的返回类型是text/plain，如果想返回其他类型的内容，可以利用ctx.request.accepts判断一下，客户端希望接受什么数据（根据HTTP Request的Accept字段），然后使用ctx.response.type指定返回类型。

  const Koa = require('koa');
  const app = new Koa();
  
  const main = ctx => {
    if (ctx.request.accepts('xml')) {
      ctx.response.type = 'xml';
      ctx.response.body = '<data>Hello World</data>';
    } else if (ctx.request.accepts('json')) {
      ctx.response.type = 'json';
      ctx.response.body = { data: 'Hello World' };
    } else if (ctx.request.accepts('html')) {
      ctx.response.type = 'html';
      ctx.response.body = '<p>Hello World</p>';
    } else {
      ctx.response.type = 'text';
      ctx.response.body = 'Hello World';
    }
  };
  
  app.use(main);
  app.listen(3000);

4、网页模板

实际开发中，返回给用户的网页往往都写成模板文件，我们可以让Koa先读取模板文件，然后将这个模板返回给用户。

  const fs = require('fs');
  const Koa = require('koa');
  const app = new Koa();
  
  const main = ctx => {
       ctx.response.type = 'html';
       ctx.response.body = fs.createReadStream('./demos/template.html');
   }
  
  app.use (main);
  app.listen(3000)

两个代码效果是相同

const fs = require('fs');
const Koa = require('koa');
const app = new Koa();
	
app.use(ctx=>{
	   ctx.response.type = 'html';
	   ctx.response.body = fs.createReadStream('./demos/template.html');
})
	

app.listen(3000)

5、POST请求如何接收

1、获取POST请求的步骤

1、解析上下文ctx中的原生node.js对象req。
2、将POST表单数据解析成query string-字符串。
将字符串转换成JSON格式

2、ctx.request和ctx.req的区别

ctx.request:是Koa2中的Context经过封装的请求对象，它用起来更直观和简单。
ctx.req:是content提供的node.js原生HTTP请求对象。这个虽然不那么直观，但是可以得到更多的内容，适合我们深度编程。

3、ctx.method得到请求类型

Koa2中提供了ctx.method属性，可以轻松的得到请求的类型，然后根据请求类型编写不同的相应方法，这在工作中非常常用。

  const Koa = require('koa');
  const app = new Koa();
  app.use(async(ctx)=>{
      //当请求是get请求时，显示表单让用户填写
      if(ctx.url === '/' && ctx.method === 'GET'){
          let html = `
          <h1>Koa2 request post demo</h1>
          <form method="POST" action='/'>
              <p>username</p>
              <input name="username"/>  <br/>
              <p>age</p>
              <input name="age" /> <br/>
              <p>website</p>
              <input name="website" />
              <button type="submit">submit</button>
          </form>
          `;
          ctx.body = html;
          //当请求是post请求时
      }else if(ctx.url === '/' && ctx.method === 'POST'){
          ctx.body = '接收到post请求'
      }else{
          //其他页面显示404页面
          ctx.body = '<h1>404!</h1>'
      }
  })
  
  app.listen(3000,()=>{
      console.log('demo server is starting at port 3000')
  })

注意，POST必须写成POST，post不可以（必须大写，小写不行）

5（2）、POST请求如何接收（2）

1.解析Node原生POST参数

声明一个方法，然后用Promise对象进行解析。这里我们使用了ctx.req.on来接收事件。

  function parsePostData(ctx){
      return new Promise((resolve,reject)=>{
          try{
              let postdata = '';
              ctx.req.addListener('end',function(){
                  resolve(postdata)
              })
              ctx.req.on('data',(data)=>{
                  postdata += data;
              })
  
          }catch(error){
              reject(error)
          }
      })
  }

2.POST字符串解析JSON对象

写一个字符串封装JSON兑现对象的方法。

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

全部代码

const Koa = require('koa');
const app = new Koa();
app.use(async(ctx)=>{
    //当请求是get请求时，显示表单让用户填写
    if(ctx.url === '/' && ctx.method === 'GET'){
        let html = `
        <h1>Koa2 request post demo</h1>
        <form method="POST" action='/'>
            <p>username</p>
            <input name="username"/>  <br/>
            <p>age</p>
            <input name="age" /> <br/>
            <p>website</p>
            <input name="website" />
            <button type="submit">submit</button>
        </form>
        `;
        ctx.body = html;
        //当请求是post请求时
    }else if(ctx.url === '/' && ctx.method === 'POST'){
        let postData = await parsePostData(ctx);
        ctx.body = postData;
    }else{
        //其他页面显示404页面
        ctx.body = '<h1>404!</h1>'
    }
})

function parsePostData(ctx){
    return new Promise((resolve,reject)=>{
        try{
            let postdata = '';
            ctx.req.addListener('end',function(){
                let parseData = parseQueryStr(postdata)
                resolve(parseData)
            })
            ctx.req.on('data',(data)=>{
                postdata += data;
            })

        }catch(error){
            reject(error)
        }
    })
}

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

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

6、get请求的接收

query和querystring区别

在koa2中GET请求通过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;
  
      ctx.body = {
          url,
          req_query,
          req_querystring
  
      }
  
  })
  app.listen(3000,()=>{
      console.log('[demo] server is starting at port 3000')
  })

2.直接从ctx中获取get请求

直接在ctx中得到get请求，ctx中也分为query和querystring

  const Koa = require('koa');
  const app = new Koa();
  
  app.use(async(ctx)=>{
      let url = ctx.url;
      //从上下文中直接获取
      let ctx_query = ctx.query;
      let ctx_querystring = ctx.querystring;
      ctx.body = {
          url,
          ctx_query,
          ctx_querystring
  
      }
  
  })
  app.listen(3000,()=>{
      console.log('[demo] server is starting at port 3000')
  })

总结：获得GET请求的方式有两种，一种是从request中获得，一种是一直从上下文中获得。获得的格式也有两种：query和querystring。

二、路由

1、原生路由

网站一般都有多个页面。通过ctx.request.path可以获取用户请求的路径，由此实现简单的路由

  const Koa = require('koa');
  const app = new Koa();
  
  const main = ctx => {
    if (ctx.request.path !== '/') {
      ctx.response.type = 'html';
      ctx.response.body = '<a href="/">Index Page</a>';
    } else {
      ctx.response.body = 'Hello World';
    }
  };
  
  app.use(main);
  app.listen(3000);

2、koa-route模块

原生路由用起来不太方便，我们可以使用封装好的koa-route模块

  const Koa = require('koa');
  const route = require('koa-route');
  const app = new Koa();
  
  const about = ctx =>{
      ctx.response.type = 'html';
      ctx.response.body = '<a href="/">Index Page</a>'
  };
  const main = ctx =>{
      ctx.response.body = 'Hello World'
  }
  
  app.use(route.get('/',main));
  app.use(route.get('/about',about))
  app.listen(3000);

根路径/的处理函数是main，/about路径的处理函数是about

3、静态资源

如果网站提供静态资源（图片、字体、样式、脚本......）,为它们一个个写路由就很麻烦，也没必要。koa-static模块封装了这部分的请求。

  const Koa = require('koa');
  const app = new Koa();
  const path = require('path');
  const serve = require('koa-static');
  const main = serve(path.join(__dirname));
  app.use(main);
  app.listen(3000);

1、安装koa-static

npm install --save koa-static

2、新建static文件夹

在static文件夹中让人图片、css和js文件

3、使用koa-static中间件

const Koa = require('koa');
const path = require('path');
const static = require('koa-static');
const app = new Koa();

const staticPath = './static';

app.use(static(path.join(__dirname,staticPath)));

app.use(async(ctx)=>{
    ctx.body = 'hello static'
})

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

4、重定向

有些场合，服务器需要重定向（redirect）访问请求。比如，用户登录以后，将他重定向到登录前的页面。ctx.response.redirect()方法可以发出一个302跳转，将用户导向另一个路由

  const Koa = require('koa');
  const route = require('koa-route');
  const app = new Koa();
  
  const redirect = ctx => {
    ctx.response.redirect('/');
  };
  
  const main = ctx => {
    ctx.response.body = 'Hello World';
  };
  
  app.use(route.get('/', main));
  app.use(route.get('/redirect', redirect));
  app.listen(3000);

访问 http://127.0.0.1:3000/redirect ，浏览器会将用户导向根路由。

5、ctx.request.url

要想实现原生路由，需要得到地址栏输入的路径，然后根据路径的不同进行跳转。用ctx.request.url就可以实现

  const Koa = require('koa')
  const app = new Koa()
   
  app.use( async ( ctx ) => {
    let url = ctx.request.url
    ctx.body = url
  })
  app.listen(3000)

三、中间件

1、Logger功能

Koa的最大特色，也是最重要的一个设计，就是中间件（middleware）

  const Koa = require('koa');
  const app = new Koa();
  
  const main = ctx => {
    console.log(`${Date.now()} ${ctx.request.method} ${ctx.request.url}`);
    ctx.response.body = 'Hello World';
  };
  
  app.use(main);
  app.listen(3000);

访问 http://127.0.0.1:3000 ，命令行就会输出日志。
1534751382271 GET /

2、上一个例子里面的Logger功能，可以拆分成一个独立函数

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

const logger = (ctx,next)=>{
    console.log(`${Date.now()} ${ctx.request.method} ${ctx.request.url}`);
    next();
}
const main = ctx =>{
    ctx.response.body = '我是中间件'
}

app.use(logger);
app.use(main);
app.listen(3000);

像上面代码中的logger函数就叫做'中间件'(middleware),因为它处在HTTP Request和HTTP Response中间，用来实现某种中间功能。app.use()用来加载中间件。
基本上，Koa所有的功能都是通过中间件实现的，前面例子里面的main也是中间件。每个中间件默认接受两个参数，第一个参数是Context对象，第一个参数是next函数。只要调用next函数，就可以把执行权转交给下一个中间件。

3、中间件栈

多个中间件会形成一个栈结构（middle stack)，以'先进后出'(first-in-last-out)的顺序执行

  1. 最外层的中间件首先执行。
  2. 调用next函数，把执行权交给下一个中间件。
  3. ...
  4. 最内层的中间件最后执行。
  5. 执行结束后，把执行权交回上一层的中间件。
  6. ...
  7. 最外层的中间件收回执行权之后，执行next函数后面的代码。

	const Koa = require('koa');
	const app = new Koa();
	
	const one = (ctx, next) => {
	  console.log('>> one');
	  next();
	  console.log('<< one');
	}
	
	const two = (ctx, next) => {
	  console.log('>> two');
	  next();
	  console.log('<< two');
	}
	
	const three = (ctx, next) => {
	  console.log('>> three');
	  next();
	  console.log('<< three');
	}
	
	app.use(one);
	app.use(two);
	app.use(three);
	
	app.listen(3000);

如果中间件内部调用next函数，那么执行权就不会传递下去

4、异步中间件

迄今为止，所有例子的中间件都是同步的，不包含异步操作。如果有异步操作（比如读取数据库），中间件就必须写成async函数

  const fs = require('fs.promised');
  const Koa = require('koa');
  const app = new Koa();
  
  
  
  const main = async function(ctx,next){
      ctx.response.type = 'html';
      ctx.response.body = await fs.readFile('./demos/template.html','utf-8')
  }
  
  app.use(main);
  app.listen(3000);

fs.readFile是一个异步操作，必须写成await fs.readFile(),然后中间件必须写成async函数

5、中间件的合成

koa-compose模块可以将多个中间件合成为一个

  const Koa = require('koa');
  const compose = require('koa-compose');
  const app = new Koa();
  
  const logger = (ctx,next) =>{
      console.log(`${Date.now()} ${ctx.request.method} ${ctx.request.url}`);
      next();
  }
  const main = ctx=>{
      ctx.response.body = 'hello world2'
  }
  const middlewares = compose([logger,main])
  app.use(middlewares);
  app.listen(3000);

6、koa-bodyparser中间件

对于POST请求的处理，koa-bodyparser中间件可以把koa2上下文的formData数据解析到ctx.request.body中

1、安装中间件

使用npm进行安装，需要注意的是我们这里要用–save，因为它在生产环境中需要使用。
npm install --save koa-bodyparser@3

2、引入使用

安装完成后，需要在代码中引入并使用。我们在代码顶部用require进行引入。
const bodyParser = require('koa-bodyparser');
然后进行使用，如果不使用是没办法调用的，使用代码如下。
app.use(bodyParser());

在代码中使用后，直接可以用ctx.request.body进行获取POST请求参数，中间件自动给我们作了解析。

  const Koa = require('koa');
  const app = new Koa();
  const bodyParser = require('koa-bodyparser');
  
  app.use(bodyParser())
  app.use(async(ctx)=>{
      //当请求是get请求时，显示表单让用户填写
      if(ctx.url === '/' && ctx.method === 'GET'){
          let html = `
          <h1>Koa2 request post demo</h1>
          <form method="POST" action='/'>
              <p>username</p>
              <input name="username"/>  <br/>
              <p>age</p>
              <input name="age" /> <br/>
              <p>website</p>
              <input name="website" />
              <button type="submit">submit</button>
          </form>
          `;
          ctx.body = html;
          //当请求是post请求时
      }else if(ctx.url === '/' && ctx.method === 'POST'){
          let postData = ctx.request.body;
          ctx.body = postData;
      }else{
          //其他页面显示404页面
          ctx.body = '<h1>404!</h1>'
      }
  })
  
  
  app.listen(3000,()=>{
      console.log('demo server is starting at port 3000')
  })

四、错误处理

1、500错误

如果代码运行过程中发生错误，我们需要吧错误信息返回给用户。HTTP协定约定这时要返回500状态码。Koa提供了ctx.throw()方法，用来抛出错误，ctx.throw(500)错误。
```
  const Koa = require('koa');
  const app = new Koa();
  
  const main = ctx => {
    ctx.throw(500);
  };
  
  app.use(main);
  app.listen(3000);
```

2、404错误

如果将ctx.response.status设置成404，就相当于ctx.throw(404),返回404错误

  const Koa = require('koa');
  const app = new Koa();
  
  const main = ctx => {
      ctx.response.status = 404;
      ctx.response.body = 'Page Not Found--404'
  }
  app.use(main);
  app.listen(3000);

3、处理错误的中间件

为了方便处理错误，最好使用try...catch将其捕获。但是，为每个中间件都写try...catch太麻烦，我们可以让最外层的中间件，负责所有中间件的错误处理

  const Koa = require('koa');
  const app = new Koa();
  
  const handler = async (ctx, next) => {
      try {
          await next();
      }catch (err){
          ctx.response.status = err.statusCode || err.status || 500;
          ctx.response.body = {
              message: err.message
          };
      }
  };
  
  const main = ctx =>{
      ctx.throw(500);
  }
  app.use(handler);
  app.use(main);
  app.listen(3000);

4、error事件的监听

运行过程中一旦出错，Koa会触发一个error事件。监听这个事件，也可以处理错误

  const Koa = require('koa');
  const app = new Koa();
  
  const main = ctx => {
    ctx.throw(500);
  };
  
  app.on('error', (err, ctx) => {
    console.error('server error', err);
  });
  
  app.use(main);
  app.listen(3000);

5、释放error事件

需要注意的是，如果被try...catch捕获，就不会触发error事件。这时，必须调用ctx.app.emit(),手动释放error事件，才能让监听函数生效。

  const Koa = require('koa');
  const app = new Koa();
  
  const handler = async (ctx,next) => {
    try {
      await next();
    }catch (err) {
      ctx.response.status = err.statusCode || err.status || 500;
      ctx.response.type = 'html';
      ctx.response.body = '<p>Something wrong,please contact administrator</p>';
      ctx.app.emit('error',err,ctx);
    }
  }
  
  const main = ctx =>{
    ctx.throw(500);
  }
  
  app.on('error',function(err){
    console.log('logging error',err.message);
    console.log(err)
  })
  app.use(handler);
  app.use(main);
  app.listen(3000);

main函数抛出错误，被handler函数捕获。catch代码块里面使用ctx.app.emit()手动释放error事件，才能让监听函数监听到

五、Web App的功能

1、Cookies

ctx.cookies 用来读写Cookie

  const Koa = require('koa');
  const app = new Koa();
  
  const main = function(ctx){
      const n = Number(ctx.cookies.get('view') || 0)+1;
      ctx.cookies.set('view',n);
      ctx.response.body = n + 'views';
  }
  app.use(main);
  app.listen(3000);

ctx.cookies.get(name,[options]) 读取上下文请求中的cookie
ctx.cookies.set(name,value,[options]) 在上下文中写入cookie

domain : 写入cookie所在的域名
path : 写入cookie所在的路径
maxAge： cookie最大有效时长
expires： cookie失效时间
httpOnly：是否只用http请求中获得
overwirte: 是否允许重写

例子

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

app.use(async(ctx)=>{
    if (ctx.url === '/index'){
        ctx.cookies.set(
            'myName', 'xiaoLiLi',{
                domain: '127.0.0.1', //写cookie所在的域名
                path: '/index',   //写cookie所在的路径
                maxAge: 1000*60*60*24, //cookie有效时长（一天）
                expires: new Date('2018-12-28'), //cookie失效时间
                httpOnly: false, //是否只用于http请求中获取
                overwrite: false //是否允许重写
            }
        )
        ctx.body = 'cookie is OK'

    }else{
        if(ctx.cookies.get('myName')){
            ctx.body = ctx.cookies.get('myName');
        }else{
            ctx.body = 'cookie is none';
        }
    }
})

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

2、表单

Web应用离不开处理表单。本质上，表单就是POST方法发送到服务器的键值对。koa-body模块可以用来从POST请求的数据体里面提取键值对。

  const Koa = require('koa');
  const koaBody = require('koa-body');
  const app = new Koa();
  const main = async function(ctx) {
      const body = ctx.request.body;
      if(!body.name) ctx.throw(400,'.name required');
      ctx.body = {name: body.name};
  }
  
  app.use(koaBody());
  app.use(main);
  app.listen(3000);

3、文件上传

koa-body 模块还可以用来处理文件上传

  const os = require('os');
  const path = require('path');
  const Koa = require('koa');
  const fs = require('fs');
  const koaBody = require('koa-body');
  
  const app = new Koa();
  
  const main = async function(ctx) {
    const tmpdir = os.tmpdir();
    const filePaths = [];
    const files = ctx.request.body.files || {};
  
    for (let key in files) {
      const file = files[key];
      const filePath = path.join(tmpdir, file.name);
      const reader = fs.createReadStream(file.path);
      const writer = fs.createWriteStream(filePath);
      reader.pipe(writer);
      filePaths.push(filePath);
    }
  
    ctx.body = filePaths;
  };
  
  app.use(koaBody({ multipart: true }));
  app.use(main);
  app.listen(3000);

打开另一个命令行窗口，运行下面的命令，上传一个文件。注意，/path/to/file要更换为真实的文件路径。

koa2的模板初始（ejs）

安装中间件

npm install --save koa-views

安装ejs模板引擎

npm install --save ejs

编写模板

新建view/index.ejs

  <!DOCTYPE html>
  <html>
  <head>
      <title><%= title %></title>http://jspang.com/wp-admin/post.php?post=2760&action=edit#
  </head>
  <body>
      <h1><%= title %></h1>
      <p>EJS Welcome to <%= title %></p>
  </body>
  </html>

编写koa文件

const Koa = require('koa');
const views = require('koa-views');
const path = require('path');
const app = new Koa();

//加载模板引擎
app.use(views(path.join(__dirname,'./view'),{
    extension: 'ejs'
}))
app.use(async(ctx)=>{
    let title = 'hello koa2';
    await ctx.render('index',{
        title
    })
})

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

request 请求

1、Request别名

ctx.header
ctx.headers
ctx.method
ctx.method=
ctx.url
ctx.url=
ctx.originalUrl
ctx.origin
ctx.href
ctx.path
ctx.path=
ctx.query
ctx.query=
ctx.querystring
ctx.querystring=
ctx.host
ctx.hostname
ctx.fresh
ctx.stale
ctx.socket
ctx.protocal
ctx.secure
ctx.ip
ctx.ips
ctx.subdomains
ctx.is()
ctx.accepts()
ctx.acceptsEncodings()
ctx.acceptsCharsets()
ctx.acceptsLanguages()
ctx.get()

query和querystring区别

在koa2中GET请求通过request接收，但是接受的方法有两种：query和querystring。
query：返回的是格式化好的参数对象。
querystring：返回的是请求字符串。

2、Response 别名

ctx.body
ctx.body=
ctx.status
ctx.status=
ctx.message
ctx.message=
ctx.length=
ctx.length
ctx.type=
ctx.type
ctx.headerSent
ctx.redirect()
ctx.attachment()
ctx.set()
ctx.append()
ctx.remove()
ctx.lastModeified=
ctx.etag=

六、响应（Response）

Koa Response 对象是在node的vanilla响应对象之上的抽象，提供诸多多HTTP服务器开发有用的功能

API

1、response.header

响应标头对象

2、response.headers

响应标头对象。别名是response.header

3、response.socket

请求套接字

4、response.status

获取响应状态。默认情况下，response.status设置为404而不是像node的res.statusCode那样默认为200.

5、response.status =

通过数组代码设置响应状态

100 "continue"
101 "switching protocols"
102 "processing"
200 "ok"
201 "created"
202 "accepted"
203 "non-authoritative information"
204 "no content"
205 "reset content"
206 "partial content"
207 "multi-status"
208 "already reported"
226 "im used"
300 "multiple choices"
301 "moved permanently"
302 "found"
303 "see other"
304 "not modified"
305 "use proxy"
307 "temporary redirect"
308 "permanent redirect"
400 "bad request"
401 "unauthorized"
402 "payment required"
403 "forbidden"
404 "not found"
405 "method not allowed"
406 "not acceptable"
407 "proxy authentication required"
408 "request timeout"
409 "conflict"
410 "gone"
411 "length required"
412 "precondition failed"
413 "payload too large"
414 "uri too long"
415 "unsupported media type"
416 "range not satisfiable"
417 "expectation failed"
418 "I'm a teapot"
422 "unprocessable entity"
423 "locked"
424 "failed dependency"
426 "upgrade required"
428 "precondition required"
429 "too many requests"
431 "request header fields too large"
500 "internal server error"
501 "not implemented"
502 "bad gateway"
503 "service unavailable"
504 "gateway timeout"
505 "http version not supported"
506 "variant also negotiates"
507 "insufficient storage"
508 "loop detected"
510 "not extended"
511 "network authentication required"

6、response.message

获取响应的状态信息。默认情况下，response.message与response.status关联。

7、response.message=

将响应的状态信息设置为给定值

8、response.length=

将响应的Content-Length设置为给定值

9、response.length

以数字返回相应的Content-Length，或者从ctx.body推导出来，或者undefined。

10、response.body

获取响应主体

11、response.body=

将响应体设置为以下之一：

string 写入
Buffer 写入
Stream 管道
Object || Array JSON-字符串化
null 无内容响应
如果response.status未被设置，koa将会自动设置状态为200或204

(1)、String

Content-Type默认为text/html或text/plain,同时默认字符串是utf-8。Content-Length字段也是如此

(2)、Buffer

Content-type默认为application/octet-stream,并且Content-Length字段也是如此

(3)、Stream

Content-Type 默认为application/octet-stream

(4)、Object

Content-Type默认为application/json。这包括普通的对象{foo：'bar'}和数组['foo','bar']

12、response.get(field)

不区分大小写获取响应头字段值field

const etag = ctx.response.get(ETag);

13、response.set(field,value)

设置响应头field到value
```
  ctx.set('Cache-Control','no-cache')
```

14、response.append(field,value)

用值val附加额外的标头field

  ctx.append('Link', '<http://127.0.0.1/>');

15、response.set(fields)

用一个对象设置多个响应标头fields:

  ctx.set({
    'Etag': '1234',
    'Last-Modified': date
  });

16、response.remove(field)

删除标头field

17、response.type

获取响应Content-Type不含参数'charset'
```
  const ct = ctx.type;
```

18、response.type=

设置响应Content-Type通过mime字符串或文件扩展名

  ctx.type = 'text/plain; charset=utf-8';
  ctx.type = 'image/png';
  ctx.type = '.png';
  ctx.type = 'png';

注意: 在适当的情况下为你选择 charset, 比如 response.type = 'html' 将默认是 "utf-8". 如果你想覆盖 charset, 使用 ctx.set('Content-Type', 'text/html') 将响应头字段设置为直接值。

19、response.is(types...)

非常类似 ctx.request.is(). 检查响应类型是否是所提供的类型之一。这对于创建操纵响应的中间件特别有用。

例如, 这是一个中间件，可以削减除流之外的所有HTML响应。

  const minify = require('html-minifier');
  
  app.use(async (ctx, next) => {
    await next();
  
    if (!ctx.response.is('html')) return;
  
    let body = ctx.body;
    if (!body || body.pipe) return;
  
    if (Buffer.isBuffer(body)) body = body.toString();
    ctx.body = minify(body);
  });

20、response.redirect(url, [alt])

执行 [302] 重定向到 url.

字符串 “back” 是特别提供Referrer支持的，当Referrer不存在时，使用 alt 或“/”。

  ctx.redirect('back');
  ctx.redirect('back', '/index.html');
  ctx.redirect('/login');
  ctx.redirect('http://google.com');

要更改 “302” 的默认状态，只需在该调用之前或之后分配状态。要变更主体请在此调用之后:
```
  ctx.status = 301;
  ctx.redirect('/cart');
  ctx.body = 'Redirecting to shopping cart';
```

21、response.attachment([filename])

将 Content-Disposition 设置为 “附件” 以指示客户端提示下载。(可选)指定下载的 filename。

22、response.headerSent

检查是否已经发送了一个响应头。用于查看客户端是否可能会收到错误通知。

23、response.lastModified

将 Last-Modified 标头返回为 Date, 如果存在。

24、response.lastModified=

将 Last-Modified 标头设置为适当的 UTC 字符串。您可以将其设置为 Date 或日期字符串。
```
  ctx.response.lastModified = new Date();
```

25、response.etag=

设置包含 " 包裹的 ETag 响应，请注意，没有相应的 response.etag getter。
```
  ctx.response.etag = crypto.createHash('md5').update(ctx.body).digest('hex');
```

26、response.vary(field)

在 field 上变化。

27、response.flushHeaders()

刷新任何设置的标头，并开始主体。

查看全文

相关阅读:
python从可迭代对象中取值
 python中可迭代对象和列表
 python中字典生成式
 Redis源码解析之跳跃表（一）
Redis高可用集群
 Redis主从&哨兵集群搭建
 Java并发之ThreadPoolExecutor源码解析（三）
Java并发之ThreadPoolExecutor源码解析（二）
Java并发之ThreadPoolExecutor源码解析（一）
并发编程之JMM&Volatile（三）

原文地址：https://www.cnblogs.com/DCL1314/p/9507246.html

热门文章
python
python
mysql
mysql
mysql
linux
python如何实现一个装饰器
 python中闭包
 python中装饰器进化史
 flask如何写一个接口

koa2

一、基本用法

1、架设HTTP服务

2、Content对象

3、HTTP Response的类型

4、网页模板

5、POST请求如何接收

1、获取POST请求的步骤

2、ctx.request和ctx.req的区别

3、ctx.method得到请求类型

5（2）、POST请求如何接收（2）

1.解析Node原生POST参数

2.POST字符串解析JSON对象

6、get请求的接收

query和querystring区别

2.直接从ctx中获取get请求

总结：获得GET请求的方式有两种，一种是从request中获得，一种是一直从上下文中获得。获得的格式也有两种：query和querystring。

二、路由

1、原生路由

2、koa-route模块

3、静态资源

1、安装koa-static

2、新建static文件夹

3、使用koa-static中间件

4、重定向

5、ctx.request.url

三、中间件

1、Logger功能

2、上一个例子里面的Logger功能，可以拆分成一个独立函数

3、中间件栈

4、异步中间件

5、中间件的合成

6、koa-bodyparser中间件

1、安装中间件

2、引入使用

四、错误处理

1、500错误

2、404错误

3、处理错误的中间件

4、error事件的监听

5、释放error事件

五、Web App的功能

1、Cookies

cookie 选项

例子

2、表单

3、文件上传

koa2的模板初始（ejs）

安装中间件

安装ejs模板引擎

编写模板

编写koa文件

request 请求

1、Request别名

query和querystring区别

2、Response 别名

六、响应（Response）

API

1、response.header

2、response.headers

3、response.socket

4、response.status

5、response.status =

通过数组代码设置响应状态

6、response.message

7、response.message=

8、response.length=

9、response.length

10、response.body

11、response.body=

将响应体设置为以下之一：

(1)、String

(2)、Buffer

(3)、Stream

(4)、Object

12、response.get(field)

13、response.set(field,value)

14、response.append(field,value)

15、response.set(fields)

16、response.remove(field)