*I have a simple calculator function that I wrote for a coding challenge.* *Now I'm having trouble with an additional calculate function that should return a 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;
}
return a / b;
}
toString(){
return "Calculator";
}
calculate(...args) {
var result = 0;
return new Promise(function(resolve, reject){
setTimeout(function() {
if(result === NaN) {
reject(NaN);
} else {
resolve(result);
}
}, 1000);
});
}
}
```

*And here are the tests that the promise needs to meet:*

```
describe( "Calculator.calculate", function(){
let calculator;
beforeEach( function(){
calculator = new Calculator();
} );
it( "returns a promise", function( done ){
const
callDone = () => done(),
calculating = calculator.calculate( () => void 0 );
expect( calculating ).to.be.instanceOf( Promise );
calculating.then( callDone ).catch( callDone );
} );
it( "resolves with the result when the calculation succeeds", function( done ){
const calculating = calculator.calculate( function(){
expect( this ).to.equal( calculator );
let result = 0;
result += this.add( 1, 2 );
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 ){
const calculating = calculator.calculate();
calculating.catch( function( result ){
expect( result ).to.be.NaN;
done();
} );
} );
} );
```

*The above calculate function I wrote only passes the first test and none of the other.*

0 ACCPTED 2023-06-07 21:08:46

*Some remarks on your attempt:*

*The requirements do not suggest that you need to**delay*a result using`setTimeout`

.*There is no need for*`...args`

as parameter list for`calculate`

.*It will only get one argument, and it should be a function.**The*`result`

variable is never set to anything else than 0. It would need to be the result by calling the callback function (the argument passed to`calculate`

).`resolve`

should be called with the result as argument.`reject`

should be called with`NaN`

as argument*There is no specification that when the result is*`NaN`

, the promise should be rejected.*The opposite is true: when the promise rejects (because of an error) it should reject with NaN as reason.**The last test in the test sequence, passes no argument to*`calculate`

, which would lead to an error while`calculate`

tries to execute an argument that is undefined.*And then it should return a rejected promise.*

*We can avoid calling the Promise constructor by declaring the method as async .*

```
async calculate(f) {
try {
return f.call(this);
} catch {
throw NaN;
}
}
```

The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.