一个良好的编码习惯必然离不开异样解决，本文将会介绍如何在 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，这个时候须要定义若干的业务逻辑错误代码，像上面这样的

这个时候，就须要在业务层中进行解决。

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

这样就实现了一次的改写。

微信公众号