Nodejs之koa

于 2024-07-06 23:03:11 发布
阅读量853 收藏 26
点赞数 34
分类专栏： Node.js 文章标签： node.js 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40588441/article/details/140237403
版权

Koa

https://www.koajs.net/

https://koa.nodejs.cn/

  • Koa是一个由Express原班人马打造的，尝试在Web应用开发中摆脱回调地狱，并增强错误处理的轻量化的Node.js框架。
  • Koa的目标是成为一个更小、更富表现力、更健壮的Web框架。

安装

Koa需要Node v12或更高版本以支持ES2015和异步函数。 您可以使用您喜欢的版本管理器快速安装一个支持的Node版本：

nvm install 12
npm install koa
node my-koa-app.js

基本使用

Koa应用是一个包含中间件函数数组的对象，这些函数在请求时以类似堆栈的方式组合并执行

在Koa框架中，ctx 是上下文对象，它封装了原生的Node.js请求和响应对象，并且提供了许多方便的方法和属性来处理HTTP请求和响应

ctx.req 和 ctx.res 是Node.js的原生请求和响应对象。这些对象提供了低级别的请求和响应处理方法

ctx.res.end('ok')` 是直接调用Node.js原生响应对象的 `end` 方法来结束响应并发送字符串 `ok

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

server.js

1.server.js

 // 导入koa模块
const Koa = require('./koa');
// 创建一个Koa应用实例
const app = new Koa(); 
app.use(function (ctx) {
  // 处理请求，返回'hello'
  ctx.res.end('hello'); 
});
// 监听3000端口，并在控制台打印服务器运行信息
app.listen(3000, () => console.log('server is running at http://localhost:3000'));

application.js

koa\lib\application.js

 // 导入http模块
const http = require('http');
module.exports = class Application {
    use(fn) {
        // 设置中间件处理函数
        this.middleware = fn; 
    }
    listen(...args) {
         // 创建一个HTTP服务器实例，并使用回调函数作为请求处理程序
        const server = http.createServer(this.callback());
         // 监听指定的端口，并返回监听器对象
        return server.listen(...args);
    }
    callback() {
        const handleRequest = (req, res) => {
             // 创建上下文对象
            const ctx = this.createContext(req, res);
            // 调用中间件处理函数
            this.middleware(ctx); 
        };
        // 返回请求处理函数
        return handleRequest; 
    }
    createContext(req, res) {
        //创建上下文对象
        const context = {};
        //设置请求对象
        context.req = req; 
        //设置响应对象
        context.res = res;
        //返回上下文对象
        return context;
    }
}

request&response

在Koa中，ctx.request 和 ctx.response 是封装了 Node.js 原生请求和响应对象（ctx.req 和 ctx.res）的对象。相比于 Node.js 的原生请求和响应对象，ctx.request 和 ctx.response 提供了更多的方法和属性，使得处理 HTTP 请求和响应更加方便和简单。

  • ctx.request

    :

    • ctx.request.query: 一个包含解析过的查询字符串的对象
    • ctx.request.method: 请求方法，例如 ‘GET’, ‘POST’ 等
    • ctx.request.url: 请求的 URL
    • ctx.request.header: 请求头对象
    • ctx.request.body: 请求体（需要额外的中间件如koa-bodyparser来解析请求体）

  • ctx.response

    :

    • ctx.response.body: 可以设置响应体的内容，它可以是一个字符串、对象或者流
    • ctx.response.status: 可以设置响应的 HTTP 状态码
    • ctx.response.message: HTTP 状态消息
    • ctx.response.header: 响应头对象

server.js

// 引入Koa框架
const Koa = require('./koa');
// 实例化Koa对象
const app = new Koa();
// 使用中间件处理请求
app.use(async ctx => {
+  // 打印请求方法
+  console.log(ctx.request.method, ctx.method)
+  // 打印请求URL
+  console.log(ctx.request.url, ctx.url)
+  // 打印请求路径
+  console.log(ctx.request.path, ctx.path)
+  // 打印查询字符串参数
+  console.log(ctx.request.query, ctx.query)
+  // 打印请求头
+  console.log(ctx.request.header, ctx.header)
+  // 设置响应状态码
+  ctx.response.status = 200;
+  ctx.status = 200;
+  // 设置响应消息
+  ctx.response.message = 'OK';
+  ctx.message = 'OK';
+  ctx.set('Content-Type', 'text/html;charset=utf-8');
+  // 设置响应体
+  ctx.response.body = 'Hello';
+  ctx.body = 'Hello';
});
// 监听3000端口，启动服务
app.listen(3000, () => console.log('server is running at http://localhost:3000'));

