Блог

У меня есть цикл, который вызывает метод, который делает что-то асинхронно. Этот цикл может вызывать метод много раз. После этого цикла у меня есть еще один цикл, который нужно выполнить только тогда, когда все асинхронные действия будут выполнены.

Итак, это иллюстрирует то, чего я хочу:

 for (i = 0; i < 5; i  ) {
    doSomeAsyncStuff();    
}

for (i = 0; i < 5; i  ) {
    doSomeStuffOnlyWhenTheAsyncStuffIsFinish();    
}
 

Я не очень хорошо знаком с обещаниями, так что может ли кто-нибудь помочь мне в этом?

Вот как я doSomeAsyncStuff() себя веду:

 function doSomeAsyncStuff() {
    var editor = generateCKEditor();
    editor.on('instanceReady', function(evt) {
        doSomeStuff();
        // There should be the resolve() of the promises I think.
    })
}
 

Может быть, мне придется сделать что-то вроде этого:

 function doSomeAsyncStuff() {
    var editor = generateCKEditor();
    return new Promise(function(resolve,refuse) {
        editor.on('instanceReady', function(evt) {
            doSomeStuff();
            resolve(true);
        });
    });
}
 

Но я не уверен в синтаксисе.

Для этого вы можете использовать Promise.all (spec, MDN): он принимает кучу отдельных обещаний и возвращает вам одно обещание, которое будет выполнено, когда все те, которые вы ему дали, будут выполнены, или отклонено, когда какое-либо из них будет отклонено.

Так что, если вы doSomeAsyncStuff дадите обещание вернуть, то:

     const promises = [];
//  ^^^^^−−−−−−−−−−−−−−−−−−−−−−−−−−− use `const` or `let`, not `var`
    
    for (let i = 0; i < 5; i  ) {
//       ^^^−−−−−−−−−−−−−−−−−−−−−−−− added missing declaration
        promises.push(doSomeAsyncStuff());
    }
    
    Promise.all(promises)
        .then(() => {
            for (let i = 0; i < 5; i  ) {
//               ^^^−−−−−−−−−−−−−−−− added missing declaration
                doSomeStuffOnlyWhenTheAsyncStuffIsFinish();    
            }
        })
        .catch((e) => {
            // handle errors here
        });
 

У MDN есть статья об обещаниях здесь. Я также подробно освещаю выпускные вечера в главе 8 моей книги JavaScript: Новые игрушки, ссылки в моем профиле, если вам интересно.

Вот пример:

  function doSomethingAsync(value) {
     return new Promise((resolve) => {
         setTimeout(() => {
             console.log("Resolving "   value);
             resolve(value);
         }, Math.floor(Math.random() * 1000));
     });
   }
   
   function test() {
       const promises = [];
       
       for (let i = 0; i < 5;   i) {
           promises.push(doSomethingAsync(i));
       }
       
       Promise.all(promises)
           .then((results) => {
               console.log("All done", results);
           })
           .catch((e) => {
               // Handle errors here
           });
   }
   
   test(); 

Пример вывода (из Math.random -за того , что заканчивается первым, может отличаться):

Решение 3
Решение 2
Решение 1
Решение 4
Разрешение 0
Все сделано [0,1,2,3,4]

Многоразовая функция хорошо работает для этого шаблона:

 function awaitAll(count, asyncFn) {
  const promises = [];

  for (i = 0; i < count;   i) {
    promises.push(asyncFn());
  }

  return Promise.all(promises);
}
 

Пример OP:

 awaitAll(5, doSomeAsyncStuff)
  .then(results => console.log('doSomeStuffOnlyWhenTheAsyncStuffIsFinished', results))
  .catch(e => console.error(e));
 

Связанный шаблон-это итерация по массиву и выполнение асинхронной операции над каждым элементом:

 function awaitAll(list, asyncFn) {
  const promises = [];

  list.forEach(x => {
    promises.push(asyncFn(x));
  });

  return Promise.all(promises);
}
 

Пример:

 const books = [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }];

function doSomeAsyncStuffWith(book) {
  return Promise.resolve(book.name);
}

awaitAll(books, doSomeAsyncStuffWith)
  .then(results => console.log('doSomeStuffOnlyWhenTheAsyncStuffIsFinished', results))
  .catch(e => console.error(e));
 

 const doSomeAsyncStuff = async (funcs) => {
  const allPromises = funcs.map(func => func());
  return await Promise.all(allPromises);
}

doSomeAsyncStuff([
  () => new Promise(resolve => setTimeout(() => resolve(), 100)),
  () => new Promise(resolve => setTimeout(() => resolve(), 100)),
  () => new Promise(resolve => setTimeout(() => resolve(), 100)),
  () => new Promise(resolve => setTimeout(() => resolve(), 100)),
  () => new Promise(resolve => setTimeout(() => resolve(), 100)),
]);
 

Вот код, который я написал для себя, чтобы понять ответы, изложенные здесь. У меня есть запросы мангуста в цикле for, поэтому я поместил здесь asyncFunction , чтобы занять его место. Надеюсь, это кому-нибудь поможет. Вы можете запустить этот скрипт в узле или в любой из многих сред выполнения Javascript.

 let asyncFunction = function(value, callback)
{
        setTimeout(function(){console.log(value); callback();}, 1000);
}



// a sample function run without promises

asyncFunction(10,
    function()
    {
        console.log("I'm back 10");
    }
);


//here we use promises

let promisesArray = [];

let p = new Promise(function(resolve)
{
    asyncFunction(20,
        function()
        {
            console.log("I'm back 20");
            resolve(20);
        }
    );
});

promisesArray.push(p);


for(let i = 30; i < 80; i  = 10)
{
    let p = new Promise(function(resolve)
    {
        asyncFunction(i,
            function()
            {
                console.log("I'm back "   i);
                resolve(i);
            }
        );
    });
    promisesArray.push(p);
}


// We use Promise.all to execute code after all promises are done.

Promise.all(promisesArray).then(
    function()
    {
        console.log("all promises resolved!");
    }
)
 

Вот элегантное решение для вас, если вы хотите сделать одно и то же несколько раз:

 await Promise.all(new Array(10).fill(0).map(() => asyncFn()));
 

это создает массив из 10 элементов, заполняет его нулями, а затем сопоставляет его с массивом обещаний