ES6的Error子类如何自定义错误类型

// 定义一个自定义的验证错误类型
class ValidationError extends Error {
    constructor(message, field) {
        // 调用父类（Error）的构造函数
        super(message);

        // 设置错误的名称，这很重要，因为它默认是'Error'
        this.name = 'ValidationError';

        // 添加自定义属性，以提供更多上下文信息
        this.field = field;

        // 保持堆栈跟踪的正确性 (可选，但在某些环境中很有用)
        // if (Error.captureStackTrace) {
        //     Error.captureStackTrace(this, ValidationError);
        // }
    }
}

// 定义一个自定义的网络错误类型
class NetworkError extends Error {
    constructor(message, statusCode, endpoint) {
        super(message);
        this.name = 'NetworkError';
        this.statusCode = statusCode;
        this.endpoint = endpoint;
    }
}

// 如何使用和抛出这些自定义错误
function processUserData(data) {
    if (!data || !data.username) {
        throw new ValidationError('用户名不能为空', 'username');
    }
    // 模拟一个网络请求失败
    if (data.username === 'admin') {
        throw new NetworkError('API请求失败', 500, '/api/users');
    }
    return `用户 ${data.username} 处理成功。`;
}

// 捕获和处理自定义错误
try {
    // 尝试处理一个会抛出ValidationError的数据
    // processUserData({ age: 30 });

    // 尝试处理一个会抛出NetworkError的数据
    processUserData({ username: 'admin', age: 40 });

} catch (error) {
    if (error instanceof ValidationError) {
        console.error(`捕获到验证错误：${error.message}，问题字段：${error.field}`);
        // 实际应用中：可以向用户显示具体的错误提示
    } else if (error instanceof NetworkError) {
        console.error(`捕获到网络错误：${error.message}，状态码：${error.statusCode}，请求端点：${error.endpoint}`);
        // 实际应用中：记录日志，尝试重试，或显示网络异常提示
    } else if (error instanceof Error) {
        // 捕获所有其他标准的Error实例
        console.error(`捕获到未知错误：${error.message}`);
        console.error(error.stack); // 打印完整的堆栈信息，便于调试
    } else {
        // 捕获那些不是Error实例的抛出（虽然不推荐，但可能发生）
        console.error('捕获到一个非Error对象：', error);
    }
}

// 假设我们需要一个更复杂的错误，比如一个服务层面的错误
class ServiceError extends Error {
    constructor(message, errorCode, details = {}) {
        super(message);
        this.name = 'ServiceError';
        this.errorCode = errorCode; // 自定义的错误码，比如 'USER_NOT_FOUND', 'INVALID_INPUT'
        this.details = details;     // 包含更多细节的对象，比如哪个参数错了，或原始的错误响应
    }
}

// 使用示例
function getUserProfile(userId) {
    if (userId === 'invalid') {
        // 抛出一个带有详细信息的ServiceError
        throw new ServiceError(
            '用户ID无效',
            'INVALID_USER_ID',
            { input: userId, suggestion: '请提供一个有效的用户ID' }
        );
    }
    if (userId === 'not_found') {
        throw new ServiceError(
            '用户未找到',
            'USER_NOT_FOUND',
            { queriedId: userId, databaseStatus: 'offline' } // 甚至可以包含内部状态
        );
    }
    return { id: userId, name: `User ${userId}` };
}

try {
    // getUserProfile('invalid');
    getUserProfile('not_found');
} catch (error) {
    if (error instanceof ServiceError) {
        console.error(`服务错误：[${error.errorCode}] ${error.message}`);
        console.error('详细信息：', error.details);
        // 根据errorCode和details，可以做更细致的错误处理或日志记录
    } else {
        console.error('捕获到其他错误：', error);
    }
}

// 假设有一个处理订单的函数
async function processOrder(orderId, userId) {
    if (!orderId || !userId) {
        throw new ValidationError('订单ID和用户ID都不能为空', 'orderId/userId');
    }

    try {
        // 模拟调用一个外部服务来获取订单详情
        const orderDetails = await fetchOrderDetailsFromAPI(orderId);
        if (!orderDetails) {
            throw new NotFoundError(`订单 ${orderId} 未找到`, 'ORDER'); // 假设定义了一个NotFoundError
        }

        // 模拟权限检查
        if (orderDetails.ownerId !== userId) {
            throw new AuthorizationError('无权访问此订单', 'ORDER_ACCESS'); // 假设定义了一个AuthorizationError
        }

        // ... 订单处理逻辑
        return { status: 'success', message: `订单 ${orderId} 处理完成` };

    } catch (apiError) {
        // 如果是API调用失败，将其包装成我们自己的NetworkError
        if (apiError.response && apiError.response.status) {
            throw new NetworkError(`API请求失败：${apiError.message}`, apiError.response.status, `/api/orders/${orderId}`);
        }
        // 对于其他未知的API错误，可以重新抛出或包装成通用错误
        throw apiError;
    }
}

// Web应用中的路由处理示例 (使用Express.js风格)
app.post('/api/orders/:orderId/process', async (req, res) => {
    const { orderId } = req.params;
    const userId = req.user.id; // 假设从认证中间件获取

    try {
        const result = await processOrder(orderId, userId);
        res.status(200).json(result);
    } catch (error) {
        if (error instanceof ValidationError) {
            return res.status(400).json({ code: 'VALIDATION_FAILED', message: error.message, field: error.field });
        } else if (error instanceof NotFoundError) {
            return res.status(404).json({ code: 'NOT_FOUND', message: error.message });
        } else if (error instanceof AuthorizationError) {
            return res.status(403).json({ code: 'FORBIDDEN', message: error.message });
        } else if (error instanceof NetworkError) {
            console.error('外部服务调用失败：', error); // 内部记录日志
            return res.status(503).json({ code: 'SERVICE_UNAVAILABLE', message: '服务暂时不可用，请稍后再试。' });
        } else {
            // 捕获所有其他未预期的错误，通常是内部服务器错误
            console.error('未处理的服务器错误：', error.stack); // 打印堆栈信息便于调试
            return res.status(500).json({ code: 'INTERNAL_SERVER_ERROR', message: '服务器内部错误，请联系管理员。' });
        }
    }
});