application.js

koa\lib\application.js

// 导入http模块
const http = require('http');
// 导入自定义的context模块
const context = require('./context.js');
// 导入自定义的request模块
const request = require('./request');
// 导入自定义的response模块
const response = require('./response');
module.exports = class Application {
    // 构造函数
    constructor() {
        // 创建一个新的context对象，这个对象继承自自定义的context模块
        this.context = Object.create(context)
        // 创建一个新的request对象，这个对象继承自自定义的request模块
        this.request = Object.create(request)
        // 创建一个新的response对象，这个对象继承自自定义的response模块
        this.response = Object.create(response)
    }
    use(fn) {
        // 设置中间件处理函数
        this.middleware = fn;
    }
    listen(...args) {
        // 创建一个HTTP服务器实例，并使用回调函数作为请求处理程序
        const server = http.createServer(this.callback());
        // 监听指定的端口，并返回监听器对象
        return server.listen(...args);
    }
    callback() {
        const handleRequest = (req, res) => {
            // 创建上下文对象
            const ctx = this.createContext(req, res);
            // 调用中间件处理函数
            this.middleware(ctx);
            // 获取context对象的body属性
+           let body = ctx.body;
+           // 结束响应并发送body
+           return res.end(body);
        };
        // 返回请求处理函数
        return handleRequest;
    }
+   createContext(req, res) {
+       // 创建一个新的context对象，这个对象继承自this.context
+       const context = Object.create(this.context)
+       // 创建一个新的request对象，这个对象继承自this.request，并将这个对象赋值给context.request
+       const request = context.request = Object.create(this.request)
+       // 创建一个新的response对象，这个对象继承自this.response，并将这个对象赋值给context.response
+       const response = context.response = Object.create(this.response)
+       // 将原生的req和res对象赋值给context、request和response的req和res属性
+       context.req = request.req = req;
+       context.res = response.res = res;
+       // 返回创建的context对象
+       return context;
+   }
}

context.js

koa\lib\context.js

// 导入自定义的代理（delegate）模块
const delegate = require('./delegates')
// 创建一个空对象proto并将其导出
const proto = module.exports = {}
// 使用代理模块将proto对象的一些属性代理到'request'对象
delegate(proto, 'request')
    .access('method')  // 将'request'对象的'method'属性代理到proto对象
    .access('query')   // 将'request'对象的'query'属性代理到proto对象
    .access('url')     // 将'request'对象的'url'属性代理到proto对象
    .access('path')    // 将'request'对象的'path'属性代理到proto对象
    .getter('header')  // 将'request'对象的'header'属性的获取代理到proto对象
// 使用代理模块将proto对象的一些属性代理到'response'对象
delegate(proto, 'response')
    .access('status')  // 将'response'对象的'status'属性代理到proto对象
    .access('message') // 将'response'对象的'message'属性代理到proto对象
    .access('body')    // 将'response'对象的'body'属性代理到proto对象
    .method('set')     // 将'response'对象的'set'方法代理到proto对象

request.js

koa\lib\request.js

// 导入 parseurl 模块，用于解析 URL
const parse = require('parseurl')
// 导入 querystring 模块，用于解析查询字符串
const qs = require('querystring')
// 导出一个对象，这个对象定义了一些属性的 getter
module.exports = {
    // 获取 HTTP 请求的头部
    get header () {
        return this.req.headers
    },
    // 获取 HTTP 请求的 URL
    get url () {
        return this.req.url
    },
    get path () {
        return parse(this.req).pathname
    },
    // 获取 HTTP 请求的方法
    get method () {
        return this.req.method
    },
    // 获取 HTTP 请求的查询字符串
    get querystring () {
        return parse(this.req).query;
    },
    // 获取 HTTP 请求的查询参数，这些参数是一个对象，它由查询字符串解析得到
    get query () {
        return qs.parse(this.querystring)
    }
}

response.js

koa\lib\response.js

// 定义一个模块，暴露出一些属性和方法
module.exports = {
    // 设置状态码的方法
    set status(code) {
        this.res.statusCode = code;
    },
    // 设置状态消息的方法
    set message(msg) {
        this.res.statusMessage = msg;
    },
    // 设置body的方法
    set body(val) {
        this._body = val;
    },
    // 获取body的方法
    get body () {
        return this._body
    },
    set (field, val) {
        this.res.setHeader(field, val)
    }
}

