My `Promise.first` solution for the exercise of the Chapter Promise, Async and Performance, YDNJS

akidox · May 31, 2020, 6:37am

The exercise is from this section of that Chapter:

getify/You-Dont-Know-JS/blob/1st-ed/async & performance/ch3.md#variations-on-all---and-race--

# You Don't Know JS: Async & Performance
# Chapter 3: Promises

In Chapter 2, we identified two major categories of deficiencies with using callbacks to express program asynchrony and manage concurrency: lack of sequentiality and lack of trustability. Now that we understand the problems more intimately, it's time we turn our attention to patterns that can address them.

The issue we want to address first is the *inversion of control*, the trust that is so fragilely held and so easily lost.

Recall that we wrap up the *continuation* of our program in a callback function, and hand that callback over to another party (potentially even external code) and just cross our fingers that it will do the right thing with the invocation of the callback.

We do this because we want to say, "here's what happens *later*, after the current step finishes."

But what if we could uninvert that *inversion of control*? What if instead of handing the continuation of our program to another party, we could expect it to return us a capability to know when its task finishes, and then our code could decide what to do next?

This paradigm is called **Promises**.

Promises are starting to take the JS world by storm, as developers and specification writers alike desperately seek to untangle the insanity of callback hell in their code/design. In fact, most new async APIs being added to JS/DOM platform are being built on Promises. So it's probably a good idea to dig in and learn them, don't you think!?

**Note:** The word "immediately" will be used frequently in this chapter, generally to refer to some Promise resolution action. However, in essentially all cases, "immediately" means in terms of the Job queue behavior (see Chapter 1), not in the strictly synchronous *now* sense.

## What Is a Promise?

This file has been truncated. show original

Solution code:

if (!Promise.first) {
  Promise.first = function(prs) {
    var errArr = []; // store the reject reasons
    return new Promise( function(resolve,reject){
      prs.forEach( function(pr){
        Promise.resolve( pr )
        .then(
          resolve,
          function(err) {
            errArr.push(err);
            if(errArr.length == prs.length) {
              reject(errArr);  // if all promises rejected, reject the returned promise
            }
          });
      });
    });
  };
}

Below is how its used:

// say foo(), foo1(), foo2() are three promises that are rejected
Promise.first([foo(), foo1(), foo2()])
.catch(function(err){
  console.log(err);
});