In JS, let's say I call a promise in a 'fire and forget' way. I don't care if it was successful or not, and I don't care what it returns as I want to return the same value anyways.
I can call
return myPromise().then(() => foo).catch(() => foo);
Is there a way to not repeat then then and catch parts?
I thought about using finally, thinking that it will take what finally returns (similar to what Java does by taking the return value of the finally block) :
return myPromise().finally(() => foo);
But it turns out it didn't do what I expected. According to mdn, this return value will be used to reject in case the original promise rejected.
You can declare your result returning function once and then re-use it twice for the .then() and .catch() handlers
const myReturn = () => foo;
return myPromise()
.then(myReturn)
.catch(myReturn);
You can further shorten this by using both parameters of .then() which handle both the success and failure path:
const myReturn = () => foo;
return myPromise()
.then(myReturn, myReturn);
If you find needing this a lot, you might make a small library function that takes a value and returns two functions that both just evaluate to it:
const doubleThunk = val =>
[() => val, () => val];
Which would be used like this:
return myPromise()
.then(...doubleThunk(foo));
You could have a look at Promise.allSettled if you're targeting newer browsers or Node.js versions.
This function will return a Promise that resolves whether or not the passed Promise resolves or rejects.
function foo(results) {
console.log('foo():', ...results)
}
// Success path
Promise.allSettled([Promise.resolve('Yay')]).then(foo)
// Failure path
Promise.allSettled([Promise.reject('Doh')]).then(foo).as-console-wrapper { max-height: 100% !important; }