delegates.js

koa\lib\delegates.js

// 定义一个Delegator函数，接收proto和target两个参数
function Delegator(proto, target) {
    // 如果当前函数不是通过new关键字调用的，那么就返回一个新的Delegator实例
    if (!(this instanceof Delegator)) return new Delegator(proto, target);
    // 将proto和target保存为Delegator实例的属性
    this.proto = proto;
    this.target = target;
}
// 在Delegator原型上定义一个access方法，这个方法接收一个name参数
Delegator.prototype.access = function (name) {
    // 调用getter和setter方法，将name属性的获取和设置代理到target对象
    return this.getter(name).setter(name);
};
// 在Delegator原型上定义一个getter方法，这个方法接收一个name参数
Delegator.prototype.getter = function (name) {
    // 保存proto和target属性
    var proto = this.proto;
    var target = this.target;
    // 在proto对象上定义一个name属性，这个属性的获取被代理到target对象
    Object.defineProperty(proto, name, {
        get: function () {
            return this[target][name];
        },
        configurable:true
    });
    // 返回当前Delegator实例
    return this;
};
// 在Delegator原型上定义一个setter方法，这个方法接收一个name参数
Delegator.prototype.setter = function (name) {
    // 保存proto和target属性
    var proto = this.proto;
    var target = this.target;
    // 在proto对象上定义一个name属性，这个属性的设置被代理到target对象
    Object.defineProperty(proto, name, {
        set: function (val) {
            this[target][name] = val;
        },
        configurable:true
    });
    // 返回当前Delegator实例
    return this;
};
Delegator.prototype.method = function(name){
    var proto = this.proto;
    var target = this.target;
    proto[name] = function(){
      return this[target][name].apply(this[target], arguments);
    };
    return this;
};
// 导出Delegator函数
module.exports = Delegator;

中间件级联

同步中间件

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3.server.js

const Koa = require('koa');
const app = new Koa();
const middleware1 = (ctx, next) => {
  console.log(1);
  next();
  console.log(2);
};
const middleware2 = (ctx, next) => {
  console.log(3);
  next();
  console.log(4);
};
const middleware3 = (ctx) => {
  console.log(5);
};
app.use(middleware1);
app.use(middleware2);
app.use(middleware3);
app.listen(3000, () => console.log('server is running at http://localhost:3000'));


(ctx, next) => {
  console.log(1);
  (ctx, next) => {
    console.log(3);
    (ctx) => {
      console.log(5);
    }
    console.log(4);
  }
  console.log(2);
}

异步中间件

img

server.js

const Koa = require('koa');
const app = new Koa();
const middleware1 = async (ctx, next) => {
  console.time('cost');
  console.log(1);
  await next();
  console.log(2);
  console.timeEnd('cost')
};
const middleware2 = async (ctx, next) => {
  console.log(3);
  await new Promise((resolve) => {
    setTimeout(() => {
      console.log('middleware2 sleep 1s');
      resolve();
    }, 1000);
  });
  await next();
  console.log(4);
};
const middleware3 = async (ctx) => {
  console.log(5);
  await new Promise((resolve) => {
    setTimeout(() => {
      console.log('middleware3 sleep 1s');
      resolve();
    }, 1000);
  });
  ctx.body = 'hello';
  console.log(6);
};
app.use(middleware1);
app.use(middleware2);
app.use(middleware3);
app.listen(3000, () => console.log('server is running at http://localhost:3000'));


1
3
middleware2 sleep 1s
5
middleware3 sleep 1s
6
4
2
cost: 2.022s

application.js

koa\lib\application.js

