javascript - 설명 - promise all 순서




forEach 루프와 함께 async/await 사용 (10)

forEach 루프에서 async / await 사용에 문제가 있습니까? 파일 배열을 반복하고 각 파일의 내용을 await .

import fs from 'fs-promise'

async function printFiles () {
  const files = await getFilePaths() // Assume this works fine

  files.forEach(async (file) => {
    const contents = await fs.readFile(file, 'utf8')
    console.log(contents)
  })
}

printFiles()

이 코드는 작동하지만 이것으로 뭔가 잘못 될 수 있습니까? 나는 누군가 당신이 이것과 같은 고차 함수에서 async / await 를 사용해서는 안된다고 말하게 했으므로 이것에 문제가 있는지 묻고 싶었습니다.


Antonio Val의 p-iteration 과 유사하게 대체 npm 모듈은 async-af .

const AsyncAF = require('async-af');
const fs = require('fs-promise');

function printFiles() {
  // since AsyncAF accepts promises or non-promises, there's no need to await here
  const files = getFilePaths();

  AsyncAF(files).forEach(async file => {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  });
}

printFiles();

또는 async-af 에는 약속 결과를 기록하는 정적 메소드 (log / logAF)가 있습니다.

const AsyncAF = require('async-af');
const fs = require('fs-promise');

function printFiles() {
  const files = getFilePaths();

  AsyncAF(files).forEach(file => {
    AsyncAF.log(fs.readFile(file, 'utf8'));
  });
}

printFiles();

그러나 라이브러리의 주요 장점은 비동기 메소드를 연결하여 다음과 같은 작업을 수행 할 수 있다는 것입니다.

const aaf = require('async-af');
const fs = require('fs-promise');

const printFiles = () => aaf(getFilePaths())
  .map(file => fs.readFile(file, 'utf8'))
  .forEach(file => aaf.log(file));

printFiles();

async-af


ES2018을 사용하면 다음에 대한 위의 모든 답변을 크게 단순화 할 수 있습니다.

async function printFiles () {
  const files = await getFilePaths()

  for await (const file of fs.readFile(file, 'utf8')) {
    console.log(contents)
  }
}

사양 참조 : https://github.com/tc39/proposal-async-iteration

2018-09-10 :이 답변은 최근 많은 주목을 받고 있습니다. 비동기 반복에 대한 자세한 내용은 Axel Rauschmayer의 블로그 게시물을 참조하십시오 : http://2ality.com/2016/10/asynchronous-iteration.html


npm의 p-iteration 모듈은 Array iteration 메서드를 구현하여 async / await와 함께 매우 간단하게 사용할 수 있습니다.

귀하의 경우에 대한 예 :

const { forEach } = require('p-iteration');
const fs = require('fs-promise');

(async function printFiles () {
  const files = await getFilePaths();

  await forEach(files, async (file) => {
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  });
})();

그러나 위의 두 가지 솔루션 모두 작동하지만 Antonio 's는 코드를 적게 사용하여 작업을 수행합니다. 여기에서 여러 다른 자식 참조에서 데이터베이스의 데이터를 확인한 다음 모든 데이터를 배열로 푸시하고 결국에 해결할 수있는 방법이 있습니다. 끝난:

Promise.all(PacksList.map((pack)=>{
    return fireBaseRef.child(pack.folderPath).once('value',(snap)=>{
        snap.forEach( childSnap => {
            const file = childSnap.val()
            file.id = childSnap.key;
            allItems.push( file )
        })
    })
})).then(()=>store.dispatch( actions.allMockupItems(allItems)))

다음은 forEachAsync 프로토 타입입니다. await 합니다.

Array.prototype.forEachAsync = async function (fn) {
    for (let t of this) { await fn(t) }
}

Array.prototype.forEachAsyncParallel = async function (fn) {
    await Promise.all(this.map(fn));
}

이 코드를 자신의 코드에 포함시킬 수 있지만, 전역 오염을 피하기 위해 다른 사람에게 배포하는 라이브러리에는 포함시키지 않아야합니다.


비동기식 데이터를 직렬화 된 순서로 처리하고 코드에보다 전통적인 풍미를 제공하는 파일에 몇 가지 메소드를 표시하는 것은 상당히 고통스럽지 않습니다. 예를 들면 다음과 같습니다.

module.exports = function () {
  var self = this;

  this.each = async (items, fn) => {
    if (items && items.length) {
      await Promise.all(
        items.map(async (item) => {
          await fn(item);
        }));
    }
  };

  this.reduce = async (items, fn, initialValue) => {
    await self.each(
      items, async (item) => {
        initialValue = await fn(initialValue, item);
      });
    return initialValue;
  };
};

이제 그것이 './myAsync.js'에 저장되었다고 가정하면 인접한 파일에서 아래와 비슷한 것을 할 수 있습니다.

...
/* your server setup here */
...
var MyAsync = require('./myAsync');
var Cat = require('./models/Cat');
var Doje = require('./models/Doje');
var example = async () => {
  var myAsync = new MyAsync();
  var doje = await Doje.findOne({ name: 'Doje', noises: [] }).save();
  var cleanParams = [];

  // FOR EACH EXAMPLE
  await myAsync.each(['bork', 'concern', 'heck'], 
    async (elem) => {
      if (elem !== 'heck') {
        await doje.update({ $push: { 'noises': elem }});
      }
    });

  var cat = await Cat.findOne({ name: 'Nyan' });

  // REDUCE EXAMPLE
  var friendsOfNyanCat = await myAsync.reduce(cat.friends,
    async (catArray, friendId) => {
      var friend = await Friend.findById(friendId);
      if (friend.name !== 'Long cat') {
        catArray.push(friend.name);
      }
    }, []);
  // Assuming Long Cat was a friend of Nyan Cat...
  assert(friendsOfNyanCat.length === (cat.friends.length - 1));
}

