Table of contents
Please support this book: buy it (PDF, EPUB, MOBI) or donate
(Ad, please don’t block.)


This chapter explains the proposal “Promise.prototype.finally” by Jordan Harband.

How does it work?

.finally() works as follows:

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

finally’s callback is always executed. Compare:

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:

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