与 express 不一样的是，koa 自身连路由系统也没有，需要额外安装路由中间件插件。这给开发者带来了更多的选择，你既可以使用 koa 官方团队提供的路由中间件 koa-router，也可以选择其它的方式实现 Koa Web 的路由。也就是说，是否使用官方的 koa-router 其实并非强制的。

如上所述 koa-router 是一款由 koa 官方以 中间件 形式提供的路由模块，它能完成我们一般的路由功能，并且由于是官方所提供的插件，很多第三方插件更倾向于基于 koa-router 进行推出，因此在本文中也使用它进行路由的讲解，这对于 Web 后端类项目的初学者也更加友好。

另外， koa-router 是 express 路由风格的路由，这大概由于 koa 和 express 是同一个团队进行开发的有较大关系。对于熟悉 express 的读者可以直接入手。

要使用 koa-router 需要先进行安装。目前 koa 团队规范了 路由模块 的项目名称，从旧版的 koa-router 迁移到了新的 @koa/router。因此依据当前最新的文档，你可以使用如下方式对 koa-router 进行安装：

npm i @koa/router
# or
yarn add @koa/router
# or
pnpm i @koa/router

（依据你项目所使用的包管理工具进行选择）

由于我们使用 TypeScript 进行开发，而 koa-router 本身不包含 TypeScript 源码或者相应的类型声明文件。因此为了更好地获得类型的支持，还需要独立安装对应的类型模块。

在 koa-router 项目名迁移到 @koa/router 后，对应的类型模块项目名为 @types/koa__router。因此你可以通过下面的方式为路由添加 TypeScript 支持：

npm install @types/koa__router -D
# or
yarn add -D @types/koa__router
# or
pnpm install @types/koa__router -D

（依据你项目所使用的包管理工具进行选择）

我们用的主要就是 Router 对象，它是一个类，其类型签名如下：

declare class Router<StateT = Koa.DefaultState, ContextT = Koa.DefaultContext> {
    opts: Router.RouterOptions;
    methods: string[];
    params: object;
    stack: Router.Layer[];

    /**
     * 创建新路由器。
     */
    constructor(opt?: Router.RouterOptions);

