确保守则行之有效,但我很相信,它没有做你预计要做的事情。 它只是向多个星号开火,但Files 功能随即返回。

Reading in sequence

如果您希望按顺序阅读这些档案, 确实不能使用forEach。 仅使用一个现代的<代码>(>for...... of loop>,其中await将按预期运作:

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

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

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

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

除readFile

import fs from  fs-promise ;
async function printFiles () {
  const files = await getFilePaths();

  const promises = files.map((file) => fs.readFile(file,  utf8 ))

  const contents = await Promise.all(promises)

  contents.forEach(console.log);
}

Bergi s solution works nicely when fs is promise based. You can use bluebird, fs-extra or fs-promise for this.

However, solution for node s native fs libary is as follows:

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

Note: require( fs ) compulsorily takes function as 3rd arguments, otherwise throws error:

TypeError [ERR_INVALID_CALLBACK]: Callback must be a function

不要把一刀切的方法从 lo中.。 这是因为,每艘护航将推迟到整个同步作业完成之后。 这并不是非常干.的。 它还避免了<代码>sync/>/await的平行化好处。

更好的解决办法是一劳永逸地创造所有承诺,然后利用<条码>Promise.all(<>获取结果。 否则,每次连续作业都不会开始,直到以前完成。

Consequently, the code may be refactored as follows;

const printFiles = async () => {
  const files = await getFilePaths();
  const results = [];
  files.forEach((file) => {
    results.push(fs.readFile(file,  utf8 ));
  });
  const contents = await Promise.all(results);
  console.log(contents);
}

一个重要的caveat是:await + for . of methods and the for Each + async way 实际效果不同。

插入awaitin a real for 休息将确保所有星号都由一个人执行。 和forEach + async 与此同时,所有承诺也会被击退,这种承诺是更快的,有时是过度的()。 如果你做一些非行问询或访问某些网络服务,限制数量:,并不想在某个时候发射10万次电话。

如果你不使用<条码>条码/日码<>,则你也可使用<<>条码>。

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

或者,你可以创造出一个帮助,但从根本上说,这种帮助就是利用。

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

您可使用<代码>Array.prototype.forEach,但作为ync/await不能兼容。 这是因为,从联合呼吁中恢复的许诺预计会得到解决,但Array.prototype.forEach没有兑现执行呼吁的任何承诺。 因此,你可以供大家使用,但不得不处理允诺的解决办法。

这里是使用<代码>Array.prototype.forEach的系列文件读写的一种方式。

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

  let promiseChain = Promise.resolve()
  files.forEach((file) => {
    promiseChain = promiseChain.then(() => {
      fs.readFile(file,  utf8 ).then((contents) => {
        console.log(contents)
      })
    })
  })
  await promiseChain
}

Here is a way (still using Array.prototype.forEach) to print the contents of files in parallel

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

  const promises = []
  files.forEach((file) => {
    promises.push(
      fs.readFile(file,  utf8 ).then((contents) => {
        console.log(contents)
      })
    )
  })
  await Promise.all(promises)
}

仅增加原始答复

• The parallel reading syntax in the original answer is sometimes confusing and difficult to read, maybe we can write it in a different approach

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

  const readAndLogFile = async filePath => {
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
    return contents;
  };

  files.forEach(file => {
    fileReadPromises.push(readAndLogFile(file));
  });

  await Promise.all(fileReadPromises);
}

• For sequential operation, not just for...of, normal for loop will also work

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

  for (let i = 0; i < files.length; i++) {
    const file = files[i];
    const contents = await fs.readFile(file, "utf8");
    console.log(contents);
  }
}

执行部分第1段

是否在每一 lo中使用yn/awa? ......

was covered to an extent in @Bergi s selected answer, which showed how to process in serial and in parallel. However there are other issues noted with parallelism -

1. Order -- @chharvey notes that -

例如,如果一个小的档案在真正庞大的档案之前完成阅读,那么,即使小档案是在文件阵列中大案卷之后提交的,它就将首先记录下来。

2. Possibly opening too many files at once -- A comment by Bergi under another answer

It is also not good to open thousands of files at once to read them concurrently. One always has to do an assessment whether a sequential, parallel, or mixed approach is better.

So let s address these issues showing actual code that is brief and concise, and does not use third party libraries. Something easy to cut, paste, and modify.

Reading in parallel (all at once), printing in serial (as early as possible per file).

最容易改进的是,如@Bergi swer,但作小改动,以便每个档案都尽快印制<>,同时保留<>/em>。

async function printFiles2() {
  const readProms = (await getFilePaths()).map((file) =>
    fs.readFile(file, "utf8")
  );
  await Promise.all([
    await Promise.all(readProms),                      // branch 1
    (async () => {                                     // branch 2
      for (const p of readProms) console.log(await p);
    })(),
  ]);
}

