Зворотний виклик після завершення асинхронних зворотних викликів для кожного

Як випливає з назви. Як це зробити?

Я хочу зателефонувати whenAllDone()після того, як цикл forEach пройшов кожен елемент і провів деяку асинхронну обробку.

[1, 2, 3].forEach(
  function(item, index, array, done) {
     asyncFunction(item, function itemDone() {
       console.log(item + " done");
       done();
     });
  }, function allDone() {
     console.log("All done");
     whenAllDone();
  }
);

Чи можна змусити його працювати так? Коли другим аргументом forEach є функція зворотного виклику, яка запускається, коли вона пройшла всі ітерації?

Очікуваний вихід:

3 done
1 done
2 done
All done!

Array.forEach не надає цієї приналежності (о, якби це було), але є кілька способів досягти того, що ви хочете:

Використання простого лічильника

function callback () { console.log('all done'); }

var itemsProcessed = 0;

[1, 2, 3].forEach((item, index, array) => {
  asyncFunction(item, () => {
    itemsProcessed++;
    if(itemsProcessed === array.length) {
      callback();
    }
  });
});

(завдяки @vanuan та ін.) Цей підхід гарантує, що всі елементи будуть оброблені, перш ніж викликати зворотний виклик "зроблено". Потрібно скористатися лічильником, який оновлюється при зворотному дзвінку. Залежно від значення показника параметр не дає однакової гарантії, оскільки не повертається порядок повернення асинхронних операцій.

Використання ES6 Обіцянь

(Бібліотеку обіцянок можна використовувати для старих браузерів):

1. Обробити всі запити, що гарантують синхронне виконання (наприклад, 1, потім 2, потім 3)

   function asyncFunction (item, cb) {
     setTimeout(() => {
       console.log('done with', item);
       cb();
     }, 100);
   }
   
   let requests = [1, 2, 3].reduce((promiseChain, item) => {
       return promiseChain.then(() => new Promise((resolve) => {
         asyncFunction(item, resolve);
       }));
   }, Promise.resolve());
   
   requests.then(() => console.log('done'))

2. Обробляти всі запити на асинхронізацію без "синхронного" виконання (2 може закінчитися швидше, ніж 1)

   let requests = [1,2,3].map((item) => {
       return new Promise((resolve) => {
         asyncFunction(item, resolve);
       });
   })
   
   Promise.all(requests).then(() => console.log('done'));

Використання бібліотеки асинхронізації

Є й інші асинхронні бібліотеки, асинхроніка є найпопулярнішою, яка забезпечує механізми для вираження того, що ви хочете.

Основну частину питання було відредаговано для видалення раніше синхронного коду прикладу, тому я оновив свою відповідь для уточнення. Оригінальний приклад використовував синхронний код типу для моделювання асинхронної поведінки, тому застосовується наступне:

array.forEachє синхронним і так є res.write, тому ви можете просто поставити зворотний дзвінок після дзвінка, щоб передбачити:

  posts.foreach(function(v, i) {
    res.write(v + ". index " + i);
  });

  res.end();

Якщо у вас виникли асинхронні функції, і ви хочете переконатися, що перед виконанням коду він закінчує свою задачу, ми завжди можемо використовувати можливість зворотного виклику.

Наприклад:

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

Примітка: functionAfterForEachце функція, яка повинна виконуватися після закінчення завдань foreach. asynchronous- це асинхронна функція, що виконується всередині foreach.

Сподіваюся, це вирішить вашу проблему, я зазвичай працюю з цим, коли мені потрібно виконати forEach з асинхронними завданнями всередині.

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
      } 
}

з

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

Як не дивно, скільки неправильних відповідей було дано на асинхронний випадок! Можна просто показати, що перевіряючий індекс не передбачає очікуваної поведінки:

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

вихід:

4000 started
2000 started
1: 2000
0: 4000

Якщо ми перевіримо index === array.length - 1 , зворотний виклик буде викликаний після завершення першої ітерації, тоді як перший елемент ще не очікується!

Щоб вирішити цю проблему без використання зовнішніх бібліотек, таких як async, я вважаю, що найкраще зберегти довжину списку та декремент, якщо після кожної ітерації. Оскільки є лише одна нитка, ми впевнені, що немає шансів на стан гонки.

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);
});

З ES2018 ви можете використовувати ітератори асинхронізації:

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');
}

Моє рішення без Обіцянки (це гарантує закінчення кожної дії до початку наступної):

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>

 var counter = 0;
 var listArray = [0, 1, 2, 3, 4];
 function callBack() {
     if (listArray.length === counter) {
         console.log('All Done')
     }
 };
 listArray.forEach(function(element){
     console.log(element);
     counter = counter + 1;
     callBack();
 });

Це рішення для Node.js, яке є асинхронним.

використовуючи пакет async npm.

(JavaScript) Синхронізація для кожного циклу з зворотними зворотами всередині

Моє рішення:

//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();
            }
        });
    }
});

Приклад:

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

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

// out: a b c done

Я намагаюся простим способом вирішити це питання, поділіться ним із вами:

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- Функція бібліотеки mssql в Node js. Це може замінити кожну функцію або Code u want. Щасти

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)
})

Вам не знадобиться зворотний виклик для повторення списку. Просто додайте end()виклик після циклу.

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

Просте рішення було б таким, як слідувати

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

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

Як щодо setInterval, щоб перевірити повну кількість ітерацій, приносить гарантію. не впевнений, якщо він не перевантажить область, хоча я використовую його і, здається, є одним

_.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);