// 导入http模块
const http = require('http');
// 导入自定义的context模块
const context = require('./context.js');
// 导入自定义的request模块
const request = require('./request');
// 导入自定义的response模块
const response = require('./response');
+const compose = require('./koa-compose')
module.exports = class Application {
    // 构造函数
    constructor() {
        // 创建一个新的context对象，这个对象继承自自定义的context模块
        this.context = Object.create(context)
        // 创建一个新的request对象，这个对象继承自自定义的request模块
        this.request = Object.create(request)
        // 创建一个新的response对象，这个对象继承自自定义的response模块
        this.response = Object.create(response)
+       this.middleware = []
    }
    use(fn) {
        // 设置中间件处理函数
+       this.middleware.push(fn)
+       return this
    }
    listen(...args) {
        // 创建一个HTTP服务器实例，并使用回调函数作为请求处理程序
        const server = http.createServer(this.callback());
        // 监听指定的端口，并返回监听器对象
        return server.listen(...args);
    }
    callback() {
+       const fn = compose(this.middleware)
        const handleRequest = (req, res) => {
            // 创建上下文对象
            const ctx = this.createContext(req, res);
+           return this.handleRequest(ctx, fn);
        };
        // 返回请求处理函数
        return handleRequest;
    }
+   handleRequest(ctx, fnMiddleware) {
+       const handleResponse = () => respond(ctx);
+       return fnMiddleware(ctx).then(handleResponse);
+   }
    createContext(req, res) {
        // 创建一个新的context对象，这个对象继承自this.context
        const context = Object.create(this.context)
        // 创建一个新的request对象，这个对象继承自this.request，并将这个对象赋值给context.request
        const request = context.request = Object.create(this.request)
        // 创建一个新的response对象，这个对象继承自this.response，并将这个对象赋值给context.response
        const response = context.response = Object.create(this.response)
        // 将原生的req和res对象赋值给context、request和response的req和res属性
        context.req = request.req = req;
        context.res = response.res = res;
        // 返回创建的context对象
        return context;
    }
}
+function respond(ctx) {
+    let res = ctx.res;
+    let body = ctx.body;
+    return res.end(body);
+}

koa-compose.js

koa\lib\koa-compose.js

function compose(middleware) {
    return function (context) {
        function dispatch(i) {
            let fn = middleware[i];
            return Promise.resolve(fn(context, () => dispatch(i + 1)));
        }
        return dispatch(0);
    };
}
module.exports = compose;

错误处理

server.js

const Koa = require('./koa');
const app = new Koa();
const middleware1 = async (ctx, next) => {
 //throw new Error('middleware1 error');
 await next();
};
const middleware2 = async (ctx, next) => {
  throw new Error('middleware2 error');
};
app.use(middleware1);
app.use(middleware2);
app.listen(3000, () => console.log('server is running at http://localhost:3000'));

koa-compose.js

koa\lib\koa-compose.js

function compose(middleware) {
    return function (context) {
        function dispatch(i) {
            let fn = middleware[i];
+           if (!fn) return Promise.resolve()
+           try {
+               return Promise.resolve(fn(context, () => dispatch(i + 1)));
+           } catch (err) {
+               return Promise.reject(err)
+           }
        }
        return dispatch(0);
    };
}
module.exports = compose;

application.js

koa\lib\application.js

// 导入http模块
const http = require('http');
// 导入自定义的context模块
const context = require('./context.js');
// 导入自定义的request模块
const request = require('./request');
// 导入自定义的response模块
const response = require('./response');
const compose = require('./koa-compose')
module.exports = class Application {
    // 构造函数
    constructor() {
        // 创建一个新的context对象，这个对象继承自自定义的context模块
        this.context = Object.create(context)
        // 创建一个新的request对象，这个对象继承自自定义的request模块
        this.request = Object.create(request)
        // 创建一个新的response对象，这个对象继承自自定义的response模块
        this.response = Object.create(response)
        this.middleware = []
    }
    use(fn) {
        // 设置中间件处理函数
        this.middleware.push(fn)
        return this
    }
    listen(...args) {
        // 创建一个HTTP服务器实例，并使用回调函数作为请求处理程序
        const server = http.createServer(this.callback());
        // 监听指定的端口，并返回监听器对象
        return server.listen(...args);
    }
    callback() {
        const fn = compose(this.middleware)
        const handleRequest = (req, res) => {
            // 创建上下文对象
            const ctx = this.createContext(req, res);
            return this.handleRequest(ctx, fn);
        };
        // 返回请求处理函数
        return handleRequest;
    }
    handleRequest(ctx, fnMiddleware) {
        const handleResponse = () => respond(ctx);
+       const onerror = err => ctx.onerror(err)
+       return fnMiddleware(ctx).then(handleResponse).catch(onerror);
    }
    createContext(req, res) {
        // 创建一个新的context对象，这个对象继承自this.context
        const context = Object.create(this.context)
        // 创建一个新的request对象，这个对象继承自this.request，并将这个对象赋值给context.request
        const request = context.request = Object.create(this.request)
        // 创建一个新的response对象，这个对象继承自this.response，并将这个对象赋值给context.response
        const response = context.response = Object.create(this.response)
        // 将原生的req和res对象赋值给context、request和response的req和res属性
        context.req = request.req = req;
        context.res = response.res = res;
        // 返回创建的context对象
        return context;
    }
}
function respond(ctx) {
    let res = ctx.res;
    let body = ctx.body;
    return res.end(body);
}