    /**
     * 使用给定的中间件。
     *
     * 中间件按照 `.use()` 定义的顺序运行。它们被顺序调用，请求从第一个中间件开始，沿着中间件堆栈 "down"（向下） 传递。
     */
    use(...middleware: Array<Router.Middleware<StateT, ContextT>>): Router<StateT, ContextT>;
    /**
     * 使用给定的中间件。
     *
     * 中间件按照 `.use()` 义的顺序运行。它们被顺序调用，请求从第一个中间件开始，沿着中间件堆栈"down"（向下）传递。
     */
    use(
        path: string | string[] | RegExp,
        ...middleware: Array<Router.Middleware<StateT, ContextT>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP get 方法
     */
    get<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP get 方法
     */
    get<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP post 方法
     */
    post<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP post 方法
     */
    post<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP put 方法
     */
    put<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP put 方法
     */
    put<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP link 方法
     */
    link<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP link 方法
     */
    link<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP unlink 方法
     */
    unlink<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP unlink 方法
     */
    unlink<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP delete 方法
     */
    delete<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP delete 方法
     */
    delete<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     *  `router.delete()` 的别名，因为delete是保留字
     */
    del<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     *  `router.delete()` 的别名，因为delete是保留字
     */
    del<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP head 方法
     */
    head<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP head 方法
     */
    head<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP options 方法
     */
    options<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP options 方法
     */
    options<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * HTTP patch 方法
     */
    patch<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * HTTP patch 方法
     */
    patch<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * 用所有方法注册路由。
     */
    all<T = {}, U = {}, B = unknown>(
        name: string,
        path: string | RegExp,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;
    /**
     * 用所有方法注册路由。
     */
    all<T = {}, U = {}, B = unknown>(
        path: string | RegExp | Array<string | RegExp>,
        ...middleware: Array<Router.Middleware<StateT & T, ContextT & U, B>>
    ): Router<StateT, ContextT>;

    /**
     * 为已经初始化的路由器实例设置路径前缀。
     *
     * @example
     *
     * ```javascript
     * router.prefix('/things/:thing_id')
     * ```
     */
    prefix(prefix: string): Router<StateT, ContextT>;

    /**
     * 返回路由器中间件，它分派与请求匹配的路由。
     */
    routes(): Router.Middleware<StateT, ContextT>;

    /**
     * 返回路由器中间件，它分派与请求匹配的路由。
     */
    middleware(): Router.Middleware<StateT, ContextT>;

    /**
     * 返回单独的中间件，用于响应带有包含允许方法的 `Allow` 请求头的 `OPTIONS` 请求，以及适当地响应“405 方法不允许” 和 “501 未实现”。
     *
     * @example
     *
     * ```javascript
     * var Koa = require('koa');
     * var Router = require('koa-router');
     *
     * var app = new Koa();
     * var router = new Router();
     *
     * app.use(router.routes());
     * app.use(router.allowedMethods());
     * ```
     *
     * **使用[Boom](https://github.com/hapijs/boom)的例子：**
     *
     * ```javascript
     * var Koa = require('koa');
     * var Router = require('koa-router');
     * var Boom = require('boom');
     *
     * var app = new Koa();
     * var router = new Router();
     *
     * app.use(router.routes());
     * app.use(router.allowedMethods({
     *   throw: true,
     *   notImplemented: () => new Boom.notImplemented(),
     *   methodNotAllowed: () => new Boom.methodNotAllowed()
     * }));
     * ```
     */
    allowedMethods(
        options?: Router.RouterAllowedMethodsOptions
    ): Router.Middleware<StateT, ContextT>;

    /**
     * 使用可选的 30x 状态 `code` 将 `source` 重定向到 `destination` URL。
     *
     * `source` 和 `destination` 都可以是路由名.
     *
     * ```javascript
     * router.redirect('/login', 'sign-in');
     * ```
     *
     * 这相当于：
     *
     * ```javascript
     * router.all('/login', ctx => {
     *   ctx.redirect('/sign-in');
     *   ctx.status = 301;
     * });
     * ```
     */
    redirect(source: string, destination: string, code?: number): Router<StateT, ContextT>;

    /**
     * 创建并注册一个 route。
     */
    register(
        path: string | RegExp,
        methods: string[],
        middleware: Router.Middleware<StateT, ContextT> | Array<Router.Middleware<StateT, ContextT>>,
        opts?: Router.LayerOptions,
    ): Router.Layer;

    /**
     * 具有给定 `name` 的 Lookup route。
     */
    route(name: string): Router.Layer | boolean;

    /**
     * 为 route 生成URL。接受命名`params` 的映射或一系列参数(对于正则表达式路由)
     *
     * router = new Router();
     * router.get('user', "/users/:id", ...
     *
     * router.url('user', { id: 3 });
     * // => "/users/3"
     *
     * 可以从第三个参数生成查询（query）:
     *
     * router.url('user', { id: 3 }, { query: { limit: 1 } });
     * // => "/users/3?limit=1"
     *
     * router.url('user', { id: 3 }, { query: "limit=1" });
     * // => "/users/3?limit=1"
     *
     */
    url(name: string, params?: any, options?: Router.UrlOptionsQuery): Error | string;

    /**
     * 匹配给定的 `path` 并返回相应的routes。
     */
    match(path: string, method: string): Router.RoutesMatch;

    /**
     * 为命名的路由参数运行中间件。适用于自动加载或验证。
     *
     * @example
     *
     * ```javascript
     * router
     *   .param('user', (id, ctx, next) => {
     *     ctx.user = users[id];
     *     if (!ctx.user) return ctx.status = 404;
     *     return next();
     *   })
     *   .get('/users/:user', ctx => {
     *     ctx.body = ctx.user;
     *   })
     *   .get('/users/:user/friends', ctx => {
     *     return ctx.user.getFriends().then(function(friends) {
     *       ctx.body = friends;
     *     });
     *   })
     *   // /users/3 => {"id": 3, "name": "Alex"}
     *   // /users/3/friends => [{"id": 4, "name": "TJ"}]
     * ```
     */

    param<BodyT = unknown>(param: string, middleware: Router.ParamMiddleware<StateT, ContextT, BodyT>): Router<StateT, ContextT>;

    /**
     * 为路由生成URL。接受一个路径名和一个名为 `params` 的 map。
     *
     * @example
     *
     * ```javascript
     * router.get('user', '/users/:id', (ctx, next) => {
     *   // ...
     * });
     *
     * router.url('user', 3);
     * // => "/users/3"
     *
     * router.url('user', { id: 3 });
     * // => "/users/3"
     *
     * router.use((ctx, next) => {
     *   // 重定向到命名路由
     *   ctx.redirect(ctx.router.url('sign-in'));
     * })
     *
     * router.url('user', { id: 3 }, { query: { limit: 1 } });
     * // => "/users/3?limit=1"
     *
     * router.url('user', { id: 3 }, { query: "limit=1" });
     * // => "/users/3?limit=1"
     * ```
     */
    static url(path: string | RegExp, params: object): string;
 }

HTTP 定义了一组请求方法, 以表明要对给定资源执行的操作。指示针对给定资源要执行的期望动作。HTTP 动词 是用于 HTTP 请求方法中的一系列的值，包括了：

顾名思义，所谓 命名路由 就是给一个路由起别名。也就是说，路由可以有名称，这允许我们在开发过程中生成URL和简单地去重命名URL。

以 get 请求为例，Router 对象上的 get 是两个 重载 的方法，当其中一个重载方法参数为 path、...middleware，而另外一个为 name、path、...middleware。这就是说我们可以给 get 方法描述的路由在第一个参数的位置多指定一个 name 字符串参数来表示路由名，比如：

router.get('user', '/users/:id', (ctx, next) => {
 // ...
});

这里的 'user' 对应于 name，即该条路由被命名为 usrt。定义了名字自然是为了更方便地来进行使用地。

Router 对象上的 url 方法可以为路由生成URL，它接受的第一个参数就是 命名路由的路由名name 。该方法的类型签名为：

url(name: string, params?: any, options?: Router.UrlOptionsQuery): Error | string;

我们就用它来试一下：

router.url('user', 3);  // => "/users/3"

其中，这里就是把 param 值 （3）赋给了 名字为 user 的路由中后面的 parameter （/:id），因此就是/users/3。

顾名思义，所谓 嵌套路由就是在接续一个路由以同样地方式定义子路由。从实现层面上看，路由地使用是通过中间件使用上的嵌套。 例如：

const father = new Router();
const child = new Router();


child.get('/', (ctx, next) => {...});
child.get('/:pid', (ctx, next) => {...});

routers1.use(
  '/father/:fid/child', 
  posts.routes(),
  routers2.allowedMethods()
);

// 响应于 "/father/123/child" 
// 和 "/father/123/child/123"
app.use(routers1.routes());

嵌套的子路由自动地被继承其了父路由作为它地前缀，不过还可以手动在实例化 Router 对象时为路由添加前缀。例如：

const router = new Router({
  prefix: '/users'
});

router.get('/', ...); // responds to "/users"
router.get('/:id', ...); // responds to "/users/:id"