Introduction

Asynchronous JavaScript is one of the most misunderstood parts of the language because several concepts get mixed together: the call stack, the event loop, timers, promises, and browser or runtime APIs. The cleanest way to learn it is to correct a few common misstatements and connect each one to what the engine is actually doing.

Misconception 1: Async JavaScript Means JavaScript Runs Many Lines at the Same Time

Usually, JavaScript code still runs on one main thread of execution. What changes is that some operations, such as timers, network requests, and file I/O, are delegated to the host environment. When they finish, their callbacks are scheduled to run later.

That means asynchronous JavaScript is about non-blocking coordination, not automatic parallel execution of your normal code.

A simple example:

1console.log("start");
2
3setTimeout(() => {
4  console.log("timer finished");
5}, 0);
6
7console.log("end");

The output is:

start
end
timer finished

Even with a zero-millisecond timer, the callback does not interrupt the current call stack.

Misconception 2: setTimeout(fn, 0) Runs Immediately

It does not. It means "run this callback no earlier than the specified delay, after the current stack is clear and after the event loop gets to it."

That distinction matters when promises are involved. Promise callbacks are scheduled as microtasks, which run before timer callbacks in the next event-loop turn:

1console.log("A");
2
3setTimeout(() => console.log("timeout"), 0);
4
5Promise.resolve().then(() => console.log("promise"));
6
7console.log("B");

The output is:

1A
2B
3promise
4timeout

This surprises many learners because both pieces of work are asynchronous, but they are not placed in the same queue.

Misconception 3: async and await Make Code Synchronous

async and await make asynchronous code look more linear, but the code is still promise-based. An async function always returns a promise.

1async function getNumber() {
2  return 42;
3}
4
5getNumber().then((value) => {
6  console.log(value);
7});

Even though the function appears to return a plain number, the caller receives a promise that eventually resolves to 42.

await pauses only the current async function, not the whole JavaScript runtime. Other tasks can keep running while that function is suspended.

Misconception 4: AJAX and Asynchronous JavaScript Are the Same Thing

AJAX is one use of asynchronous JavaScript, not the definition of it. The broader topic includes:

• timers such as setTimeout
• promises
• 'fetch'
• async iterators
• event handlers
• worker communication

If you equate async JavaScript with AJAX only, your mental model becomes too narrow and older than the language ecosystem you are actually working in.

Build the Correct Mental Model

A better model is:

• JavaScript executes current code on the call stack
• host APIs manage timers, network I/O, and other external work
• when async work completes, callbacks are queued
• the event loop schedules queued work when the stack is empty
• microtasks, such as promise reactions, are drained before moving to the next macrotask

That is enough to explain most confusing examples without memorizing random output orders.

Common Pitfalls

The biggest mistake is assuming "asynchronous" means "faster." If you await requests sequentially in a loop, the code is still asynchronous but not concurrent.

Another common issue is forgetting that async functions return promises. That leads to bugs like logging the promise object itself instead of awaiting it.

Developers also often misuse setTimeout as a way to "wait for something to finish." A timer is just a timer. It does not know when another operation is ready.

Finally, many misconceptions come from ignoring the distinction between promise microtasks and timer callbacks. If the output order seems strange, that is usually the first place to look.

Summary

• Async JavaScript is about non-blocking coordination, not normal code running all at once.
• 'setTimeout(fn, 0) does not run immediately.'
• Promise callbacks run before timer callbacks in the next event-loop turn.
• 'async functions always return promises.'
• AJAX is only one example of asynchronous JavaScript, not the whole concept.