context.js

koa\lib\context.js

// 导入自定义的代理（delegate）模块
const delegate = require('./delegates')
// 创建一个空对象proto并将其导出
const proto = module.exports = {
+   onerror(err) {
+       const { res } = this;
+       this.status = 500;
+       res.end(err.message)
+   }
}
// 使用代理模块将proto对象的一些属性代理到'request'对象
delegate(proto, 'request')
    .access('method')  // 将'request'对象的'method'属性代理到proto对象
    .access('query')   // 将'request'对象的'query'属性代理到proto对象
    .access('url')     // 将'request'对象的'url'属性代理到proto对象
    .access('path')    // 将'request'对象的'path'属性代理到proto对象
    .getter('header')  // 将'request'对象的'header'属性的获取代理到proto对象
// 使用代理模块将proto对象的一些属性代理到'response'对象
delegate(proto, 'response')
    .access('status')  // 将'response'对象的'status'属性代理到proto对象
    .access('message') // 将'response'对象的'message'属性代理到proto对象
    .access('body')    // 将'response'对象的'body'属性代理到proto对象
    .method('set')     // 将'response'对象的'set'方法代理到proto对象

multiple times

server.js

const Koa = require('./koa');
const app = new Koa();
const middleware1 = async (ctx, next) => {
+  await next(); 
+  await next();
};
const middleware2 = async (ctx, next) => {

};
app.use(middleware1);
app.use(middleware2);
app.listen(3000, () => console.log('server is running at http://localhost:3000'));

koa-compose.js

koa\lib\koa-compose.js

function compose(middleware) {
    return function (context) {
+       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 (!fn) return Promise.resolve()
            try {
                return Promise.resolve(fn(context, () => dispatch(i + 1)));
            } catch (err) {
                return Promise.reject(err)
            }
        }
        return dispatch(0);
    };
}
module.exports = compose;

body

server.js

const Koa = require('./koa');
const app = new Koa();
const fs = require('fs');
const middleware1 = async (ctx, next) => {
+ ctx.body = 'hello world';
+ //ctx.body = Buffer.from('hello world');
+ //ctx.body = fs.createReadStream('./package.json');
+ //ctx.body = {name:'hs'};
};
app.use(middleware1);
app.listen(3000, () => console.log('server is running at http://localhost:3000'));

application.js

koa\lib\application.js

// 导入http模块
const http = require('http');
// 导入自定义的context模块
const context = require('./context.js');
// 导入自定义的request模块
const request = require('./request');
// 导入自定义的response模块
const response = require('./response');
const compose = require('./koa-compose')
+const {Stream} = require('stream')
module.exports = class Application {
    // 构造函数
    constructor() {
        // 创建一个新的context对象，这个对象继承自自定义的context模块
        this.context = Object.create(context)
        // 创建一个新的request对象，这个对象继承自自定义的request模块
        this.request = Object.create(request)
        // 创建一个新的response对象，这个对象继承自自定义的response模块
        this.response = Object.create(response)
        this.middleware = []
    }
    use(fn) {
        // 设置中间件处理函数
        this.middleware.push(fn)
        return this
    }
    listen(...args) {
        // 创建一个HTTP服务器实例，并使用回调函数作为请求处理程序
        const server = http.createServer(this.callback());
        // 监听指定的端口，并返回监听器对象
        return server.listen(...args);
    }
    callback() {
        const fn = compose(this.middleware)
        const handleRequest = (req, res) => {
            // 创建上下文对象
            const ctx = this.createContext(req, res);
            return this.handleRequest(ctx, fn);
        };
        // 返回请求处理函数
        return handleRequest;
    }
    handleRequest(ctx, fnMiddleware) {
        const handleResponse = () => respond(ctx);
        const onerror = err => ctx.onerror(err)
        return fnMiddleware(ctx).then(handleResponse).catch(onerror);
    }
    createContext(req, res) {
        // 创建一个新的context对象，这个对象继承自this.context
        const context = Object.create(this.context)
        // 创建一个新的request对象，这个对象继承自this.request，并将这个对象赋值给context.request
        const request = context.request = Object.create(this.request)
        // 创建一个新的response对象，这个对象继承自this.response，并将这个对象赋值给context.response
        const response = context.response = Object.create(this.response)
        // 将原生的req和res对象赋值给context、request和response的req和res属性
        context.req = request.req = req;
        context.res = response.res = res;
        // 返回创建的context对象
        return context;
    }
}
function respond(ctx) {
+   let {res,body} = ctx;
+   if (Buffer.isBuffer(body)) return res.end(body)
+   if (typeof body === 'string') return res.end(body)
+   if (body instanceof Stream) return body.pipe(res)
+   res.end(JSON.stringify(body))
}

