promise-chain | A promise chain example | Reactive Programming library

You need to await the fetch in order for it to work as you expect it to be.

When your JS code does an Ajax request over the network to get data from the server, you need to set up the response code in a function (which is also called callback).The JS Engine basiclly tells the hosting environment that he is going to suspend the execution for the moment and when the network response arrives back, please let me know and execute that callback function.

So' in your example, you're making an asynchronous request via fetch. the response will get sometime after you make it but if you won't await that call, the

This should absolutely be doable using setTimeout. Probably the issue is that you are immediately registering 10,000 timeouts. The longer your path, the worse this approach becomes.

So instead of scheduling all updates right away, you should use a recursive algorithm where each "frame" schedules the timeout for the next frame. Something like this:

It's not a promise unless its .then(…) method returns a promise, and if it's an ES6 native Promise then it definitely will.

A thenable's then method may return anything (including undefined).

What it's saying is that, by using the code in the example:

I've used 2 solutions for this type of thing.

1: wrap the interface in an extension

Your first example works like this:

1. new Promise runs, calling the function you pass it (the executor function) synchronously
2. Code in the executor function calls setTimeout, passing in a function to call 1000ms later; the browser adds that to its list of pending timer callbacks
3. new Promise returns the promise
4. then is called, adding the function you pass into it to the promise's list of fulfillment handlers and creating a new promise (which your code doesn't use, so it gets thrown away).
5. 1000ms or so later, the browser queues a call to the setTimeout callback, which the JavaScript engine picks up and runs
6. The callback calls the resolve function to fulfill the promise with the value 1
7. That triggers the promise's fulfillment handlers (asynchronously, but it doesn't really matter for this example), so the handler attached in Step 4 gets called, showing the alert and then returning result * 2 (which is 1 * 2, which is 1). That value is used to fulfill the promise created and thrown away in Step 4.

Will JS engine wait until fetch gets resolved or Will JS engine continue executing let user = await response.json();...

It waits. The async function is suspended at the await in await fetch(/*...*/), waiting for the promise fetch returned to settle. While it's suspended, the main JavaScript thread can do other things. Later, when the promise settles, the function is resumed and either the fulfillment value is assigned to response (if the promise is fulfilled) or an exception will get thrown (if it is rejected).

More generally: async functions are synchronous up until the first await or return in their code. At that point, they return their promise, which is settled later based on the remainder of the async function's code.

In a comment you asked:

when async function is suspended at each await, will async function is removed from the call stack and is put back to the call stack again when the promise being awaited settles?

At a low level, yes; but to make debugging easier, a good, up-to-date JavaScript engine maintains an "async call stack" they use for error traces and such. For instance, if you run this on Chrome...

You must:

1. Make your original function return a promise
2. Await that promise when calling runInNewContext.

Therefore, let's say you want to return the user object:

One approach to run multiple async calls with minimal code would be via an async for-loop:

Chaining a promise and making an HTTP request are different things. In the case of fetch, you do indeed chain one promise to another, but doing so doesn't result in another HTTP request to the server. Instead, what happens is that the first promise fulfills after receiving the headers, and then the second fulfills after receiving the body of the same request.