Understanding the crazy behavior of JavaScript array concat and async functions

Discover the difference between `push` and `concat` in asynchronous JavaScript array operations and why one method could fail while the other succeeds.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Crazy simultaneous javascript array concat interferes with itself

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Tackling the Crazy Behavior of JavaScript Array Concatenation

When working with JavaScript, developers are often faced with unexpected behaviors, especially when dealing with asynchronous operations. A common dilemma arises when trying to concatenate arrays while fetching data asynchronously. This guide addresses a specific problem where using push and concat yields different results in the same scenario, leading to confusion and debugging challenges.

The Dilemma

Imagine you're constructing an array filled with employment data from various company IDs by calling an asynchronous function. You find that using concat sometimes leads to missing items, while push always returns the expected results. The core of this mystery lies in understanding JavaScript's asynchronous behavior and how concat handles references under the hood.

Here's a snapshot of the code:

[[See Video to Reveal this Text or Code Snippet]]

In this scenario, VERSION 1 using push consistently returns the expected results, while VERSION 2 using concat can result in random outcomes.

Why Does This Happen?

To decipher this behavior, we need to delve into how each method operates.

Version 1: push

With push, you're directly modifying the same reference to the employments array. Each call adds elements to the existing array as follows:

[[See Video to Reveal this Text or Code Snippet]]

The reference to employments is preserved.

Each async task awaits completion and updates the same array.

This guarantees that every item fetched is added correctly.

Version 2: concat

On the flip side, concat creates a new array based on the existing one. If two async functions occur simultaneously, they might reference an outdated state of employments, leading to inconsistencies.

[[See Video to Reveal this Text or Code Snippet]]

The Race Condition

In asynchronous JavaScript, two "threads" (callbacks) might attempt to access and modify employments at the same time. This creates a race condition:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

In situations where you're working with asynchronous functions and arrays, favor the push method to maintain a consistent reference and avoid the complications of concatenating with potentially outdated data.

Understanding how async calls can interleave and affect your data can save you from hours of debugging. Equipped with this knowledge, you can troubleshoot and anticipate issues that may arise in your JavaScript applications.

Do you have your own experiences dealing with bizarre behavior in array manipulations during asynchronous functions? Share in the comments below!