首先,两个单独的分支同时运作。

• branch 1: Reading in parallel, all at once,
• branch 2: Reading in serial to force order, but waiting no longer than necessary

这是容易的。

Reading in parallel with a concurrency limit, printing in serial (as early as possible per file).

A "concurrency limit" means that no more than N files will ever being read at the same time.
Like a store that only allows in so many customers at a time (at least during COVID).

第一个辅助职能是:

function bootablePromise(kickMe: () => Promise<any>) {
  let resolve: (value: unknown) => void = () => {};
  const promise = new Promise((res) => { resolve = res; });
  const boot = () => { resolve(kickMe()); };
  return { promise, boot };
}

The function bootablePromise(kickMe:() => Promise<any>) takes a function kickMe as an argument to start a task (in our case readFile) but is not started immediately.

。

• promise of type Promise
• boot of type function ()=>void

promise has two stages in life

1. Being a promise to start a task
2. Being a promise complete a task it has already started.

promise transitions from the first to the second state when boot() is called.

async function printFiles4() {
  const files = await getFilePaths();
  const boots: (() => void)[] = [];
  const set: Set<Promise<{ pidx: number }>> = new Set<Promise<any>>();
  const bootableProms = files.map((file,pidx) => {
    const { promise, boot } = bootablePromise(() => fs.readFile(file, "utf8"));
    boots.push(boot);
    set.add(promise.then(() => ({ pidx })));
    return promise;
  });
  const concurLimit = 2;
  await Promise.all([
    (async () => {                                       // branch 1
      let idx = 0;
      boots.slice(0, concurLimit).forEach((b) => { b(); idx++; });
      while (idx<boots.length) {
        const { pidx } = await Promise.race([...set]);
        set.delete([...set][pidx]);
        boots[idx++]();
      }
    })(),
    (async () => {                                       // branch 2
      for (const p of bootableProms) console.log(await p);
    })(),
  ]);
}

以前有两个分支

• branch 1: For running and handling concurrency.
• branch 2: For printing

现在的差额不超过<条码>。 许可同时办理。

重要变量是:

• boots: The array of functions to call to force its corresponding Promise to transition. It is used only in branch 1.
• set: There are Promises in a random access container so that they can be easily removed once fulfilled. This container is used only in branch 1.
• bootableProms: These are the same Promises as initially in set, but it is an array not a set, and the array is never changed. It is used only in branch 2.

采用一个模拟<代码>fs.readFile,时间为:

const timeTable = {
  "1": 600,
  "2": 500,
  "3": 400,
  "4": 300,
  "5": 200,
  "6": 100,
};

test run times such as this are seen, showing the concurrency is working --

[1]0--0.601
[2]0--0.502
[3]0.503--0.904
[4]0.608--0.908
[5]0.905--1.105
[6]0.905--1.005

马达加斯加

然而,上述两种解决办法都是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)))

同@Bergi的反应一样,但有一个不同之处。

<代码>Promise.all拒绝所有允诺,如果这些承诺被否决。

因此,使用再保险。

const readFilesQueue = async (files, index = 0) {
    const contents = await fs.readFile(files[index],  utf8 )
    console.log(contents)

    return files.length <= index
        ? readFilesQueue(files, ++index)
        : files

}

const printFiles async = () => {
    const files = await getFilePaths();
    const printContents = await readFilesQueue(files)

    return printContents
}

printFiles()

<<>PS>/strong>

。

因此,该法典只能由以下因素设计:三个分离的职能是“纯净”** ,没有副作用,处理整个清单,并易于修改以处理未结案件。

const files = await getFilesPath()

const printFile = async (file) => {
    const content = await fs.readFile(file,  utf8 )
    console.log(content)
}

const readFiles = async = (files, index = 0) => {
    await printFile(files[index])

    return files.lengh <= index
        ? readFiles(files, ++index)
        : files
}

readFiles(files)

www.un.org/Depts/DGACM/index_spanish.htm 未来的编辑/现状

Node支持高层的等待(这确实有gin,已经赢得,并且可以通过和谐旗帜获得),它冷却,但却没有解决一个问题(从战略上讲,我只处理LTS版本)。 如何获得档案?

Using composition. Given the code, causes to me a sensation that this is inside a module, so, should have a function to do it. If not, you should use an IIFE to wrap the role code into an async function creating simple module that s do all for you, or you can go with the right way, there is, composition.

