JavaScript Promise与异步计算器方法实现教程

class Calculator {
    constructor() {
        this[Symbol.toStringTag] = 'Calculator';
    }

    add(a, b) {
        return a + b;
    }

    subtract(a, b) {
        return a - b;
    }

    multiply(a, b) {
        return a * b;
    }

    divide(a, b) {
        if (b === 0) {
            return NaN; // 除数为0返回NaN
        }
        return a / b;
    }

    toString() {
        return "Calculator";
    }

    // calculate 方法将在此处实现
}

    calculate(...args) { // 错误的参数处理
        var result = 0; // 结果未被回调函数更新
        return new Promise(function(resolve, reject){
            setTimeout(function() { // 不必要的延迟
                if(result === NaN) { // 错误的拒绝条件判断
                   reject(NaN);
                } else {
                   resolve(result);
                }
            }, 1000);
        });
    }

class Calculator {
    // ... 其他方法保持不变 ...

    async calculate(f) {
        try {
            // 确保 f 是一个函数，否则尝试调用会抛出 TypeError
            // 使用 f.call(this) 确保回调函数 f 的 this 上下文指向当前的 Calculator 实例
            return f.call(this); // 如果 f 成功执行并返回值，Promise将以该值解析
        } catch (error) {
            // 如果 f 不是函数，或者 f 在执行过程中抛出任何错误，
            // Promise 将被拒绝，并以 NaN 作为拒绝原因。
            throw NaN;
        }
    }
}

class Calculator {
    constructor() {
        this[Symbol.toStringTag] = 'Calculator';
    }

    add(a, b) {
        return a + b;
    }

    subtract(a, b) {
        return a - b;
    }

    multiply(a, b) {
        return a * b;
    }

    divide(a, b) {
        if (b === 0) {
            return NaN;
        }
        return a / b;
    }

    toString() {
        return "Calculator";
    }

    /**
     * 执行一个计算回调函数，并返回一个Promise。
     * 如果回调成功，Promise以其返回值解析；如果回调失败或参数无效，Promise以NaN拒绝。
     * @param {function} f - 要执行的计算回调函数。
     * @returns {Promise<number>} 一个Promise，解析为计算结果或拒绝为NaN。
     */
    async calculate(f) {
        try {
            // 确保回调函数 f 的 this 上下文指向当前的 Calculator 实例
            return f.call(this);
        } catch (error) {
            // 捕获所有错误（如 f 不是函数或 f 内部抛出错误），并以 NaN 拒绝 Promise
            throw NaN;
        }
    }
}

// 示例用法
const calculator = new Calculator();

// 成功案例
calculator.calculate(function() {
    let result = 0;
    result += this.add(1, 2); // this 指向 calculator
    result += this.add(3, 4);
    return result;
}).then(res => {
    console.log("计算成功:", res); // 输出: 计算成功: 10
}).catch(err => {
    console.error("计算失败:", err);
});

// 返回 NaN 的成功案例 (Promise 仍解析)
calculator.calculate(function() {
    return this.divide(1, 0); // divide 方法返回 NaN
}).then(res => {
    console.log("计算成功 (结果为NaN):", res); // 输出: 计算成功 (结果为NaN): NaN
}).catch(err => {
    console.error("计算失败:", err);
});

// 失败案例：未提供函数参数
calculator.calculate().catch(err => {
    console.error("计算失败 (参数无效):", err); // 输出: 计算失败 (参数无效): NaN
});

// 失败案例：回调函数内部抛出错误
calculator.calculate(function() {
    throw new Error("内部计算错误");
}).catch(err => {
    console.error("计算失败 (内部错误):", err); // 输出: 计算失败 (内部错误): NaN
});