Promise递归实现困惑求解：如何正确编写递归Promise？

Hey there! I totally get where you're coming from—recursive Promises can feel like a head-scratcher even after digging through multiple resources. Let's break this down simply so you can see how to get your Promise to resolve properly every time.

Core Rules for Recursive Promises #

Before we dive into examples, let's nail down the non-negotiables that make recursive Promises work:

• Always return a Promise from your recursive function. If you skip this, the Promise chain breaks, and you'll never get the resolved value you're waiting for.
• Define a clear termination condition. This is the point where your recursion stops—here, you'll return a resolved (or rejected) Promise to end the chain.
• Resolve with the recursive call. When you make your recursive call inside a Promise, pass its result to resolve() so the current Promise waits for the recursive step to finish.

A Working Example: Recursive Countdown #

Let's use a simple countdown to see these rules in action. This function will count down from a number, then resolve when it hits 0:

function countDown(num) {
  // Termination condition: stop recursion and resolve
  if (num <= 0) {
    return Promise.resolve("🎉 Countdown complete!");
  }

  console.log(`Current count: ${num}`);
  // Return a new Promise for each recursive step
  return new Promise((resolve) => {
    // Simulate an async operation (like an API call or timeout)
    setTimeout(() => {
      // Resolve with the recursive call—this links the Promises together
      resolve(countDown(num - 1));
    }, 1000);
  });
}

// Use the recursive Promise
countDown(3)
  .then(message => console.log(message))
  .catch(error => console.error(`Oops: ${error}`));

What's happening here?

1. When num reaches 0, we immediately return a resolved Promise—this is our "escape hatch" from recursion.
2. For every number above 0, we create a new Promise that waits 1 second, then calls countDown(num-1) and resolves with that result. Since countDown returns a Promise, this ensures the chain waits for the next step to finish.
3. The entire function always returns a Promise, so .then() knows exactly when the entire recursive process is done.

Common Mistakes to Avoid #

Let's look at a broken version of the same function to see what trips people up:

// ❌ Broken recursive Promise
function badCountDown(num) {
  if (num <= 0) {
    return Promise.resolve("Done");
  }
  console.log(num);
  // Forgot to return the Promise!
  new Promise((resolve) => {
    setTimeout(() => {
      // Forgot to resolve with the recursive call!
      badCountDown(num - 1);
    }, 1000);
  });
}

• This function doesn't return the outer Promise, so calling badCountDown(3) just returns undefined instead of a Promise.
• Even if we returned the Promise, we're not resolving it with the recursive call—so the Promise would never resolve, leaving it stuck in a pending state forever.

Tailoring This to Your Example #

Since you mentioned you wrote a simple test example, chances are one of these issues is tripping you up:

• You're not returning the Promise from your recursive function
• Your termination condition isn't returning a resolved Promise
• You're not linking the recursive call to the current Promise's resolve()

If you share your specific code, we can troubleshoot it directly, but following the core rules above should get your Promise resolving as expected.

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