5 Awesome JavaScript Promise Tricks

By  on  

The Promise API changed the game in JavaScript. We went from abusing setTimeouts and settling for synchronous operations to doing everything possible to leverage this new async API. Let's check out a handful of awesome Promise API tricks!

Cancel a fetch Request

One problem we instantly complained about with promises was not being able to cancel them. A simple promiseInstance.cancel() would have been excellent but never came. Instead we were given an API that was way more complicated:

const controller = new AbortController();
const { signal } = controller;

fetch("http://localhost:8000", { signal }).then(response => {
    console.log(`Request 1 is complete!`);
}).catch(e => {
    console.warn(`Fetch 1 error: ${e.message}`);
});

// Abort request
controller.abort();

The magic here is providing the signal with each fetch request. In the JavaScript world, we inherit difficult APIs and do wonders to abstract them, and thus we'll find a way to better abstract this API.

waitForTime & waitForever

Waiting for a duration is useful in loads of production and testing situations -- it's never ideal but always helpful. I've used two awesome functions to make my life btter:

/* Wait for milliseconds */
function waitForTime(ms) {
  return new Promise(r => setTimeout(r, ms));
}

/* Usage */
await waitForTime(200);

/* Wait Forever */
function waitForever() {
  return new Promise(r => {});
}

// Usage:
await waitForever();

Don't wait for perfect situations, wait for the time you need.

Async Array Functions

Array functions like forEach, map, and other functions are used frequently without the need for them to be synchronous. We don't think about it there's a fair amount of times we can go async with our operations.

const promises = [1, 2, 3].map(async (num) => {
  console.log(num);
});

await promises;

The difference in caring between async and sync is Promise.allSettled. Go async when you can!

then on Objects

Did you know that you can arbitrarily add a then method on objects to have them treated as a Promise?

j = { then: resolve => fetch("/").then(resolve) }

j.then(res => console.log(res));
// Response {type: "basic", url: "https://davidwalsh.name/", redirected: false, status: 200, ok: true, …}

// ... or an await...
const response = await j;
// Response {type: "basic", url: "https://davidwalsh.name/", redirected: false, status: 200, ok: true, …}

Now you know! An excellent trick most don't know about!

Detect an Async Function

Not something you would need to do often but this post is about tricks, right? If you want to detect an asynchronous function, you always can:

async function myFunction() {

}

const isAsync = myFunction.constructor.name === "AsyncFunction";

JavaScript Promises are something we every day but a broader look at them allows us to innovate! Have any Promise tricks of your own? Please share!

Recent Features

  • By
    5 HTML5 APIs You Didn’t Know Existed

    When you say or read "HTML5", you half expect exotic dancers and unicorns to walk into the room to the tune of "I'm Sexy and I Know It."  Can you blame us though?  We watched the fundamental APIs stagnate for so long that a basic feature...

  • By
    7 Essential JavaScript Functions

    I remember the early days of JavaScript where you needed a simple function for just about everything because the browser vendors implemented features differently, and not just edge features, basic features, like addEventListener and attachEvent.  Times have changed but there are still a few functions each developer should...

Incredible Demos

  • By
    Drag & Drop Elements to the Trash with MooTools 1.2

    Everyone loves dragging garbage files from their desktop into their trash can. There's a certain amount of irony in doing something on your computer that you also do in real life. It's also a quick way to get rid of things. That's...

  • By
    Web Audio API

    The Web Audio API allows developers to load and decode audio on demand using JavaScript.  The more I evaluate awesome games for Firefox OS TVs, the more I get to learn about these APIs that I normally wouldn't touch.  The following is a very basic introduction to the WebAudio API...

Discussion

  1. I love waitForever()! I have coded and used waitForTime for quite some time now (most often with Sindre Sorhus’ delay package on npm) but it never occurred to me to make waitForever!. Definitely useful for testing.

  2. nico

    If you plan to call a function that might be async anyway you could also just test the result for a then method. Because your async function might not be a true modern async function, but maybe just return a promise.

    The waitForTime() is one of my standard async function, but I normally call it sleep(). Another one that helps throtteling or waiting for a settled DOM is: await nextFrame(), as in:

    function nextFrame () {
      return new Promise(resolve => requestAnimationFrame(r));
    }
    
  3. I’m either confused about the “Async Array Functions” section, or maybe there is an error?

    const promises = [1, 2, 3].map(async (num) => {/* ... */});
    // promises is an Array
    await promises; // does not await the promises *inside the array
    
    • Yes, I’m under the same impression.

      await [promiseA, promiseB]

      is not the same as

      await Promise.all([promiseA, promiseB])

      — or is it?

Wrap your code in <pre class="{language}"></pre> tags, link to a GitHub gist, JSFiddle fiddle, or CodePen pen to embed!