Create Event_loop_phases.md

Author: ps0305

Basic JavaScript/Event_loop_phases.md

@@ -0,0 +1,69 @@
+In JavaScript, the **event loop** is a core concept that manages the execution of asynchronous operations and tasks. The event loop is responsible for continuously checking the **call stack** and **task queues** to determine which code to execute next. It consists of multiple phases, each handling specific types of tasks. Below are the different phases of the event loop in JavaScript (based on Node.js as it provides more insight into the phases):
+
+### 1. **Timers Phase**
+- This phase executes **callbacks scheduled by `setTimeout()` and `setInterval()`**.
+- Only the callbacks whose timer has expired are executed.
+- If a timer is set with a delay of `0ms`, it does not execute immediately but is processed in this phase after other phases.
+
+### 2. **Pending Callbacks Phase**
+- This phase handles I/O callbacks that were deferred, such as errors from TCP operations or `dns` callbacks.
+- It processes callbacks that are not directly tied to a specific timer but are still waiting for some I/O operation to complete.
+
+### 3. **Idle, Prepare Phase**
+- This is an internal phase used by Node.js for system-level tasks. It is rarely used in user-land code.
+- This phase allows the event loop to perform setup and other necessary operations before the actual execution of tasks.
+
+### 4. **Poll Phase**
+- This phase is where the event loop **spends most of its time**.
+- It processes incoming I/O events (e.g., reading from a file, handling HTTP requests).
+- If there are no timers or I/O callbacks, the poll phase can block and wait for new events.
+- It will execute **synchronous I/O callbacks** like reading a file or network data.
+
+### 5. **Check Phase (for `setImmediate()`)**
+- This phase executes callbacks scheduled by `setImmediate()`.
+- The `setImmediate()` callbacks are executed after the poll phase is complete, making them run before timers if scheduled during the poll phase.
+
+### 6. **Close Callbacks Phase**
+- This phase handles **close callbacks**, such as when a socket or stream is closed (`'close'` event).
+- It executes any cleanup functions or final callbacks for closing resources.
+
+### 7. **Microtasks Queue (Promises and `process.nextTick()`)**
+- Although not an explicit phase, **microtasks** are crucial and can be processed between the main phases.
+- This includes callbacks from **Promises (`.then()`), `process.nextTick()`, and `queueMicrotask()`**.
+- Microtasks are given higher priority and are executed **immediately after the current phase completes**, before the event loop moves to the next phase.
+
+### **Visual Summary of the Event Loop Phases**
+
+1. Timers → 2. Pending Callbacks → 3. Idle/Prepare → 4. Poll → 5. Check (setImmediate) → 6. Close Callbacks → **Microtasks Queue**
+
+### **Order of Execution Example**
+
+Consider this example:
+
+```javascript
+setTimeout(() => console.log("Timeout"), 0);
+setImmediate(() => console.log("Immediate"));
+Promise.resolve().then(() => console.log("Promise"));
+process.nextTick(() => console.log("NextTick"));
+```
+
+**Output:**
+```
+NextTick
+Promise
+Immediate
+Timeout
+```
+
+**Explanation:**
+1. `process.nextTick()` executes before anything else.
+2. Microtasks like `Promise` callbacks run after the current phase.
+3. `setImmediate()` callbacks run before `setTimeout()` callbacks if both are scheduled without delay.
+
+### Key Takeaways:
+- **Microtasks** have the highest priority.
+- `setImmediate()` is processed in the **check phase**, after I/O.
+- `setTimeout()` and `setInterval()` are processed in the **timers phase**.
+- The event loop efficiently manages async tasks, avoiding blocking the main thread.
+
+Understanding these phases helps in writing efficient and non-blocking JavaScript code, especially in Node.js environments.