Using async/await with a forEach loop

Another issue is that using async/await inside a forEach loop, which is something we often tend to do, can lead to unintended consequences. The problem here is that forEach does not recognize async functions or handle promises correctly. Although your code may seem to "work" without throwing any errors, it won't actually await each readFile operation as intended.

Here's what happens:

The forEach loop starts all the readFile operations almost simultaneously, moving on to the next one before they finish. Since forEach doesn’t wait for the asynchronous function to complete, the printFiles function will be called before all file contents are fully read. This could cause the logs to be incomplete or lead to other issues depending on the situation.

If you need to process each file in turn, a regular for...of loop is more effective because it correctly handles await:

import fs from 'fs-promise'; async function printFiles() { const files = await getFilePaths(); // Assume this works fine for (const file of files) { const contents = await fs.readFile(file, 'utf8'); console.log(contents); } } printFiles(); 

This ensures that each file is read and logged before moving on to the next one.

To sum it up, avoid using async/await inside forEach, as it may not work as expected. Instead, use a for...of the loop to guarantee proper sequential execution of asynchronous functions.

This does not use async/await as the OP requested and only works if you are in the back-end with NodeJS. Although it still may be helpful for some people, because the example given by OP is to read file contents, and normally you do file reading in the backend.

Fully asynchronous and non-blocking:

const fs = require("fs") const async = require("async") const obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"} const configs = {} async.forEachOf(obj, (value, key, callback) => { fs.readFile(__dirname + value, "utf8", (err, data) => { if (err) return callback(err) try { configs[key] = JSON.parse(data); } catch (e) { return callback(e) } callback() }); }, err => { if (err) console.error(err.message) // configs is now a map of JSON data doSomethingWith(configs) }) 

I would use the well-tested (millions of downloads per week) pify and async modules. If you are unfamiliar with the async module, I highly recommend you check out its docs. I've seen multiple devs waste time recreating its methods, or worse, making difficult-to-maintain async code when higher-order async methods would simplify code.

const async = require('async') const fs = require('fs-promise') const pify = require('pify') async function getFilePaths() { return Promise.resolve([ './package.json', './package-lock.json', ]); } async function printFiles () { const files = await getFilePaths() await pify(async.eachSeries)(files, async (file) => { // <-- run in series // await pify(async.each)(files, async (file) => { // <-- run in parallel const contents = await fs.readFile(file, 'utf8') console.log(contents) }) console.log('HAMBONE') } printFiles().then(() => { console.log('HAMBUNNY') }) // ORDER OF LOGS: // package.json contents // package-lock.json contents // HAMBONE // HAMBUNNY ```

In 2022 I would still advise using external libraries to handle all this async flow. I've created the module alot🔗 for similar things.

Your example would be:

import fs from 'fs-promise' import alot from 'alot' async function printFiles () { const files = await getFilePaths() // Assume this works fine await alot(files) .forEachAsync(async file => { let content = await fs.readFile(file, 'utf8'); console.log(content); }) .toArrayAsync({ threads: 4 }); } } printFiles() 

For simple examples surely the async for..of would do the job, but as soon the task is more complicated you have to use some utility for this.

Alot has dozens of other methods that you can chain, like mapAsync, filterAsync, groupAsync, etc.

As an example:

• Load JSON files with products meta
• Extract ProductID
• Load products from the server
• Filter those with a price > 100$
• Order by price ascending
• Take top 50

import fs from 'fs-promise' import alot from 'alot' import axios from 'axios' import { File } from 'atma-io' let paths = await getFilePaths(); let products = await alot(paths) .mapAsync(async path => await File.readAsync<IProductMeta>(path)) .mapAsync(async meta => await axios.get(`${server}/api/product/${meta.productId}`)) .mapAsync(resp => resp.data) .filterAsync(product => product.price > 100) .sortBy(product => product.price, 'asc') .takeAsync(50) .toArrayAsync({ threads: 5, errors: 'include' });