Javascript递归函数不返回值？

Question

我正在解决一个代码战问题，我很确定我已经成功了：

function digital_root(n) {
    // ...
    n = n.toString();
    if (n.length === 1) {
        return parseInt(n);
    } else {
        let count = 0;
        for (let i = 0; i < n.length; i++) {
            //console.log(parseInt(n[i]))
            count += parseInt(n[i]);
        }
        //console.log(count);
        digital_root(count);
    }
}

console.log(digital_root(942));

基本上它应该找到一个“数字根”：

数字根是数字中所有数字的递归和。 给定n，取n的位数之和。如果该值有两个 位数，以这种方式继续减少，直到一个位数的数字 产生。这仅适用于自然数。

所以我实际上在最后得到了正确的答案，但无论出于何种原因，if 语句（我正在观察调试器运行并且它确实输入了该语句，它会说返回值是正确的值。

但随后它跳出if 语句并尝试从digital_root 主函数返回？

这是为什么？当它遇到if 语句时，它不应该摆脱这种情况吗？我很困惑为什么它试图跳出if 语句然后尝试从digital_root 不返回任何内容，所以返回值最终是未定义的？

Answer 1

代码审查

我的备注是下面的代码cmets

// javascript generally uses camelCase for function names
// so this should be digitalRoot, not digital_root
function digital_root(n) {
    // variable reassignment is generally frowned upon
    // it's somewhat silly to convert a number to a string if you're just going to parse it again
    n = n.toString();
    if (n.length === 1) {
        // you should always specify a radix when using parseInt
        return parseInt(n);
    } else {
        let count = 0;
        for (let i = 0; i < n.length; i++) {
            //console.log(parseInt(n[i]))
            count += parseInt(n[i]);
        }
        // why are you looping above but then using recursion here?
        // missing return keyword below
        digital_root(count);
    }
}

console.log(digital_root(942));

简单的递归解决方案

考虑到其中一些事情，让我们简化digitalRoot...

const digitalRoot = n =>
  n < 10 ? n : digitalRoot(n % 10 + digitalRoot((n - n % 10) / 10))
  
console.log(digitalRoot(123))         //          => 6
console.log(digitalRoot(1234))        //       10 => 1
console.log(digitalRoot(12345))       //       15 => 6
console.log(digitalRoot(123456))      //       21 => 3
console.log(digitalRoot(99999999999)) // 99 => 18 => 9

---

使用减少

数字根是数字中所有数字的递归和。给定n，取n的位数之和。如果该值有两位数，则继续以这种方式减少，直到产生一位数。这仅适用于自然数。

如果您打算使用实际的归约函数，我将在此处向您展示如何做到这一点。首先，我们将创建一个toDigits 函数，它接受一个整数，并返回一个包含其数字的数组。然后，我们将通过使用用空总和 0 初始化的 add 减速器减少这些数字来实现 digitalRoot

// toDigits :: Int -> [Int]
const toDigits = n =>
  n === 0 ? [] :  [...toDigits((n - n % 10) / 10), n % 10]

// add :: (Number, Number) -> Number
const add = (x,y) => x + y

// digitalRoot :: Int -> Int
const digitalRoot = n =>
  n < 10 ? n : digitalRoot(toDigits(n).reduce(add, 0))
      
console.log(digitalRoot(123))         //          => 6
console.log(digitalRoot(1234))        //       10 => 1
console.log(digitalRoot(12345))       //       15 => 6
console.log(digitalRoot(123456))      //       21 => 3
console.log(digitalRoot(99999999999)) // 99 => 18 => 9

Answer 2

else 内没有返回任何内容。应该是：

return digital_root(count);
^^^^^^^

为什么？

digital_root 应该返回一些东西。如果我们用一位数字调用它，则执行 if 部分，并且由于我们从该 if 返回，所以一切正常。但是，如果我们提供一个由多于一位数字组成的数字，那么 else 部分就会被执行。现在，在else 部分，我们计算count 的digital_root，但我们不使用那个值（应该返回的值）。上面这行代码可以拆分成两行代码，便于理解：

var result = digital_root(count); // get the digital root of count (may or may not call digital_root while calculating it, it's not owr concern)
return result;                    // return the result of that so it can be used from the caller of digital_root

Answer 3

它是一个递归函数，代码应该有点像这样

function digital_root(n) {
    // ...
    n=n.toString();
    if(n.length === 1){
         return parseInt(n);
    }
    else
    {
    let count = 0;
    for(let i = 0; i<n.length;i++)
    {
    //console.log(parseInt(n[i]))
    count+=parseInt(n[i]);
    }
   //console.log(count);
   return digital_root(count);
   }
}

你应该返回相同的函数，而不是仅仅调用它来获得正确的调用堆栈