Promise.prototype.finally()
.finally()
is similar to finally {}
in synchronous codeThis chapter explains the proposal “Promise.prototype.finally
” by Jordan Harband.
.finally()
works as follows:
finally
’s callback is always executed. Compare:
then
’s callback is only executed if promise
is fulfilled.catch
’s callback is only executed if promise
is rejected. Or if then
’s callback throws an exception or returns a rejected Promise.In other words: Take the following piece of code.
This piece of code is equivalent to:
The most common use case is similar to the most common use case of the synchronous finally
clause: cleaning up after you are done with a resource. That should always happen, regardless of whether everything went smoothly or there was an error.
For example:
let connection;
db.open()
.then(conn => {
connection = conn;
return connection.select({ name: 'Jane' });
})
.then(result => {
// Process result
// Use `connection` to make more queries
})
···
.catch(error => {
// handle errors
})
.finally(() => {
connection.close();
});
.finally()
is similar to finally {}
in synchronous codeIn synchronous code, the try
statement has three parts: The try
clause, the catch
clause and the finally
clause.
In Promises:
try
clause very loosely corresponds to invoking a Promise-based function or calling .then()
.catch
clause corresponds to the .catch()
method of Promises.finally
clause corresponds to the new Promise method .finally()
introduced by the proposal.However, where finally {}
can return
and throw
, returning has no effect inside the callback .finally()
, only throwing. That’s because the method can’t distinguish between the callback returning explicitly and it finishing without doing so.
promise.prototype.finally
is a polyfill for .finally()
.--harmony-promise-finally
(details).