한 가지 중요한 경고 는 다음과 같습니다. await + for .. of method 및 forEach + async 방식은 실제로 다른 효과를 갖습니다.

실제 for 루프 내에서 await 하면 모든 비동기 호출이 하나씩 실행됩니다. 그리고 forEach + async 방식은 동시에 모든 약속을 해제합니다. 빠르지 만 때로는 압도적입니다 ( DB 쿼리를 수행하거나 볼륨 제한이있는 일부 웹 서비스를 방문 하고 한 번에 10 만 건의 호출을 원하지 않는 경우).

async/await 사용하지 않고 파일을 하나씩 읽도록하려면 reduce + promise (보다 우아함)를 사용할 수도 있습니다.

files.reduce((lastPromise, file) => 
 lastPromise.then(() => 
   fs.readFile(file, 'utf8')
 ), Promise.resolve()
)

또는 forEachAsync를 작성하여 기본적으로 동일한 for 루프 기반을 사용할 수 있습니다.

Array.prototype.forEachAsync = async function(cb){
    for(let x of this){
        await cb(x);
    }
}

현재 Array.forEach 프로토 타입 속성은 비동기 작업을 지원하지 않지만 필요에 맞게 자체 폴리 필을 만들 수 있습니다.

// Example of asyncForEach Array poly-fill for NodeJs
// file: asyncForEach.js
// Define asynForEach function 
async function asyncForEach(iteratorFunction){
  let indexer = 0
  for(let data of this){
    await iteratorFunction(data, indexer)
    indexer++
  }
}
// Append it as an Array prototype property
Array.prototype.asyncForEach = asyncForEach
module.exports = {Array}

그리고 그게 다야! 이제 이들에 대해 조작에 대해 정의 된 배열에서 비동기 forEach 메소드를 사용할 수 있습니다.

테스트 해보자 ...

// Nodejs style
// file: someOtherFile.js

const readline = require('readline')
Array = require('./asyncForEach').Array
const log = console.log

// Create a stream interface
function createReader(options={prompt: '>'}){
  return readline.createInterface({
    input: process.stdin
    ,output: process.stdout
    ,prompt: options.prompt !== undefined ? options.prompt : '>'
  })
}
// Create a cli stream reader
async function getUserIn(question, options={prompt:'>'}){
  log(question)
  let reader = createReader(options)
  return new Promise((res)=>{
    reader.on('line', (answer)=>{
      process.stdout.cursorTo(0, 0)
      process.stdout.clearScreenDown()
      reader.close()
      res(answer)
    })
  })
}

let questions = [
  `What's your name`
  ,`What's your favorite programming language`
  ,`What's your favorite async function`
]
let responses = {}

async function getResponses(){
// Notice we have to prepend await before calling the async Array function
// in order for it to function as expected
  await questions.asyncForEach(async function(question, index){
    let answer = await getUserIn(question)
    responses[question] = answer
  })
}

async function main(){
  await getResponses()
  log(responses)
}
main()
// Should prompt user for an answer to each question and then 
// log each question and answer as an object to the terminal

map과 같은 다른 배열 함수 중 일부에 대해서도 동일한 작업을 수행 할 수 있습니다 ...

async function asyncMap(iteratorFunction){
  let newMap = []
  let indexer = 0
  for(let data of this){
    newMap[indexer] = await iteratorFunction(data, indexer, this)
    indexer++
  }
  return newMap
}

Array.prototype.asyncMap = asyncMap

... 등등 :)

참고할 사항 :

  • iteratorFunction은 비동기 함수 또는 약속이어야합니다
  • Array.prototype.<yourAsyncFunc> = <yourAsyncFunc> 이전에 생성 된 배열은이 기능을 사용할 수 없습니다

Promise.all 대신 Array.prototype.map ( Promise 가 해결되는 순서를 보장하지는 않음) 대신 해결 된 Promise 부터 Array.prototype.reduce 사용합니다.

async function printFiles () {
  const files = await getFilePaths();

  await files.reduce(async (promise, file) => {
    // This line will wait for the last async function to finish.
    // The first iteration uses an already resolved Promise
    // so, it will immediately continue.
    await promise;
    const contents = await fs.readFile(file, 'utf8');
    console.log(contents);
  }, Promise.resolve());
}

fs 가 약속 기반 일 때 Bergi의 솔루션 은 훌륭하게 작동합니다. 이를 위해 bluebird , fs-extra 또는 fs-promise 를 사용할 수 있습니다.

그러나 노드의 기본 fs 라이브러리에 대한 솔루션 은 다음과 같습니다.

const result = await Promise.all(filePaths
    .map( async filePath => {
      const fileContents = await getAssetFromCache(filePath, async function() {

        // 1. Wrap with Promise    
        // 2. Return the result of the Promise
        return await new Promise((res, rej) => {
          fs.readFile(filePath, 'utf8', function(err, data) {
            if (data) {
              res(data);
            }
          });
        });
      });

      return fileContents;
    }));

참고 : require('fs') 강제로 세 번째 인수로 기능을 수행하며, 그렇지 않으면 오류가 발생합니다.

TypeError [ERR_INVALID_CALLBACK]: Callback must be a function




ecmascript-2017