// more complex version with IIFE to a single module
(async (files) => readFiles(await files())(getFilesPath)

请注意,由于语义原因的变化的名称。 您通过一名校长(一种功能,可由另一功能援引),并找回一个记忆点,其中含有申请逻辑的最初部分。

But, if s not a module and you need to export the logic?

将职能按“合成”职能处理。

export const readFilesQueue = async () => {
    // ... to code goes here
}

或改变变数名称,不论......

* by side effect menans any colacteral effect of application that can change the statate/behaviour or introuce bugs in the application, like IO.

** by "pure”, it s in tratrophe since the functions it not organic and the Code can be converged to a organic text, when there s no consoleproduct, only data pors.

除此之外,为了简单起见,你需要与处理副作用、易发生错误的mon合作,并将这一错误与申请分开处理。

目前,Array。 页: 1 每个农业综合企业的财产都不支持“合成”行动,但我们能够创造自己的多功能来满足我们的需要。

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

而这样说! 现在,在业务后确定的任何阵列中,你们都有一种可供使用的方法。

让我们检验......

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

对于像地图这样的其他一些阵列职能,我们也可以这样做。

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

......

值得注意的是:

• Your iteratorFunction must be an async function or promise
• Any arrays created before Array.prototype.<yourAsyncFunc> = <yourAsyncFunc> will not have this feature available

今天 我提出了多方面的解决办法。 追随该星座,等待每个洛普岛的职能。 通过在周围建立总结,我们就可以做到这一点。

。

await (()=>{
     return new Promise((resolve,reject)=>{
       items.forEach(async (item,index)=>{
           try{
               await someAPICall();
           } catch(e) {
              console.log(e)
           }
           count++;
           if(index === items.length-1){
             resolve( Done )
           }
         });
     });
    })();

if(!Array.prototype.forEachAsync) {
    Array.prototype.forEachAsync = function (fn){
      return new Promise((resolve,reject)=>{
        this.forEach(async(item,index,array)=>{
            await fn(item,index,array);
            if(index === array.length-1){
                resolve( done );
            }
        })
      });
    };
  }

require( ./Array.prototype.forEachAsync );

let count = 0;

let hello = async (items) => {

// Method 1 - Using the Array.prototype.forEach 

    await items.forEachAsync(async () => {
         try{
               await someAPICall();
           } catch(e) {
              console.log(e)
           }
        count++;
    });

    console.log("count = " + count);
}

someAPICall = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve("done") // or reject( error )
        }, 100);
    })
}

hello([  ,   ,   ,   ]); // hello([]) empty array is also be handled by default

  await Promise.all(items.map(async (item) => {
        await someAPICall();
        count++;
    }));

    console.log("count = " + count);

// Method 4 - using for loop directly

// 1. Using the modern for(.. in..) loop
   for(item in items){

        await someAPICall();
        count++;
    }

//2. Using the traditional for loop 

    for(let i=0;i<items.length;i++){

        await someAPICall();
        count++;
    }


    console.log("count = " + count);

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

  List(files).traverse( Task.of, f => readFile( f,  utf-8 ))
    .fork( console.error, console.log)
}

import fs from  fs ;
import { futurize } from  futurize ;
import Task from  data.task ;
import { List } from  immutable-ext ;

const future = futurizeP(Task)
const readFile = future(fs.readFile)

const printFiles = files => 
  List(files).traverse( Task.of, fn => readFile( fn,  utf-8 ))
    .fork( console.error, console.log)

// 90% of encodings are utf-8, making that use case super easy is prudent

// handy-library.js
export const readFile = f =>
  future(fs.readFile)( f,  utf-8  )

export const arrayToTaskList = list => taskFn => 
  List(files).traverse( Task.of, taskFn ) 

export const readFiles = files =>
  arrayToTaskList( files, readFile )

export const printFiles = files => 
  readFiles(files).fork( console.error, console.log)

async function main() {
  /* awesome code with side-effects before */
  printFiles( await getFiles() );
  /* awesome code with side-effects after */
}

If you really wanted more flexibility in encoding, you could just do this (for fun, I m using the proposed Pipe Forward operator )

import { curry, flip } from  ramda 

export const readFile = fs.readFile 
  |> future,
  |> curry,
  |> flip

export const readFileUtf8 = readFile( utf-8 )

PS - I don ttries this Code on the console, may have some打字器...... 说到,“带自由的帽子,”90千卡。 iii

正如其他答复提到的那样,你也许希望按顺序执行,而不是同时执行。 Ie. 先提出申请,等到提交文件为止,then<>em>,一经提交第二次档案。 这不会发生。

const forEach = (arr, cb) => {
  for (let i = 0; i < arr.length; i++) {
    cb(arr[i]);
  }
};

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

const delay = (ms) => {
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
};

const logNumbers = async () => {
  console.log(1);
  await delay(2000);
  console.log(2);
  await delay(2000);
  console.log(3);
};

const main = () => {
  console.log("a");
  logNumbers();
  console.log("b");
};

main();