JS: Asynchronous programming
2026-02-21 02:54 Diff
https://hexlet.io/courses/js-asynchronous-programming/lessons/chain-of-promises/theory_unit

Even with promises, it's not always clear how to structure asynchronous code. In this lesson, we'll cover some practices that make it easier to write and analyze. Again, let us consider the task of merging two files:

Now we'll do a refactoring and get some canonical code when working with promises. So, the first version:

The good news is that the code is clearer and shorter. Also, error handling is gone, since promises handle errors automatically, and if the code calling a function wants to catch them, it does so using the catch() method. But the bad news is that the code is still structured like a staircase, just like callbacks. This code doesn't take into account the nature of the promises associated with the return of then():

This version is flat, which is the kind of code to strive for when using promises. But it does present one problem. Whenever you need to retrieve data from somewhere in the chain below, you have to pass it through the whole chain. In the example above, this is the result of reading the first file.

The variable data1 is not available where the file is written. The way out of this situation is to create variables through which the data can be passed:

It's not as pretty, but flat. The advantage of this approach becomes more obvious as the number of promises increases. Also, you don't always need to pass data.

Controlling asynchronous operations

A common mistake when working with promises is losing control. Look at the slightly modified code from the examples above:

This code works in many situations, but it contains a serious bug. The promise inside the promise constant isn't returned outside. The promise chain is broken. Any error in this promise will go unnoticed by external code. There's no guarantee that this promise will execute at the time the calling code expects it.

Violating the continuity of asynchronous operations is a common error, even among experienced programmers. In some situations, this error is immediately noticeable; in others, the code behaves oddly. Sometimes it runs OK; in others, it crashes with random errors.

To prevent this, you need to make sure that asynchronous operations aren't interrupted. The completion of each operation must lead to some kind of response. There must always be something waiting for that moment.

Dynamic chain

Sometimes we don't know the number of asynchronous operations in advance, but they must execute one after the other. We can solve the problem by using loops or folding. Whichever way you choose, the principle of building a chain doesn't change. A chain of promises will always look like then().then().then()....

The only nuance you need to consider is the initial promise from which the chain starts. If such a promise doesn't exist, it can be created using the Promise.resolve() function. It will return a promise that doesn't do anything, but you can use it to start folding. Below is an example that reads a set of files sequentially and returns an array of their contents: