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()

    • 刷新任何设置的标头,并开始主体。
  • 相关阅读:
    Solr4.8.0源码分析(16)之SolrCloud索引深入(3)
    Solr4.8.0源码分析(15) 之 SolrCloud索引深入(2)
    Solr4.8.0源码分析(14)之SolrCloud索引深入(1)
    Solr In Action 笔记(4) 之 SolrCloud分布式索引基础
    Solr In Action 笔记(3) 之 SolrCloud基础
    change buffer太复杂了
    mtr语言真是逆天了
    mysql自动化测试第一个例子
    mysql mtr写入数据
    垃圾规范
  • 原文地址:https://www.cnblogs.com/DCL1314/p/9507246.html
Copyright © 2011-2022 走看看