Callback po zakończeniu wszystkich asynchronicznych połączeń zwrotnych forEach

Jeśli napotkasz funkcje asynchroniczne i chcesz się upewnić, że przed wykonaniem kodu zakończy swoje zadanie, zawsze możemy użyć funkcji callback.

Na przykład:

var ctr = 0;
posts.forEach(function(element, index, array){
    asynchronous(function(data){
         ctr++; 
         if (ctr === array.length) {
             functionAfterForEach();
         }
    })
});

Uwaga: functionAfterForEach jest funkcją wykonywaną po zakończeniu zadań foreach. asynchroniczna jest funkcją asynchroniczną wykonywaną wewnątrz foreach.

To dziwne, ile błędnych odpowiedzi zostało udzielonych asynchronicznej przypadku! Można po prostu pokazać, że sprawdzanie indeksu nie zapewnia oczekiwanego zachowania:

// INCORRECT
var list = [4000, 2000];
list.forEach(function(l, index) {
    console.log(l + ' started ...');
    setTimeout(function() {
        console.log(index + ': ' + l);
    }, l);
});

Wyjście:

4000 started
2000 started
1: 2000
0: 4000

Jeśli sprawdzimy index === array.length - 1, wywołanie callback zostanie wywołane po zakończeniu pierwszej iteracji, podczas gdy pierwszy element jest jeszcze w toku!

Aby rozwiązać ten problem bez korzystania z zewnętrznych bibliotek, takich jak async, myślę, że najlepiej jest zapisać długość listy i zmniejszyć, jeśli po każdym iteracja. Ponieważ jest tylko jeden wątek, jesteśmy pewni, że nie ma szans na stan rasy.

var list = [4000, 2000];
var counter = list.length;
list.forEach(function(l, index) {
    console.log(l + ' started ...');
    setTimeout(function() {
        console.log(index + ': ' + l);
        counter -= 1;
        if ( counter === 0)
            // call your callback here
    }, l);
});

Mam nadzieję, że to rozwiąże twój problem, zwykle pracuję z tym, gdy muszę wykonać forEach z asynchronicznymi zadaniami wewnątrz.

foo = [a,b,c,d];
waiting = foo.length;
foo.forEach(function(entry){
      doAsynchronousFunction(entry,finish) //call finish after each entry
}
function finish(){
      waiting--;
      if (waiting==0) {
          //do your Job intended to be done after forEach is completed
      } 
}

Z

function doAsynchronousFunction(entry,callback){
       //asynchronousjob with entry
       callback();
}

Moje rozwiązanie bez obietnicy (zapewnia to, że każda akcja kończy się przed rozpoczęciem następnej):

Array.prototype.forEachAsync = function (callback, end) {
        var self = this;
    
        function task(index) {
            var x = self[index];
            if (index >= self.length) {
                end()
            }
            else {
                callback(self[index], index, self, function () {
                    task(index + 1);
                });
            }
        }
    
        task(0);
    };
    
    
    var i = 0;
    var myArray = Array.apply(null, Array(10)).map(function(item) { return i++; });
    console.log(JSON.stringify(myArray));
    myArray.forEachAsync(function(item, index, arr, next){
      setTimeout(function(){
        $(".toto").append("<div>item index " + item + " done</div>");
        console.log("action " + item + " done");
        next();
      }, 300);
    }, function(){
        $(".toto").append("<div>ALL ACTIONS ARE DONE</div>");
        console.log("ALL ACTIONS ARE DONE");
    });

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div class="toto">

</div>

Z ES2018 możesz używać iteratorów asynchronicznych:

const asyncFunction = a => fetch(a);
const itemDone = a => console.log(a);

async function example() {
  const arrayOfFetchPromises = [1, 2, 3].map(asyncFunction);

  for await (const item of arrayOfFetchPromises) {
    itemDone(item);
  }

  console.log('All done');
}

Jest To rozwiązanie dla Node.js, który jest asynchroniczny.

Używanie pakietu async npm.

(JavaScript) Synchronizacja pętli forEach z wywołaniami zwrotnymi wewnątrz

Jak o setInterval, aby sprawdzić pełną liczbę iteracji, przynosi gwarancję. Nie wiem, czy nie przeciąży lunety, ale używam jej i wydaje się być tą

_.forEach(actual_JSON, function (key, value) {

     // run any action and push with each iteration 

     array.push(response.id)

});


setInterval(function(){

    if(array.length > 300) {

        callback()

    }

}, 100);

Moje rozwiązanie:

//Object forEachDone

Object.defineProperty(Array.prototype, "forEachDone", {
    enumerable: false,
    value: function(task, cb){
        var counter = 0;
        this.forEach(function(item, index, array){
            task(item, index, array);
            if(array.length === ++counter){
                if(cb) cb();
            }
        });
    }
});


//Array forEachDone

Object.defineProperty(Object.prototype, "forEachDone", {
    enumerable: false,
    value: function(task, cb){
        var obj = this;
        var counter = 0;
        Object.keys(obj).forEach(function(key, index, array){
            task(obj[key], key, obj);
            if(array.length === ++counter){
                if(cb) cb();
            }
        });
    }
});

Przykład:

var arr = ['a', 'b', 'c'];

arr.forEachDone(function(item){
    console.log(item);
}, function(){
   console.log('done');
});

// out: a b c done

Staram się łatwo to rozwiązać, podzielić się z Tobą:

let counter = 0;
            arr.forEach(async (item, index) => {
                await request.query(item, (err, recordset) => {
                    if (err) console.log(err);

                    //do Somthings

                    counter++;
                    if(counter == tableCmd.length){
                        sql.close();
                        callback();
                    }
                });

request jest funkcją biblioteki mssql w Node js. Może to zastąpić każdą funkcję lub kod, który chcesz. GoodLuck

var i=0;
const waitFor = (ms) => 
{ 
  new Promise((r) => 
  {
   setTimeout(function () {
   console.log('timeout completed: ',ms,' : ',i); 
     i++;
     if(i==data.length){
      console.log('Done')  
    }
  }, ms); 
 })
}
var data=[1000, 200, 500];
data.forEach((num) => {
  waitFor(num)
})

Proste rozwiązanie byłoby jak follow

function callback(){console.log("i am done");}

["a", "b", "c"].forEach(function(item, index, array){
    //code here
    if(i == array.length -1)
    callback()
}

Nie powinieneś potrzebować połączenia zwrotnego do iteracji listy. Wystarczy dodać wywołanie end() po pętli.

posts.forEach(function(v, i){
   res.write(v + ". Index " + i);
});
res.end();