koa-static

server.js

const Koa = require('./koa');
const static = require('./koa-static');
const app = new Koa();
app.use(static(__dirname + '/static'));
app.listen(3000, () => console.log('server is running at http://localhost:3000'));

koa-static.js

koa-static.js

const { access } = require('fs/promises')
const { createReadStream } = require('fs')
const path = require('path')
module.exports = function (root) {
    return async function (ctx, next) {
        await next()
        if (!!ctx.body) return;
        const filename = path.join(root, ctx.path);
        if (await exists(filename)) {
            ctx.body = createReadStream(filename)
        }
    }
}
async function exists(path) {
    try {
        await access(path)
        return true
    } catch (e) {
        return false
    }
}

koa-bodyparser

server.js

const Koa = require('./koa');
const bodyparser = require('./koa-bodyparser');
const app = new Koa();
app.use(bodyparser());
app.use(async ctx => {
    if (ctx.url === '/' && ctx.method === 'GET') {
        // 显示表单页面
        let html = `
            <form method="POST" action="/">
                <p>userName</p>
                <input name="username"/><br/>
                <button type="submit">submit</button>
            </form>
        `;
        //设置响应头的类型text/html
        ctx.set('Content-Type', 'text/html;charset=utf-8');
        ctx.body = html;
    } else if (ctx.url === '/' && ctx.method === 'POST') {
        ctx.body = ctx.request.body;
    } else {
        ctx.body = '<h1>404!</h1>';
    }
});
app.listen(3000, () => console.log('server is running at http://localhost:3000'));

koa-bodyparser.js

koa-bodyparser.js

module.exports = function () {
    return async function bodyParser(ctx, next) {
        if (!!ctx.request.body)
            return await next();
        ctx.request.body = await parseBody(ctx.req);
        await next();
    };
};

function parseBody(req) {
    return new Promise((resolve) => {
        let buffers = [];
        req.on('data', chunk => {
            buffers.push(chunk);
        });
        req.on('end', () => {
            resolve(Buffer.concat(buffers).toString());
        });
    });
}

koa-router

server.js

server.js

const Koa = require('./koa');
const app = new Koa();
const Router = require('./koa-router.js');
const router = new Router();
router.get('/', async (ctx, next) => {
    ctx.body = 'Home';
    await next();
});
router.get('/user', async (ctx, next) => {
    ctx.body = 'User';
    await next();
});
app.use(router.routes());

app.listen(3000, () => console.log('server is running at http://localhost:3000'));

koa-router.js

koa-router.js

