函数内循环重叠问题及Code Wars乘法持久性代码完善求助

Hey there! Let's get your multiplication persistence code working as intended. Right now, your code only runs one round of digit multiplication—we need to add logic that repeats the process until we land on a single-digit number. Also, that "loop overlap" issue you mentioned is almost certainly tied to un-declared variables causing scope conflicts. Let's break this down step by step.

First, Diagnose the Existing Problems #

1. Single-Round Calculation: Your code computes the product of digits once, but doesn't check if the result is still a multi-digit number (so it stops at 27 for input 39 instead of continuing all the way to 4).
2. Unscoped Loop Variable: You’re using i in your for loop without declaring it with let, const, or var. This makes i a global variable, which can cause conflicts if you run the function multiple times or add nested loops later—this is the root of your loop overlap problem.

Solution 1: Iterative Approach (Most Straightforward) #

We’ll use a while loop to keep multiplying digits until we get a single-digit result. We’ll also fix the variable scope issue by properly declaring our loop variable.

function persistence(num) {
  // Edge case: if num is already a single digit, return it right away
  if (num < 10) {
    return num;
  }
  
  let currentNum = num;
  // Keep looping until we have a single-digit number
  while (currentNum >= 10) {
    // Convert number to an array of individual digits
    const digits = currentNum.toString().split("").map(Number);
    let product = 1;
    // Use let to declare i (block-scoped, no global leaks)
    for (let i = 0; i < digits.length; i++) {
      product *= digits[i];
    }
    currentNum = product;
  }
  
  return currentNum;
}

// Test it out:
console.log(persistence(39)); // Logs 4 (correct!)
console.log(persistence(999)); // Logs 2 (9*9*9=729 → 7*2*9=126 → 1*2*6=12 → 1*2=2)

Solution 2: Recursive Approach (Concise Alternative) #

If you prefer a more elegant recursive style, this version works great—since the problem is inherently repetitive, recursion fits naturally:

function persistence(num) {
  // Termination condition: stop when we have a single digit
  if (num < 10) return num;
  // Calculate product of digits, then recurse with that product
  const product = num.toString().split("").map(Number).reduce((acc, digit) => acc * digit, 1);
  return persistence(product);
}

// Test:
console.log(persistence(39)); // 4

Fixing the Loop Overlap Issue #

The simple fix here was replacing the un-declared i with let i in the for loop. let creates a block-scoped variable, meaning each loop iteration has its own i that doesn’t leak into the global scope or interfere with other loops. Using var would also work (but has function scope instead of block scope), but let is cleaner and avoids unexpected behavior.

How It Works for Input 39 #

1. First pass: 3 * 9 = 27 (27 is multi-digit, so we loop again)
2. Second pass: 2 * 7 = 14 (still multi-digit, loop again)
3. Third pass: 1 * 4 = 4 (single-digit, exit loop and return 4)

That’s exactly the behavior the project requires!

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