🧠 What is a Promise?

A Promise in JavaScript represents a value that will be available now, later, or never. It can be in one of three states:

• Pending → still waiting
• Fulfilled → operation completed successfully
• Rejected → operation failed

---

🧩 1. Promise.all()

✅ Definition

• Waits for all promises to resolve.
• If any promise rejects, the entire thing fails immediately.

🧾 Syntax

Promise.all([promise1, promise2, promise3])
  .then(results => console.log(results))
  .catch(error => console.error(error));

🧰 Example

const p1 = Promise.resolve('User data');
const p2 = Promise.resolve('Profile picture');
const p3 = Promise.resolve('Friend list');

Promise.all([p1, p2, p3])
  .then(results => console.log(results)) // ['User data', 'Profile picture', 'Friend list']
  .catch(err => console.error(err));

🌍 Real-life Analogy

You order three food items (pizza, drink, dessert). You'll start eating only when all three have arrived. If one item is missing or canceled, you cancel the meal (the whole promise chain fails).

---

🧩 2. Promise.allSettled()

✅ Definition

• Waits for all promises to either resolve or reject.

• Always returns an array of results with each having:

  • { status: 'fulfilled', value: ... }
  • { status: 'rejected', reason: ... }

🧾 Syntax

Promise.allSettled([promise1, promise2, promise3])
  .then(results => console.log(results));

🧰 Example

const p1 = Promise.resolve('Success');
const p2 = Promise.reject('Error occurred');
const p3 = Promise.resolve('Another success');

Promise.allSettled([p1, p2, p3])
  .then(results => console.log(results));

Output:

[
  { status: 'fulfilled', value: 'Success' },
  { status: 'rejected', reason: 'Error occurred' },
  { status: 'fulfilled', value: 'Another success' }
]

🌍 Real-life Analogy

You send out 3 job applications. You wait until you get a response from all companies — whether accepted or rejected. You note down each result (not just the successes).

---

🧩 3. Promise.race()

✅ Definition

• Returns the result of the first promise that settles (either resolve or reject).
• The rest are ignored.

🧾 Syntax

Promise.race([promise1, promise2, promise3])
  .then(result => console.log(result))
  .catch(error => console.error(error));

🧰 Example

const fast = new Promise(resolve => setTimeout(() => resolve('Fast response'), 100));
const slow = new Promise(resolve => setTimeout(() => resolve('Slow response'), 300));

Promise.race([fast, slow])
  .then(result => console.log(result)); // 'Fast response'

🌍 Real-life Analogy

You're waiting for two delivery services to bring the same item (Amazon & Flipkart). Whichever one delivers first, you accept it and cancel the other.

---

🧩 4. Promise.any()

✅ Definition

• Returns the first fulfilled (successful) promise.
• Ignores rejected ones.
• If all reject, it throws an AggregateError.

🧾 Syntax

Promise.any([promise1, promise2, promise3])
  .then(result => console.log(result))
  .catch(error => console.error(error));

🧰 Example

const p1 = Promise.reject('Server 1 failed');
const p2 = Promise.reject('Server 2 failed');
const p3 = Promise.resolve('Server 3 responded');

Promise.any([p1, p2, p3])
  .then(result => console.log(result)) // 'Server 3 responded'
  .catch(error => console.error(error));

🌍 Real-life Analogy

You send the same request to 3 backup servers. You don't care which one responds — as soon as one gives a successful response, you use it. If all fail, you show an error.

---

📊 Summary Table

🧠 What is a Closure?

A closure is a function that retains access to its lexical scope, even when the function is executed outside that scope. This allows the function to remember and access variables from its outer scope even after the outer function has finished execution.

---

🎯 Why Use Closures?

Closures are useful for:

• Data encapsulation → creating private variables
• Maintaining state → in functional programming style
• Function factories → creating specialized functions

---

🏦 Bank Example with Closure

Let's create a bank account using closures. This example demonstrates how closures help encapsulate account balance information securely.

🧾 Code Example

function createAccount(initialBalance) {
  let balance = initialBalance;
  return function (action, amount) {
    if (action === 'deposit') {
      balance += amount;
    } else if (action === 'withdraw') {
      if (balance >= amount) {
        balance -= amount;
      } else {
        console.log('Insufficient funds');
      }
    } else if (action === 'checkBalance') {
      console.log('Balance:', balance);
    }
  };
}

// Creating a bank account
const myAccount = createAccount(1000);
myAccount('deposit', 500);  // Depositing 500
myAccount('checkBalance'); // Output: Balance: 1500
myAccount('withdraw', 200); // Withdrawing 200
myAccount('checkBalance'); // Output: Balance: 1300

---

🔍 Step-by-Step Explanation

✅ Outer Function (createAccount)

• Accepts an initialBalance argument
• Initializes a balance variable to store the account balance
• Returns an inner function

✅ Inner Function

• Takes two arguments: action and amount
• Actions: 'deposit', 'withdraw', or 'checkBalance'
• Has access to the balance variable through closure
• Retains access even after outer function finishes execution

✅ Action Handling

• deposit: Increases balance by specified amount
• withdraw: Decreases balance if sufficient funds, otherwise logs 'Insufficient funds'
• checkBalance: Logs current balance to console

✅ Reusability

• Create multiple bank accounts with isolated balances
• Each account operates independently
• Perfect for managing separate user accounts

---

🌍 Real-life Analogy

Think of a safety deposit box at a bank:

• The box (outer function) contains your valuables (balance)
• You get a key (inner function) to access the box
• Even if you leave the bank (outer function ends), your key still works (closure maintains access)
• Each box has its own unique contents (separate balance per account)