Black lives matter
Portrait Dr. Axel Rauschmayer
Dr. Axel Rauschmayer
Homepage | Twitter
Cover of book “JavaScript for impatient programmers”
Book, exercises, quizzes
(free to read online)
Cover of book “Deep JavaScript”
Book (50% free online)
Cover of book “Tackling TypeScript”
Book (first part free online)
Logo of newsletter “ news”
Newsletter (free)

ES2018: Promise.prototype.finally()

(Ad, please don’t block)

The proposal “Promise.prototype.finally” by Jordan Harband is at stage 4. This blog post explains it.

How does it work?  

.finally() works as follows:

.then(result => {···})
.catch(error => {···})
.finally(() => {···});

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.

.finally(() => {

This piece of code is equivalent to:

    result => {
        return result;
    error => {
        throw error;

Use case  

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;
.then(conn => {
    connection = conn;
    return{ name: 'Jane' });
.then(result => {
    // Process result
    // Use `connection` to make more queries
.catch(error => {
    // handle errors
.finally(() => {

.finally() is similar to finally {} in synchronous code  

In synchronous code, the try statement has three parts: The try clause, the catch clause and the finally clause.

In Promises:

  • The try clause very loosely corresponds to invoking a Promise-based function or calling .then().
  • The catch clause corresponds to the .catch() method of Promises.
  • The 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.


Further reading