errors

错误处理在编程中是不可避免的一部分，在程序开发过程中，不可必要的会出现各种的错误，是人为也可能是失误，任何不可预料的可能都会发生

为了更好的保证程序的健壮性和稳定性

我们必须要对错误处理有更好的认识

最近迷上了golang的错误处理哲学，希望由浅入深的总结一下自己的思考和看得见的思考

👀 用 error 表示可能出现的错误，用throw强制抛出错误

通常情况下错误处理的方式无非不过两种

泛处理
精处理

其实都很好理解

// 伪代码

try {
const file = await readFile('../file')

const content =  filterContent(file)

} catch (e) {
  alert('xxxx',e.msg)
}

泛处理指的是对所有可能的错误都使用相同的处理方式，比如在代码中使用相同统一的错误提示信息

这种方式适用于一些简单的，不太可能发生的错误，比如文件不存在，网络连接超时等。

对于更加复杂的错误，应该使用精处理，即根据具体情况对不同类型的错误进行特定的处理


const [readErr,readFile] = await readFile('../file')

if (readErr) {
    // 处理读取错误
    return 
}

const [filterErr,filterContent] =  filterContent(readFile)

if (filterErr) {
    // 处理过滤错误
    return
}

精处理可以让我们把控计划的每一步，问题也很显然暴露了出来，过于麻烦

在实际开发当中，我们需要根据实际情况选择适当的方式进行错误处理。

由于本人是精处理分子，基于此开发了一个js版本的errors包

如何定义一个错误

import { Errors } from '@memo28/utils'

Errors.News('err')

如何给一个错误分类

import { Errors } from '@memo28/utils'

Errors.News('err', { classify: 1 })

如何判断两个错误是相同类型

import { Errors } from '@memo28/utils'

Errors.As(Errors.News('err', { classify: 1 }),
Errors.News('err2', { classify: 1 })) // true

Errors.As(Errors.News('err', { classify: 1 }),
Errors.News('err2', { classify: 2 })) // false

一个错误包含了哪些信息？

Errors.New('as').info() // { msg: 'as' , classify: undefined }

Errors.New('as').trace() // 打印调用栈

Errors.New('as').unWrap() // 'as'

最佳实践

import { AnomalousChain, panicProcessing } from '@memo28/utils'

class A extends AnomalousChain {
  // 定义错误处理函数,
  // 当每次执行的被 panicProcessing 装饰器包装过的函数都会检查 是否存在 this.errors 是否为 ErrorsNewResult 类型
  // 如果为 ErrorsNewResult 类型则 调用 panicProcessing的onError回调 和 skip函数
  skip(errors: ErrorsNewResult | null): this {
    console.log(errors?.info().msg)
    return this
  }

  @panicProcessing()
  addOne(): this {
    console.log('run one')
    super.setErrors(Errors.New('run one errors'))
    return this
  }

  @panicProcessing({
    // 在 skip 前执行
    onError(error) {
      console.log(error.unWrap())
    },
    // onRecover 从错误中恢复, 当返回的是true时 继续执行addTwo内逻辑，反之
    // onRecover(erros) {
    //   return true
    // },
  })
  addTwo(): this {
    console.log('run two')
    return this
  }
}
new A().addOne().addTwo()



// output
run one
run one errors // in onError
run one errors // in skip fn

当作状态机使用

class Test extends AnomalousChain {
    constructor(status) {
        this.status = status
        if(typeof status !== 'number') this.setErrors(Errors.New('not number!'))
    }

    skip(errors: ErrorsNewResult | null): this {
      alert(errors?.info().msg)
      return this
    }

    @panicProcessing()
    runOne(){
        if (![1].includes(this.status)) return this
        return this
    }
    @panicProcessing()
    runTwo(){
        if (![2].includes(this.status)) return this
        return this
    }

}

new Test(null).runOne().runOne() // 什么都不会输出,因为status不是一个数字

抛弃trycatch，用go的思想去处理js异常

errors

最佳实践

当作状态机使用