message：错误提示信息
name：错误名称（非标准属性）宿主环境赋予
stack：错误的堆栈（非标准属性）宿主环境赋予

SyntaxError对象是解析代码时发生的语法错误
ReferenceError对象是引用一个不存在的变量时发生的错误
RangeError对象是一个值超出有效范围时发生的错误(一是数组长度为负数，二是Number对象的方法参数超出范围，以及函数堆栈超过最大值)
TypeError对象是变量或参数不是预期类型时发生的错误：对字符串、布尔值、数值等原始类型的值使用new命令
URIError对象是 URI 相关函数的参数不正确时抛出的错误：使用函数不当
eval函数没有被正确执行时，会抛出EvalError错误 - 不再使用，为了代码兼容

范围：用来捕获任何类型的同步错误，可以捕获async / await的代码，但无法捕获promise、setTimeout、dom回调(eg:onclick点击回调)的代码，在回调函数里面写try…catch可以捕获，但包在外面不会捕获，无法捕获语法错误

异步不捕获原因：

async/await捕获原因：window.onerror

范围：同步错误和异步错误都可以捕获，但无法捕获到静态资源异常，或者接口异常(网络请求异常不会事件冒泡，因此必须在捕获阶段将其捕捉到才行)，无法捕获语法错误

原理：当 JS 运行时错误发生时，window 会触发一个 ErrorEvent 接口的 error 事件

参数

/**
* @param {String}  message    错误信息
* @param {String}  source    出错文件
* @param {Number}  lineno    行号
* @param {Number}  colno    列号

客户端：script标签添加crossOrigin

服务端：设置：Access-Control-Allow-Origin

解决：window 对象的 load 和 beforeunload 事件实现了网页崩溃的监控

window.addEventListener('load', function () {
    sessionStorage.setItem('good_exit', 'pending');
    setInterval(function () {
        sessionStorage.setItem('time_before_crash', new Date().toString());
    }, 1000);
  });
  window.addEventListener('beforeunload', function () {
    sessionStorage.setItem('good_exit', 'true');
  });
  if(sessionStorage.getItem('good_exit') &&
    sessionStorage.getItem('good_exit') !== 'true') {
    /*
        insert crash logging code here
    */
    alert('Hey, welcome back from your crash, looks like you crashed on: ' + sessionStorage.getItem('time_before_crash'));
  }

解决：Service Worker 来实现网页崩溃的监控

一般错误处理：如某种回退，基本上只是说：“有错误，请再试一次或联系我们”。这并不是特别聪明，但至少通知用户，有地方错了——而不是无限加载或进行类似地处理

特殊错误处理为用户提供详细信息，让用户了解有什么问题以及如何解决它，例如，有信息丢失，数据库中的条目已经存在等等

1. 构建一个自定义 Error 构造函数:让我们方便地获得堆栈跟踪

class CustomError extends Error {
    constructor(code = 'GENERIC', status = 500, ...params) {
        super(...params)
        if (Error.captureStackTrace) {
            Error.captureStackTrace(this, CustomError)
        }
        this.code = code
        this.status = status
    }
}

module.exports = CustomError

2.处理路由：对于每一个路由，我们要有相同的错误处理行为

wT：在默认情况下，由于路由都是封装的，所以 Express 并不真正支持那种方式

解决：实现一个路由处理程序，并把实际的路由逻辑定义为普通的函数。这样，如果路由功能（或任何内部函数）抛出一个错误，它将返回到路由处理程序，然后可以传给前端

const express = require('express')
const router = express.Router()
const CustomError = require('../CustomError')

router.use(async (req, res) => {
    try {
        const route = require(`.${req.path}`)[req.method]

        try {
            const result = route(req) // We pass the request to the route function
            res.send(result) // We just send to the client what we get returned from the route function
        } catch (err) {
            /*
            This will be entered, if an error occurs inside the route function.
            */
            if (err instanceof CustomError) {
                /* 
                In case the error has already been handled, we just transform the error 
                to our return object.
                */

                return res.status(err.status).send({
                    error: err.code,
                    description: err.message,
                })
            } else {
                console.error(err) // For debugging reasons

                // It would be an unhandled error, here we can just return our generic error object.
                return res.status(500).send({
                    error: 'GENERIC',
                    description: 'Something went wrong. Please try again or contact support.',
                })
            }
        }
    } catch (err) {
        /* 
        This will be entered, if the require fails, meaning there is either 
        no file with the name of the request path or no exported function 
        with the given request method.
        */
        res.status(404).send({
            error: 'NOT_FOUND',
            description: 'The resource you tried to access does not exist.',
        })
    }
})

module.exports = router

// 实际路由文件
const CustomError = require('../CustomError')

const GET = req => {
    // example for success
    return { name: 'Rio de Janeiro' }
}

const POST = req => {
    // example for unhandled error
    throw new Error('Some unexpected error, may also be thrown by a library or the runtime.')
}

const DELETE = req => {
    // example for handled error
    throw new CustomError('CITY_NOT_FOUND', 404, 'The city you are trying to delete could not be found.')
}

const PATCH = req => {
    // example for catching errors and using a CustomError
    try {
        // something bad happens here
        throw new Error('Some internal error')
    } catch (err) {
        console.error(err) // decide what you want to do here

        throw new CustomError(
            'CITY_NOT_EDITABLE',
            400,
            'The city you are trying to edit is not editable.'
        )
    }
}

module.exports = {
    GET,
    POST,
    DELETE,
    PATCH,
}

3.构建全局错误处理机制

process.on('uncaughtException', (error: any) => {
    logger.error('uncaughtException', error)
})

process.on('unhandledRejection', (error: any) => {
    logger.error('unhandledRejection', error)
})