JavaScript Promises: Handling Successful and Failed Asynchronous Operations

const pizzaOrder = orderPizza();
// 🧾 a promise — not the pizza itself!
console.log(pizzaOrder);
// Promise { <pending> } — just the receipt

const data = fetch(url);
// 🧾 receipt, NOT data!console.log(data);                  // Promise { <pending> } 🤔

const myPromise = new Promise((resolve, reject) => {
  const success = true;
  setTimeout(() => {
    if (success) {
      resolve("🎉 It worked!");
      // → fulfilled with this value    } else {      reject(new Error("💥 It failed")); // → rejected with this error    }  }, 1000);});

myPromise .then(result => {
  console.log("✅ Success:", result);
  // runs on fulfilled
}) .catch (error => {
  console.log("❌ Failed:", error.message);
  // runs on rejected
}) .finally(() => {
  console.log("🏁 Done either way");
  // ALWAYS runs
});

function flipCoin() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      Math.random() > 0.5 ? resolve("Heads! 🪙") : reject(new Error("Tails — you lose! 😅"));
    }, 500);
  });
}flipCoin() .then(result => console.log("Won:", result)) .catch (error => console.log("Lost:", error.message)) .finally(() => console.log("— game over —"));
// Run it a few times — sometimes:// Won: Heads! 🪙// — game over —// sometimes:// Lost: Tails — you lose! 😅// — game over —

const myPromise = new Promise((resolve, reject) => {
  // ① The "executor" function runs IMMEDIATELY
  // ② Do your async work here (timer, fetch, file read…)
  // ③ Call ONE of these:  //    resolve(value)  → promise fulfills with value ✅  //    reject(error)   → promise rejects with error ❌});

function waitAndGreet(name, seconds) {
  return new Promise((resolve, reject) => {
    if (!name) {
      reject(new Error("Name is required! 🚫"));
      return;
    } setTimeout(() => {
      resolve(`Hello, ${name}! 👋 (after ${seconds}s)`);
    }, seconds * 1000);
  });
}waitAndGreet("Priya", 2) .then(message => console.log(message));
// Hello, Priya! 👋 (after 2s)
waitAndGreet("", 1) .catch (error => console.log(error.message));
// Name is required! 🚫

Promise.resolve(42).then(v => console.log(v));
// 42 — instantly fulfilledPromise.reject("nope").catch (e => console.log(e));    // nope — instantly rejected

fetch("https://jsonplaceholder.typicode.com/users/1") .then(response => response.json()) // step 1 → returns a promise!  .then(user => {
console.log("User:", user.name);
// step 2 receives parsed data    return user.address.city;                 // pass something down…
}) .then(city => {
  console.log("City:", city);
  // step 3 receives it ✅
}) .catch (error => {
  console.log("Any step failed:", error);
  // 🛡️ ONE catch handles ALL steps
});

User: Leanne GrahamCity: Gwenborough

// The chain short-circuits on failure:Promise.resolve(5)  .then(n => {
console.log(n);
return n * 2;
}) // 5  .then(n => {
console.log(n);
throw new Error("💥");
}) // 10 → then explodes  .then(n => console.log("never runs 😢"))          // skipped!  .catch (err => console.log("Caught:", err.message)); // Caught: 💥

// 😱 ERA 1 — Callback hell (the pyramid of doom):getUser(1, function(user) {  getOrders(user.id, function(orders) {    getDetails(orders[0], function(details) {      console.log(details);          // 4 levels deep, error handling everywhere    });  });});
// 😌 ERA 2 — Promise chains (flat!):getUser(1)  .then(user => getOrders(user.id))  .then(orders => getDetails(orders[0]))  .then(details => console.log(details))  .catch (error => console.log(error));
// ✨ ERA 3 — async/await (Lesson 24 — reads like sync code):async function show() {  try {    const user = await getUser(1);    const orders = await getOrders(user.id);    const details = await getDetails(orders[0]);    console.log(details);  } catch (error) {    console.log(error);  }}

const p1 = fetch("/user");
const p2 = fetch("/posts");
const p3 = fetch("/comments");

// 🏁 Race example — timeout pattern:const dataPromise = fetch("/api/data");const timeout = new Promise((_, reject) =>  setTimeout(() => reject(new Error("Too slow! ⏰")), 3000));
Promise.race([dataPromise, timeout]) .then(res => console.log("Got data in time ✅")) .catch (err => console.log(err.message));
// "Too slow! ⏰" if > 3s

// 🧺 allSettled — everyone's report card:Promise.allSettled([p1, p2, p3]).then(results => {
results.forEach(r => {
  console.log(r.status);
  // "fulfilled" or "rejected" — each one
});
});

// 📦 Order Pipeline — a full promise chain with failure handlingfunction checkInventory(item) {  return new Promise((resolve, reject) => {    setTimeout(() => {      item === "laptop"        ? resolve({ item, price: 55000 })        : reject(new Error(`"${item}" is out of stock 📭`));    }, 500);  });}
function processPayment(order) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      order.price <= 60000 ? resolve( {
        ...order, paid: true
      }) // spread from Lesson 14! ✨        : reject(new Error("Payment declined 💳"));    }, 500);  });}
      function shipOrder(order) {
        return new Promise(resolve => {
          setTimeout(() => {
            resolve(`🚚 ${order.item} shipped! Payment confirmed: ₹${order.price}`);
          }, 500);
        });
      }// The pipeline — each stage feeds the next:checkInventory("laptop")  .then(order => processPayment(order))  .then(paidOrder => shipOrder(paidOrder))  .then(confirmation => console.log(confirmation))  .catch (error => console.log("❌ Order failed:", error.message))  .finally(() => console.log("🏁 Pipeline finished"));
      // Try it with checkInventory("toaster") — watch the catch handle it!

🚚 laptop shipped! Payment confirmed: ₹55000🏁 Pipeline finished

❌ Order failed: "toaster" is out of stock 📭🏁 Pipeline finished