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; // 除数为零返回NaN
        }
        return a / b;
    }
    toString() {
        return "Calculator";
    }
    // calculate方法待实现
    calculate(f) {
        // ...
    }
}

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。
     * @param {Function} f - 要执行的计算函数。
     * @returns {Promise<number>} 一个Promise，解析为计算结果，或拒绝为NaN。
     */
    async calculate(f) {
        try {
            // 确保f是一个函数，并使用call方法绑定this上下文到当前Calculator实例
            // 如果f不是函数，或者f.call(this)执行时抛出错误，都会被catch捕获
            return f.call(this);
        } catch (error) {
            // 捕获任何在f.call(this)执行过程中发生的错误
            // 根据需求，无论何种错误，都以NaN拒绝Promise
            throw NaN;
        }
    }
}

// 假设这是测试框架（如Mocha/Chai）的一部分
// describe("Calculator.calculate", function() {
//   let calculator;

//   beforeEach(function() {
//     calculator = new Calculator();
//   });

//   it("returns a promise", function(done) {
//     const calculating = calculator.calculate(() => void 0);
//     expect(calculating).to.be.instanceOf(Promise);
//     calculating.then(done).catch(done); // 确保Promise被处理
//   });

//   it("resolves with the result when the calculation succeeds", function(done) {
//     const calculating = calculator.calculate(function() {
//       expect(this).to.equal(calculator); // 验证this上下文
//       let result = 0;
//       result += this.add(1, 2); // 使用this调用Calculator方法
//       result += this.add(3, 4);
//       return result;
//     });
//     calculating
//       .then(function(result) {
//         expect(result).to.equal(10);
//         done();
//       })
//       .catch(() => done());
//   });

//   it("rejects with NaN when the calculation fails", function(done) {
//     // 传入非函数参数，或不传参数，导致f.call(this)抛出错误
//     const calculating = calculator.calculate(); // 这里f会是undefined
//     calculating.catch(function(result) {
//       expect(result).to.be.NaN;
//       done();
//     });
//   });
// });

// 实际运行示例
const calculator = new Calculator();

// 成功案例
calculator.calculate(function() {
    console.log("成功案例 - this:", this === calculator); // true
    let result = 0;
    result += this.add(1, 2); // 3
    result += this.subtract(10, 5); // 5
    return result; // 8
}).then(res => console.log("成功解析:", res)) // 成功解析: 8
  .catch(err => console.error("成功案例不应拒绝:", err));

// 失败案例 - 未传入函数
calculator.calculate()
    .then(res => console.log("失败案例不应解析:", res))
    .catch(err => console.error("失败解析:", err)); // 失败解析: NaN

// 失败案例 - 传入非函数
calculator.calculate("not a function")
    .then(res => console.log("失败案例不应解析:", res))
    .catch(err => console.error("失败解析:", err)); // 失败解析: NaN

// 失败案例 - 函数内部抛出错误
calculator.calculate(function() {
    throw new Error("内部计算错误");
}).then(res => console.log("内部错误不应解析:", res))
  .catch(err => console.error("内部错误解析:", err)); // 内部错误解析: NaN