# Promise and Illustration with Example:
- **Promise**:
  - A promise is an object representing the eventual completion or failure of an asynchronous operation.
  - It allows handling asynchronous operations in a more manageable and readable way, avoiding callback hell.
- **Example**:
  ```javascript
  const myPromise = new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve("Promise resolved!"); // Success
      // reject(new Error("Promise rejected!")); // Failure
    }, 2000);
  });

  myPromise
    .then((result) => console.log(result)) // On success
    .catch((error) => console.error(error)); // On failure
  ```

# Closure and Lexical Environment with Working Example:
- **Closure**:
  - Closure is the combination of a function bundled together with references to its surrounding state (lexical environment).
  - It allows a function to retain access to the variables of its containing scope even after the outer function has finished executing.
- **Illustration**:
  ```javascript
  function outerFunction() {
    const outerVariable = "I'm from outer function";
    function innerFunction() {
      console.log(outerVariable); // Inner function has access to outerVariable
    }
    return innerFunction;
  }
  const closureExample = outerFunction();
  closureExample(); // Outputs: "I'm from outer function"
  ```

# Node.js, Event Loop, Event Queues, and Types:
- **Node.js**:
  - Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine. It allows executing JavaScript code outside the browser, such as on the server.
- **Event Loop**:
  - Event Loop is a core mechanism in Node.js responsible for handling asynchronous operations.
  - It continuously checks the event queue for pending events and executes them one by one.
- **Event Queues**:
  - Node.js has several event queues:
    1. **Timers Queue**: Contains callbacks from `setTimeout()` and `setInterval()`.
    2. **I/O Queue**: Holds I/O-related callbacks like file system operations, network requests, etc.
    3. **Microtask Queue (Job Queue)**: Contains promises' `then()` and `catch()` callbacks, `process.nextTick()`, and `queueMicrotask()`.
- **Types of Event Queue**:
  - **Macrotasks**: Represented by the Timers and I/O queues.
  - **Microtasks**: Represented by the Microtask queue.
  - Microtasks have higher priority and are executed before macrotasks in each iteration of the event loop.