[javascript] Promise에 대한 루프를 작성하는 올바른 방법.

promiseWhen()이 목적과 다른 목적을위한 일반적인 기능을 정말로 원한다면 Bergi의 단순화를 사용하여 꼭 그렇게하세요. 그러나 promise가 작동하는 방식으로 인해 이러한 방식으로 콜백을 전달하는 것은 일반적으로 불필요하며 복잡한 작은 후프를 뛰어 넘도록합니다.

내가 당신이 노력하고 있다고 말할 수있는 한 :

• 이메일 주소 모음에 대한 일련의 사용자 세부 정보를 비동기식으로 가져옵니다 (적어도 그게 합당한 유일한 시나리오입니다).
• .then()재귀를 통해 체인을 구축하면 됩니다.
• 반환 된 결과를 처리 할 때 원래 순서를 유지합니다.

따라서 정의 된 문제는 실제로 Promise Anti-patterns의 “The Collection Kerfuffle”에서 논의 된 문제이며 , 두 가지 간단한 솔루션을 제공합니다.

• 사용하는 병렬 비동기 호출 Array.prototype.map()
• 사용 시리얼 비동기 호출 Array.prototype.reduce().

병렬 접근 방식은 (직접적으로) 피하려는 문제를 제공합니다. 즉, 응답의 순서가 불확실합니다. 직렬 접근 방식은 .then()재귀없이 필요한 체인 을 구축합니다 .

function fetchUserDetails(arr) {
    return arr.reduce(function(promise, email) {
        return promise.then(function() {
            return db.getUser(email).done(function(res) {
                logger.log(res);
            });
        });
    }, Promise.resolve());
}

다음과 같이 전화하십시오.

//Compose here, by whatever means, an array of email addresses.
var arrayOfEmailAddys = [...];

fetchUserDetails(arrayOfEmailAddys).then(function() {
    console.log('all done');
});

보시다시피 추악한 외부 var count또는 관련 condition함수 가 필요하지 않습니다 . 제한 (문제에서 10 개)은 전적으로 배열의 길이에 의해 결정됩니다 arrayOfEmailAddys.

답변

// Given async function sayHi
function sayHi() {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log('Hi');
      resolve();
    }, 3000);
  });
}

// And an array of async functions to loop through
const asyncArray = [sayHi, sayHi, sayHi];

// We create the start of a promise chain
let chain = Promise.resolve();

// And append each function in the array to the promise chain
for (const func of asyncArray) {
  chain = chain.then(func);
}

// Output:
// Hi
// Hi (After 3 seconds)
// Hi (After 3 more seconds)

let asyncFn = (item) => {
  return new Promise((resolve, reject) => {
    setTimeout( () => {console.log(item); resolve(true)}, 1000 )
  })
}

// asyncFn('a')
// .then(()=>{return async('b')})
// .then(()=>{return async('c')})
// .then(()=>{return async('d')})

let a = ['a','b','c','d']

a.reduce((previous, current, index, array) => {
  return previous                                    // initiates the promise chain
  .then(()=>{return asyncFn(array[index])})      //adds .then() promise for each item
}, Promise.resolve())

async function myFunction() {
  while(/* my condition */) {
    const res = await db.getUser(email);
    logger.log(res);
  }
}

myFunction().then(() => {
  /* do other stuff */
})

var promiseWhile = Promise.method(function(condition, action) {
      if (!condition()) return;
    return action().then(promiseWhile.bind(null, condition, action));
});

var promiseWhile = Promise.method(function(condition, action, lastValue) {
  if (!condition()) return lastValue;
  return action().then(promiseWhile.bind(null, condition, action));
});

var count = 10;
util.promiseWhile(
  function condition() {
    return count > 0;
  },
  function action() {
    return new Promise(function(resolve, reject) {
      count = count - 1;
      resolve(count)
    })
  },
  count)

var request = []
while(count<10){
   request.push(db.getUser(email).then(function(res) { return res; }));
   count++
};

Promise.all(request).then((dataAll)=>{
  for (var i = 0; i < dataAll.length; i++) {

      logger.log(dataAll[i]);
  }
});