A brief look at async-await

A brief look at async-await
javascript.christmas

If you could share what you found incorrect, we are happy to update the article accordingly

  function chain () {
    (function loop (i) {
        if (i > 5) {
            // set state to failed
            return;
        }

        check().then((result) => {
            if (!result) {
                return loop(i + 1);
            }

            // set state to finished

        }).catch((error) => {
            // set state to failed
        });
    }(0));
  }

Actually, I would argue that promises really made no sense until "await" became available because they introduce extra complexity and (small) performance penalty for no added benefit. Worse, it encourages less experienced developers to write code in a serial manner in situations where this is not necessary (a much bigger performance problem).

Even with "await", the only time when it is really useful is when there have to be a several asynchronous operations that must happen serially because they use the result of the previous call. It depends on your field of work, of course, but in my experience these situations are really not that common.

Some time ago I wrote an article comparing performance of callbacks vs async/await but it is also an example to show that callback code does not have to be more tedious to write:

https://gir.me.uk/posts/node-8-async-await-performance-test....

Surely a better comparison for the async function would be a chain() that manually recreates the loop using a parameter or local captured variable, like shown below. They're still complex but if anything show the complexity more clearly, especially if 6 is not hardcoded but could be passed as a parameter. I suppose having the unrolled version from the article plus one of these would be best of all, to show the problem from all angles.

    function chainWithParam() {
        var checkAndIterate;
        checkAndIterate = (result, i) => {
            if (result) {
                // set state to finished
                return;
            }
            if (i == 6) {
                // set state to not done
                return;
            }
            check()
                .then(result => checkAndIterate(result, i + 1))
                .catch(error => /* set state to failed */);
        }
        checkAndIterate(false, 0);
    }
    
    function chainWithCapturedLocal() {
        i = 0;
        var checkAndIterate;
        checkAndIterate = result => {
            if (result) {
                // set state to finished
                return;
            }
            if (i == 6) {
                // set state to not done
                return;
            }
            ++i;
            check()
                .then(checkAndIterate)
                .catch(error => /* set state to failed */);
        }
        checkAndIterate(false);
    }

Surely the "manual" function could be implemented with some sort of loop-like

With the exception of necessarily serial code that I referred to, this statement is not true in my experience. Your "legible" example is only legible because you are not doing anything actually important like error handling and logging. In the real world each call may need different logging or even error handling logic and that is when promises really turn into a rats nest.

Validation, i.e. tests, are really the same regardless which approach you are using.

I do agree that async/await made promises actually usable, as I said above.

For running a bunch of asynchronous functions that do the same thing the semaphore + collector pattern works just fine and is not much more verbose.