一个良好的编码习惯必然离不开异常处理，本文将会介绍如何在koa框架下面如何抛出错误，并统一处理返回异常。

正常错误处理

koa是一个优秀的NodeJs web框架，在我们开发web项目的时候，避免不了任何错误处理，包括http错误以及自定义的业务逻辑处理。
在Node.js 中，抛出错误如下

if(someCondition){
    throw Error("Error");
}

Http错误处理

这里使用ctx.throw(400)的方式，抛出http错误，同时返回一些信息。

ctx.status = 400
ctx.body = {
    msg: "some params is invalid"
}

此时既返回了状态码，又返回了相关的错误信息。

业务逻辑错误处理

如果需要开发Restful API server，这个时候需要定义若干的业务逻辑错误代码，像下面这样的

code码	说明
0	success
-1	server error
4001	token 过期

这个时候，就需要在业务层中进行处理。

router.get("/", (ctx, next) => {
    if(tokenExpire(token)){
        const errcode = ERROR_CODE.TOKEN_EXPIRED;
        ctx.body = {
            errcode,
            msg: ERROR_MSG[errcode]
        }
        return
    }
})

这里，就返回了相关的errcode，通过errcode的方式返回了相关的错误代码

全局捕获异常处理

这里在koa里，全局捕获异常，这里使用中间件的方式，确保异常可以捕获到
在middlewares建立一个catcherror中间件，达到捕获到异常的方式

// middlewares/catcherror.js
const catchError = async(ctx, next) => {
    try{
        await next();
    }catch(error){
        if(error.errorCode){
            console.log("捕获到异常")
            return ctx.body = errror.msg;
        }
    }
}
module.exports = catchError

这样定义一个中间件，在中间件进行相关的捕获，确保捕获到相关的异常，并把这个中间件进行导出。

放在next里面，如果next程序出现异常，就可以实现在中间件进行相关的捕获。

const koa = require("koa")
const Router = require("router")
const app = new koa();
const router = new Router();
const catchError = require("./middlewares/catcherror")

app.use(catchError)

router.get('/login', (ctx, next) => {
    const path = ctx.request.query;
    
    // 主动抛出错误
    if(true){
        const error = new Error();
        error.errorCode = 1000;
        error.msg = "错误";
        throw error
    }
})

app.use(router.routers())
app.listen(3000)

这个时候，凭借着中间件，可以实现抛出错误异常。

使用基类的方式处理

主动抛出错误，会显示的相当麻烦，这里使用面向对象的方式，继承error类。
把错误信息，放入到error类中，通过放入error类中，实现对错误的直接抛出。

// core/http-exception.js

class HttpException extends Error{
    constructor(msg = '服务器异常', errorCode = 1000. code = 400){
        super();
        this.msg = msg;
        this.code = code;
        this.errorCode = errorCode;
    }
}
module.export = HttpException

再次改写app.js

// app.js
const koa = require('koa')
const Router = require('router')
const app = new koa()
const router = new Router()
const {HttpException} = require('../core/http-exception')
const catchError = require('./middlewares/catcherror')

app.use(catchError) //一定要放在第一个中间件

router.get('/login',(ctx,next)=>{
    const path = ctx.request.query
    
    // 我们主动抛出一个错误
    if(true){
        // 主要改写这里，创建新的异常
        const error = new HttpException('登录错误',10000,500)
        throw error
    }
})

app.use(router.routes())
app.listen(3000)

再次改写中间件，判断异常是否属于此异常的对象

// middlewares/catcherror.js
const {HttpException} = require('../core/http-exception')
const catchEoore = async (ctx,next)=>{
        try{
            await next()
        } catch(error){
            if(error instanceof HttpExcetion){
                return ctx.body = error.msg
            }
        }
    }
}

module.exports = catchError

这样就完成了一次的改写。