getify | A utility to grab nested values from objects | Runtime Evironment library

I am not exactly sure what is the desired output but have a look at this.

You can see the outer level are genres, followed by nested publishers with nested books within.

1. Firstly, I got all the genres.
2. Then I got the books and publishers with $lookup.
3. I used $unwind to separate publishers.
4. I added books with $addFields to each publisher for filtering it later.
5. I used $group to get relevant elements and $addToSet to make an array of publishers.
6. Finally, I used $project with $map and $filter to get relevant books for each publisher.

I think your looking for $lookup with a pipeline like this:

https://mongoplayground.net/p/H_OsKvN_npf

The exports object is created for your module before your module runs, and if there are circular dependencies, other modules may have access to that default object before your module can fill it in. If you replace it, they may have the old, original object, and not (eventually) see your exports. If you add to it, then even though the object didn't have your exports initially, eventually it will have it, even if the other module got access to the object before those exports existed.

More in the Cycles section of the CJS module documentation.

We can adapt the cycle example in that section to demonstrate it:

a.js (note changes):

No. The scope that contains name and b are not created until the function foo() is called.

In order to find one book you can use:

This is not the best solution, but you can poll a cancellation variable inside the promise :

For your original question, you want to see them run in parallel. You can use Promise.all to run multiple async tasks, it will waits for all async tasks resolved and return an output array.

Promise.all executes async tasks by iterating them(in series), not technically executes them in parallel, but they are running in parallel. It will give you a result when all async tasks resolved or rejected if any one of them failed.

Or you can just run them 1 by 1 without Promise.all. they won't block each other, so still in parallel, but you Promise.all just help you handle callback results in one place.

The output will be either 12 or 20, depends on random timeout you set for bar and foo functions.

For race condition, only the setTimeout functions are asynchronous, but all operations in callbacks are synchronous and non-blocking, so the thread won't jump from operations in one callback to another callback unless all operations in that callback are finished.

But in JS, you can still have data race when using SharedArrayBuffer which needs Atomics object to prevent data race.

Maximum recursion depth happens when you call the same function over and over again in itself too many times. The reason is that every time you call the function, you have to create new instances of all its stack variables.

For instance:

This is because of boxing in JS. The value passed as this to a function in strict mode is not forced into being an object. JS changes the this object when entering the context of the foo() function. In your sample code you are not calling the function as a part of an object, so its value will be undefined. If you do not use strict mode, the value of this is automatically set to the window object. more info here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode