为何要使用Promise？同步代码对比下的技术疑问

Great question! The key misunderstanding here is that you're comparing Promises to regular functions using a synchronous operation—a task that runs immediately and returns a result right away. Promises aren't built for these simple sync tasks; they exist to solve pain points with asynchronous operations (tasks that take time to complete, like fetching data from a server, reading a file, or waiting for a timer).

Let's rewrite your examples to reflect real-world async work, and you'll see the difference:

Example 1: Promise for Asynchronous Work #

Suppose cleaning your room takes 2 seconds (simulating an async task like waiting for a database response):

let cleanedUpMyRoom = new Promise(function(resolve, reject) {
  // Simulate a 2-second async task (e.g., actually cleaning the room)
  setTimeout(() => {
    const didFinishCleaning = true;
    if (didFinishCleaning) {
      resolve("Room is spotless!");
    } else {
      reject(new Error("Got distracted and didn't clean..."));
    }
  }, 2000);
});

// Handle the result WHEN the async task finishes
cleanedUpMyRoom
  .then(result => console.log(result)) // Runs after 2 seconds: "Room is spotless!"
  .catch(error => console.error(error.message)); // Catches failures if they happen

Example 2: Regular Function Can't Handle This Async Task #

Try doing the same with a regular function—you'll hit a wall immediately:

function cleanedUpMyRoom() {
  setTimeout(() => {
    const didFinishCleaning = true;
    return didFinishCleaning; // This return value is useless!
  }, 2000);
}

const result = cleanedUpMyRoom();
console.log(result); // Prints "undefined" RIGHT AWAY, before the 2 seconds are up

Regular functions can't "wait" for async tasks to finish before returning a value. By the time the setTimeout runs, the function has already finished executing and returned nothing.

Why Promises Matter #

Here are the core benefits that make Promises essential for async code:

• Reliable result handling: Promises let you attach logic that runs only after the async task succeeds or fails, instead of guessing when it might finish.
• Avoid "callback hell": You can chain .then() calls to handle sequential async tasks (e.g., clean room → go grocery shopping → cook dinner) without nesting messy callbacks.
• Unified error handling: A single .catch() at the end of a Promise chain can catch errors from any step in the async process, making error management far cleaner than scattered error checks in callbacks.

In your original synchronous example, a regular function is absolutely better—it's simpler and more direct. But as soon as you're dealing with tasks that don't finish immediately, Promises become the standard tool to keep your code manageable and reliable.

内容的提问来源于stack exchange，提问作者Reza Saadati