Alternative to looping inside for ... of and while(true)

Question

Very often I end up writing loops with awaits inside of them, in order to perform some tasks sequentially or achieve a certain interval between iterations.

For example:

for (const item of items) {
  await doSomthing(item);
}

or:

while(true) {
  await doSomeTask();
  await delay(60000);  
}

However, ESLint is reprimanding me for writing this kind of code.

What is an alternative pattern to sequential looping with awaiting and infinite loops with awaits inside, when I don't want to run all async tasks at the same time and rather want to run them at a slow pace?

`for/in` is meant to iterate over Objects and should not be used in other scenarios. — Scott Marcus, Aug 27 '18 at 17:31
You need to be using [Promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) more fully than just with the `await` keyword. — Scott Marcus, Aug 27 '18 at 17:32
I think we'll need a more concrete example of what you're trying to achieve to provide a meaningful answer to this. — T.J. Crowder, Aug 27 '18 at 17:33
What exactly does ESLint say? I don't see anything terribly wrong with that code if it's what you want to do. — Pointy, Aug 27 '18 at 17:33
@ScottMarcus - Depending on the actual goal, the above seems fine (except I'm not a fan of endless loops, even asynchronous ones). — T.J. Crowder, Aug 27 '18 at 17:33
@Pointy the airbnb config for eslint bans this syntax - `no-await-in-loop` and `no-constant-condition` rules — , Aug 27 '18 at 17:34
@K48 - Only one of many flaws in the AirBnB style stuff in general. — T.J. Crowder, Aug 27 '18 at 17:35
possible duplicate of https://stackoverflow.com/questions/48370317/is-there-a-clean-way-to-infinitely-use-async-functions — Bergi, Aug 27 '18 at 17:44

Bergi · Accepted Answer · 2018-08-27T17:47:04.840

3

ESLint is reprimanding me for writing this kind of code.

The solution here is to disable ESLint - either individually for those lines, or that horrible rule in general. Even the rule docs themselves say "In many cases […] it makes sense to use await within a loop and it is recommended to disable the rule via a standard ESLint disable comment".

The code you are writing is perfectly appropriate for performing tasks sequentially. If you want to avoid it, there's only recursion as an alternative that the linter can't detect :-)

edited Aug 27 '18 at 17:47

answered Aug 27 '18 at 17:34

Bergi

630,263
148
957
1,375

I wouldn't call it a "horrible rule". It is simply pointing out some code that does not take full advantage of the async/await capabilities. You are correct that the above code is perfectly valid when certain statements should be executed sequentially, however, if there is no necessity, then you should use Promise.all() to get an efficiency/speed boost. – Tim Klein Aug 27 '18 at 17:38
@TimKlein I think it's horrible to make it an error by default. Also for me the rate of false positives is far too high, but maybe that's just me who already knows when to use which. A linter is not useful when you have the feeling that it "reprimands" you instead of offering helpful advise. – Bergi Aug 27 '18 at 17:44
@TimKlein Running things in series is certainly not always a bad thing,. The biggest problem I have with `Promise.all` is it has no built in throttling, Bluebirds `map` with the concurrency option should really be what `Promise.all` became. – Keith Aug 27 '18 at 17:56

score 1 · Answer 2 · answered Aug 27 '18 at 18:44

You could use a recursive function to achieve the same effect, and this allows you to more fully leverage the asynchronous nature of what you're doing. Your main thread can continue on and do other things rather than waiting for the end of a for loop - any code that relies on that section being complete can be executed in the callback function that you pass in.

function asynchronousFunction(thing){
  //do something
  console.log('doing something')
  return new Promise(resolve => {
    setTimeout(e => resolve(), 1000)
  })
}

async function doSomething(arrayOfThings, next){
  const thing = arrayOfThings.pop()
  const responseFromAsyncFunction = await asynchronousFunction(thing)
  console.log('after', arrayOfThings.length)
  if(arrayOfThings.length) doSomething(arrayOfThings, next)
  else next()
}

const myData = [1,2,3,4,5]

doSomething(myData.slice(0), function(){ console.log('done') })

Alternative to looping inside for ... of and while(true)

2 Answers2

Related