然后捕获和然后捕获承诺之间的差异

Question

What is the difference between these two? Is one faster than the other? Both seem to work. Someone please explain

One with no promise:

client.query(query1)

.then(data => {
   callback(null, {
       statusCode: 200,
       body: JSON.stringify(data)
   });                    
.catch(err => {
   callback(null, {
       statusCode: 500,
       body: JSON.stringify(err)
   }); 
});

Other with a promise:

return new Promise((resolve, reject) => {

 client.query(query2)

    .then(data => {
      resolve({statusCode:200, body: JSON.stringify(data)}); 
    })
    .catch(err => {
       reject(err);
    });

});

Answer 1

Lets start with what these 2 code snippets have in common. They both invoke some client.query() function which we know nothing about, however we can guess it returns a Promise instance. I will assume this for the rest of the answer.

What is the difference between these two?

The difference between the two is how they return the result from an asynchronous operation. While the first one uses a callback, the latter uses a Promise , which is more than just a callback. It provides state (pending / fulfilled / rejected) and supports chaining . You could, of course, chain callbacks too, but it will inevitably end up in callback hell . In the second snippet you could have returned the original promise, but in my opinion wrapping it in your own promise is probably a good thing, because you're abstracting away the results returned the original promise.

Is one faster than the other?

I wouldn't worry about this matter. In asynchronous programming it's usually waiting for the result of aynchronous operation that takes the most time. The mechanism how you report the result of such operation to caller is irrelevant from performance point of view. What however matters in asynchronous programming is code readability and maintainability, which might not be optimal even if you use promises. And that leads us to async functions introduced in ES2017.

I'm not encouraging you to use async function straight away. Just be aware of it, study it and use when appropriate.

Answer 2

the short answer is then always returns a Promise . when any promise is rejected within the chain it will execute the first catch. (throwing an error within then will return a rejected promise).

then will return a promise of the returned value if it's not a promise and return a rejected promise if an error was thrown.

so the first one is also returning a Promise of undefined , and there's no difference in performance,

const p1 = Promise.resolve('this will resolve');

p1.then((x) => Promise.resolve('You know: ' + x)).then(str => console.log(str));
p1.then((x) => Promise.reject('this will not resolve')).then(x => console.log('this will never execute')).catch(e => console.log('told you : ' + e));

p1.then((x) => 'You know: ' + x).then(str => console.log(str));
p1.then((x) => { throw 'this will not resolve' }).then(x => console.log('this will never execute')).catch(e => console.log('told you : ' + e));

Both of these methods do the same thing within then.