Filtern von einem array mit einer Funktion, die eine Zusage zurückgibt

Gegeben

let arr = [1,2,3];

function filter(num) {
  return new Promise((res, rej) => {
    setTimeout(() => {
      if( num === 3 ) {
        res(num);
      } else {
        rej();
      }
    }, 1);
  });
 }

 function filterNums() {
   return Promise.all(arr.filter(filter));
 }

 filterNums().then(results => {
   let l = results.length;
   //length should be 1, but is 3
 });

Die Länge ist 3, weil die Versprechungen sind zurückgekehrt, nicht um Werte. Gibt es eine Möglichkeit, filter-array mit einer Funktion, die eine Zusage zurückgibt?

Hinweis: Für dieses Beispiel, fs.stat wurde ersetzt mit setTimeout finden Sie https://github.com/silenceisgolden/learn-esnext/blob/array-filter-async-function/tutorials/array-filter-with-async-function.js für den spezifischen code.

InformationsquelleAutor der Frage ajklein | 2015-10-26

Wie bereits erwähnt in den Kommentaren, Array.prototype.filter ist synchron und unterstützt daher keine Versprechungen.

Da kann man jetzt (theoretisch) Unterklasse built-in-Typen mit ES6, Sie sollten in der Lage sein, um Ihre eigenen asynchrone Methode, welche umschließt die vorhandenen filter-Funktion:

Hinweis: ich habe auskommentiert, die Unterklassen, da es nicht unterstützt wird von Babel nur noch für Arrays

class AsyncArray /*extends Array*/ {
  constructor(arr) {
    this.data = arr; //In place of Array subclassing
  }

  filterAsync(predicate) {
     //Take a copy of the array, it might mutate by the time we've finished
    const data = Array.from(this.data);
    //Transform all the elements into an array of promises using the predicate
    //as the promise
    return Promise.all(data.map((element, index) => predicate(element, index, data)))
    //Use the result of the promises to call the underlying sync filter function
      .then(result => {
        return data.filter((element, index) => {
          return result[index];
        });
      });
  }
}
//Create an instance of your subclass instead
let arr = new AsyncArray([1,2,3,4,5]);
//Pass in your own predicate
arr.filterAsync(async (element) => {
  return new Promise(res => {
    setTimeout(() => {
      res(element > 3);
    }, 1);
  });
}).then(result => {
  console.log(result)
});

Babel REPL Demo

InformationsquelleAutor der Antwort CodingIntrigue

Versprechen Reducer, um die Rettung!

[1, 2, 3, 4].reduce((op, n) => {
    return op.then(filteredNs => {
        return new Promise(resolve => {
            setTimeout(() => {
                if (n >= 3) {
                    console.log("Keeping", n);
                    resolve(filteredNs.concat(n))
                } else {
                    console.log("Dropping", n);
                    resolve(filteredNs);
                }
            }, 1000);
        });
    });
}, Promise.resolve([]))
.then(filteredNs => console.log(filteredNs));

Reduzierstücke sind genial. "Reduzieren, mein problem ist mein Ziel" scheint eine ziemlich gute Strategie, für alles, was komplexer als das, was die einfachen Werkzeuge werden für Sie zu lösen, d.h. die Filterung eines array von Dinge, die sind nicht alle sofort verfügbar.

InformationsquelleAutor der Antwort Dan Ross

1

Spät, um das Spiel, aber da sonst niemand Sie erwähnt, Bluebird unterstützt Versprechen.Karte, die ist mein go-to für Filter erfordern aysnc Verarbeitung für den Zustand,
```
function filterAsync(arr) {
    return Promise.map(arr, num => {
        if (num === 3) return num;
    })
        .filter(num => num !== undefined)
}
```
InformationsquelleAutor der Antwort Spencer MacBeth

Einen gültigen Weg, dies zu tun (aber es scheint zu unordentlich):

let arr = [1,2,3];

function filter(num) {
  return new Promise((res, rej) => {
    setTimeout(() => {
      if( num === 3 ) {
        res(num);
      } else {
        rej();
      }
    }, 1);
  });
}

async function check(num) {
  try {
    await filter(num);
    return true;
  } catch(err) {
    return false;
  }
}

(async function() {
  for( let num of arr ) {
    let res = await check(num);
    if(!res) {
      let index = arr.indexOf(num);
      arr.splice(index, 1);
    }
  }
})();

Wieder, scheint Weg zu chaotisch.

InformationsquelleAutor der Antwort ajklein

Variante von @DanRoss:

async function filterNums(arr) {
  return await arr.reduce(async (res, val) => {
    res = await res
    if (await filter(val)) {
      res.push(val)
    }
    return res
  }, Promise.resolve([]))
}

Beachten Sie, dass, wenn (wie im aktuellen Fall), müssen Sie nicht sorgen zu machen über die filter() having
Nebenwirkungen, die serialisiert werden müssen, können Sie auch tun:

async function filterNums(arr) {
  return await arr.reduce(async (res, val) => {
    if (await filter(val)) {
      (await res).push(val)
    }
    return res
  }, Promise.resolve([]))
}

InformationsquelleAutor der Antwort shaunc

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.