Comment faire pour que cette boucle async foreach fonctionne avec des promesses?

J'ai déjà foiré autour avec des Promesses, mais je suis nouveau et je ne peux pas comprendre comment le faire correctement. Pour le moment, il n'y a pas de point de la Promesse, parce qu'il n'attendez pas la async $.get complète.

Fondamentalement, chaque foreach itération dispose de son propre $.get fonction, et j'ai besoin de les avoir tous et passez à la partie qui a "...se albumart" console.log.

$.get(id,function(data) {
    //(there's some code here)
    var getZippyUrls = new Promise(function(resolve) {
            zippyarray.forEach(function(zippy) {
            //(more code)
            $.get(zippy.full, function(data) {
                //^This is the foreach of $.gets
               //(code's here)
            });  
           resolve(zippyarray);
        });
    });

    //This is my failed Promise ->
    getZippyUrls.then(function(response) {
        console.log("WE'RE OUT " + response.length);
        response.foreach(function(d) {
            console.log("Promise"+d.media);
        });
        console.log('eyyyyyy');
    });

    console.log("...gets albumart");
    //Now after the previous stuff is done, move on

source d'informationauteur Fabis

  1. 20

    Dans le code synchrone, la poursuite est effectuée lorsque la ligne se termine ;

    Avec des promesses, la poursuite est effectuée par l'intermédiaire .then. Vous étiez à l'aide d'une promesse constructeur et résolu immédiatement, vous n'avez pas attendre pour n'importe quelle tâche à tous. J'avais la carte de mon travail en tâches, et ensuite, soit de la chaîne d'eux avec le ou les attendent en série.

    //I'm assuming
zippyarray; //array of Zippy objects

var tasks = zippyarray.map(function(zippy,i){
    return function(){ //return a task on that zippy;
       //basic logic here
       return $.get({
            //ajax request
       }).then(function(data){
            //process data like in your code
            //possibly store later for later use too
            return process(data); //return the processed data;
       });
    }
});

    Maintenant, nous pouvons exécuter tous de manière séquentielle:

     var p = tasks[0](); //start the first one
 for(var i = 1; i < tasks.length; i++) p = p.then(tasks[i]);
 p.then(function(result){
       //all available here
 });

    Ou mieux, en série:

    $.when.apply(tasks.forEach(function(t){ return t(); })).then(function(results){
     //all done
})
  2. 10

    Je sais que c'est une vieille question, mais les choses ont un peu changé récemment.

    Si vous êtes bien avec l'utilisation de bibliothèques externes, la Bluebird promesse de la bibliothèque a une assez bonne mise en œuvre de ce: Promesse.chaque.

    E. g.

    function helperFunc(zippyarray) {
  return Promise.each(zippyarray, zippy => {
    return someOperationThatReturnAPromise(zippy)
      .then((singleResult) => {
        //do something with the operation result if needed
      })
  }).then((originalArray) => {
    //this happens only after the whole array is processed
    //(result is the original array here)
    return Promise.resolve(originalArray)
  })
}
  3. 0

    À garder la trace de plusieurs get-Demandes vous êtes à l'aide de cette façon:

    var cnt = requestCnt;

function finished(){
    if(--cnt)return;
    //Your code here
}

for(var i = 0; i < requestCnt; ++i){
    $.get('something.htm', {data:data}, function(data){
        finished();
    });
}

    Vous appelez toujours le fini-fonction lorsqu'une demande obtient une réponse. Le fini-fonction fait le travail quand tout est fait.

  4. 0

    Aujourd'hui, si je devais le faire de façon séquentielle - je le ferais avec async/await:

    //I'm assuming I'm inside an `async` function
zippyarray; //array of Zippy objects

for(const task of zippyArray) {
  const result = await $.get({ ... });
  //do stuff with result
}