const methods = ['head', 'options', 'get', 'put', 'patch', 'post', 'delete'];
function Router() {
  this.stack = [];
}
for (const method of methods) {
  Router.prototype[method] = function (path, middleware) {
    this.stack.push({ path, method, middleware });
  };
}
Router.prototype.routes = function () {
  return async (ctx, next) => {
    const matched = this.stack.find(layer => {
      return layer.path === ctx.path && layer.method === ctx.method.toLowerCase();
    });
    if (!matched) return next();
    await matched.middleware(ctx, next);
  }
};
module.exports = Router;
若梦plus
关注
  • 34
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
nodejs koa
Jackmic_007的博客
06-01 345
nodejs 已经是前端通往全栈的必经之路，美好的一天就是代码一篇又一篇 今天学习一下koa及koa周边 1丶什么是Koa 简单来说KoaJS是基于NodeJs的Web开发框架使用原生node开发亦不是不可，但是相对于来说非常复杂，koa给我们简化了很多，举个例子 利用原生node起一个http服务 const http = require('http') //引用内置的http模块 const server = http.createServer((req,res)=>{ res.end('hel
Koa: 打造高效、灵活的Node.js后端 (介绍与环境部署)
极限突破者的博客
03-08 4968
Koa是一个新生代Node.js Web框架，由Express原团队成员开发，它的设计目标是成为一个更小、更富有表现力、更健壮的Web框架。中间件机制：Koa的中间件机制更加简洁、灵活，可以更好地控制请求和响应的流程。异步流程控制：Koa使用async/await来处理异步操作，使得代码更加简洁、易读。轻量级：Koa本身很小，只提供了最基本的功能，其他功能都可以通过中间件来扩展。高度可定制：Koa没有强制性的中间件，开发者可以自由选择和定制中间件来满足自己的需求。
Node js KOA 技术总结
最新发布
weixin_40426261的博客
06-09 607
Koa 是一个由 Express 团队开发的下一代 Node.js Web 框架，旨在通过更现代化和简洁的 API 提供更强大的功能和更高的性能。Koa 通过使用 ES6 的生成器（Generators）和 ES7 的异步函数（Async/Await），使得中间件的编写和组合变得更加直观和简洁。以下是对 Koa 技术的详细总结。概述概述Koa：是一个由 Express 团队开发的下一代 Node.js Web 框架。提供更加现代化和简洁的 API，旨在提高 Web 应用的开发效率和性能。
nodejs-koa
enhengcys的博客
03-22 293
nodejs搭建koa后端
nodejs-KOA
strayyiyi的博客
03-12 422
(1)安装KOA 和需要的组件npm install koa koa-router koa-bodyparser（2）最基本的语句// 导入koa，和koa 1.x不同，在koa2中，我们导入的是一个class，因此用大写的Koa表示: const Koa = require('koa'); // 创建一个Koa对象表示web app本身: const app = new Koa(); // ...
node.js koa
weixin_41040445的博客
05-08 288
koa 介绍 NodeJS是一个异步的，官方的API支持的都是回调函数形式的编程模型，这样的设计会造成很多问题，比如回调的问题 koa 是由 Express 原班人马打造的，致力于成为一个更小、更富有表现力、更健壮的 Web 框架。使用 koa 编写 web 应用，通过组合不同的 generator，可以免除重复繁琐的回调函数嵌套，并极大地提升错误处理的效率。koa 不在内核方法中绑定任何中间件，它仅仅提供了一个轻量优雅的函数库，使得编写 Web 应用变得得心应手。 官网：https://www.ko
node.js -- koa
CSDN_GMC的博客
04-07 234
node.js -- koakoa1. koa介绍2. koa使用2.1 Application对象2.2 上下文content对象常用属性及方法2.3 中间件2.4 koa常用中间件koa-routerkoa-statickoa-views koa 1. koa介绍   koa是express原班⼈⻢打造的轻量、健壮、富有表现⼒的nodejs框架。⽬前koa有koa1和koa2两个版本；koa2...
nodejs-koa:nodejs之koa服务端渲染，纯练习用
05-07
在“nodejs-koa:nodejs之koa服务端渲染，纯练习用”这个项目中，重点在于学习和实践 Koa 框架如何进行服务端渲染。服务端渲染（Server-Side Rendering, SSR）是一种 Web 应用程序的开发模式，它允许在服务器端生成 ...
nodejs之koa2请求示例(GET,POST)
10-18
本篇文章主要介绍了nodejs之koa2请求示例(GET,POST)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
使用nodejs的koa框架连接MongoDB数据库.zip
11-05
在Node.js环境中，Koa是基于ExpressJS之上构建的一个现代化的Web应用框架，它提供了更加简洁、优雅的方式来处理HTTP请求和响应。MongoDB则是一种流行的NoSQL数据库，以JSON格式的文档存储数据，广泛用于非结构化数据...
nodejs-koa-blog：基于Node.js Koa2实战开发的一套完整的博客项目网站
02-03
一，这是个什么的项目？ 基于Node.js Koa2实战开发的一套完整的博客项目网站，使用Koa2二次开发套件适合多端的RESTful API，同时配套完整的后台管理系统，并前端展示既有基于ejs服务端渲染，也有基于Vue.js前瞻分离的2套前端网站。 博客线上地址是： : 二，项目包含什么功能？ 2.1.Node.js Koa2服务端RESTful API 管理员与权限控制接口 文章管理接口 评论/回复功能接口 分类接口 广告接口 2.2。博客前端展示网站 ejs服务端渲染 Vue.js前瞻分离 2.2。后台管理系统 使用Vue.js iviewui设计构建的后台管理系统 2.3。优势 使用精小而强大的Node.js Koa2框架做服务端API接口。 前端既有服务端渲染，也有前细分分离，并且做彻底的优化工作，前端展示网站打开快。 性能优化方面的工作： 服务端使用了缓存机制，减少服务器的请求压力，如Redis缓存，HTTP缓存 使用了CND加速，静态文件存储在七牛服务器上 ejs服务端渲染尽量减少文件的约会，减少对DOM的操作，并封装使用了图片懒加载，事件防抖和节流控制浏览器滚动监
koa-generator：Koa脚手架（Koa-NodeJs应用Koa的脚手架）
02-27
^ _ ^KOA程序Koa脚手架（Koa-NodeJs Application的Koa的脚手架）。为什么叫这个名字：因为网上基于KOA开头的项目和脚手架很多，但是方便大家好记，我采用了koa-program 。KOA代表KOA项目，PROGRM代表程式。使用方法...
node.js的koa框架
qq_32439381的博客
08-11 345
一、安装部署 1.在cmd输入 npm install -g koa-generator 2.创建工作目录 koa2 HelloKoa2 进入项目输入以下命令，或者用淘宝镜像安装 cd HelloKoa2  3.项目如果需要连接数据库，需要在package.json里dependencies添加以下内容 "mysql": "latest",
nodejs -- koa框架
King Saj
05-04 816
Koa 是一个基于 Node.js 的 Web 框架，它提供了一组简洁而优雅的 API，使得编写 Web 应用程序变得更加容易和快捷。首先，需要安装 Node.js 运行环境。可以从 Node.js 官网下载适合自己操作系统的安装包，并按照提示进行安装。这将创建一个名为my-koa-app的新目录，并在其中初始化一个新的 Node.js 项目。-y参数将启用默认设置，跳过对项目的交互式询问。这将在 Node.js 项目中安装 Koa 模块，并将其添加到项目的依赖列表中。在my-koa-app。
Nodejs-Koa框架
weixin_47342624的博客
10-29 3760
请求地址：http://localhost:8000/login?nodejs中除了express框架， 另外一个非常流行的Node Web服务器框架就是Koa。koa官方并没有给我们提供路由的库，我们可以选择第三方 库：koa-router。请求地址：http://localhost:8000/login。真实开发中我们如何将路径和method分离呢？
NodeJS koa 的使用
weixin_45932157的博客
03-26 443
const koa = require("koa"); const app = new koa(); app.use((ctx) => { ctx.body = "Hello zhihu aa"; console.log(ctx) }) app.listen(3000, function() { console.log("请访问127.0.0.1:3000"); });
nodejs--koa--基础
小白小白从不日别的博客
12-01 1125
什么是框架(frame)： 封装原生代码的API 规范流程和格式 让开发人员更加关注业务代码，提高开发效率 框架(frame)和库(lib)的区别： 框架是唯一的，库就可以共存 框架关注全流程，库关注单个功能 koa2的安装和使用： 初始化npminit 安装npminstallkoa2--save 基本使用 初体验： 前提：在项目根目录下 const Koa = require('koa'); const app = new Koa(); // ...
nodejs之koa框架学习
u013196396的博客
08-26 512
简介： Koa 是一个新的 web 框架，由 Express 幕后的原班人马打造， 致力于成为 web 应用和 API 开发领域中的一个更小、更富有表现力、更健壮的基石。 通过利用 async 函数，Koa 帮你丢弃回调函数，并有力地增强错误处理。 Koa 并没有捆绑任何中间件， 而是提供了一套优雅的方法，帮助您快速而愉快地编写服务端应用程序。(摘自官网） 使用前提： Koa 依赖 node ...
nodejs koa2 新增
10-25
Node.js是一个基于Chrome V8引擎的JavaScript运行环境，可以使JavaScript在服务器端运行。而Koa2是一个基于Node.js的Web框架，它提供了一系列的API和工具，使得开发Web应用变得更加简单和高效。最近Koa2新增了一些特性，包括： 1. async/await：Koa2支持使用async/await来处理异步操作，这使得代码更加简洁易懂。 2. Context对象的简化：Koa2的Context对象被简化了，使得开发者可以更加方便地访问请求和响应的信息。 3. 更好的错误处理：Koa2提供了更好的错误处理机制，使得开发者可以更加方便地处理错误。 4. 更好的中间件支持：Koa2的中间件机制得到了改进，使得开发者可以更加方便地编写和使用中间件。 5. 更好的路由支持：Koa2的路由机制得到了改进，使得开发者可以更加方便地编写和使用路由。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值