What is the explicit promise construction antipattern and how do I avoid it?

javascript

promise-engineering

async-await

callback-handling

byAlex Kataev·Mar 11, 2025

Here's the express checkout: avoid the explicit promise construction antipattern by not unnecessarily wrapping functions that already return a Promise within a new Promise.

// Risky road ahead 🚧
new Promise((resolve, reject) => {
  asyncFunction().then(resolve).catch(reject);
});
// This is like buying a dog, only to bark for it. Makes no sense, right?

Instead:

// Easy peasy, lemon squeezy! 🍋 
asyncFunction();
// Why bark yourself when you've got a perfectly good dog?

This eradicates unnecessary complexity and utilizes the Promises provided by JavaScript functions like fetch or async operations.

Core principles to dodge the bullet

Here's the lowdown on how to sidestep this antipattern. Strap in, it's gonna be a ride! 🎢

1. Embrace promise chaining

This isn't a charm bracelet, but chaining .then() and .catch() eliminates Christmas tree-like callbacks. Result? Code that's as streamlined as a supersonic jet. ✈️

2. Pass the promise, don't re-wrap it

If a function is already doling out a Promise, simply return it. It's akin to re-gifting unopened presents – less clutter, more joy. Think of it as the ultimate regifting strategy. 🎁

3. Deferred objects: Not your everyday tool

Deferreds are like those fancy silverware you save for special occasions. These ancient totems from Promise ancestors should strictly be used to retrofit non-promise APIs into Promised Land. Essentially, they're the tool you pull out only when fitting a square peg in a round hole. 🧩

4. Async/await for a promising future

Async/await can make your code as clean and easy to read as a picture book. Stick these in a try/catch wrapper and you got yourself error handling simplified. It's like having your cake and eating it too! 🎂

Delving deeper: Application and nuances

Aha! You want to dive deeper, do you? Let's pull back the curtains and explore some real-world applications and implications of these principles.

1. Working with third-party gadgets

Working with third-party libraries that don't hand you promises on a silver platter? Research the API's gift shop first. If it resembles a barren wasteland, engage the library maintainers or contribute to their treasure chest. 🏆

2. Assembling the puzzle: Composition over construction

When dealing with Promises, think of playing with LEGO, not Play-Doh. Assemble Promises like building blocks, rather than moulding each one from scratch. Ah, the joys of adult LEGO! 🧱

3. Report, discuss, and conquer

Can't find the LEGO pieces needed? Time to join forces with the authors or report the issue. Remember, great power comes with great responsibility. Collaborate for a more promising JavaScript landscape. 🌍

4. Conversions in the real world

Ever had to convert a callback API to Promises? Use off-the-shelf solutions like Bluebird or util.promisify to work smarter, not harder. Remember, no need to reinvent the wheel; someone might have already done it for you. 🎡

5. Maintain, don't remain

Maintenance brings longevity. Refactoring explicit promise constructions reduces code complexity, bug count, and increases caffeine effectiveness. Keep your Asynchronous City clean by removing unnecessary construction sites. 🌇

Advanced maneuvers with promises

Promises can be a double-edged sword, simple at the start, but tricky to handle in complex scenarios. Here, we explore some of these maneuvers to bring harmony to our asynchronous symphony. 🎼

1. Group promises with `Promise.all`

For running parallel promises and awaiting all to resolve, Promise.all is your peace treaty. Reduces war-time (execution time) and elevates the prosperity of your code kingdom. 👑

2. Sequential execution with promise chaining

Take the linear path when tasks need to run one after the other. Promise chaining lights up a single, clear path, saving you from the labyrinth of asynchronous tasks. 🪵

3. Unitary error handling

Unlike callbacks where error control is like herding cats, Promise chaining rounds up those feisty felines into a single pen. Fewer escape routes equals fewer headaches. 😸

explain-codes / Javascript / What is the explicit promise construction antipattern and how do I avoid it?

Linked

Resolve Javascript Promise outside the Promise constructor scope



How to check if an object is a Promise?



Use async await with Array.map



Do I need to return after early resolve/reject?



Resolve promises one after another (i.e. in sequence)?

