Javascript 如何正确实现递归算法？

我试图在codewars网站上解决这个算法。作为一名初学者，我很难实现各种编程技术，并且缺乏基本的编程概念，如范围界定、提升等。无论如何，我决心解决这个问题

说明书上说：

编写一个名为persistence的函数，该函数接受一个正参数num并返回其乘法persistence，即必须将num中的数字相乘直到达到一个位数的次数。

现在我只想得到这个结果

3*9=27，2*7=14，1*4=4

。我知道我错过了一些东西，请给我一些有价值的建议

我的代码如下所示：

function persistence(num) {
    var total = 1;
    var step = 0;
    var number = multiple(num);
    while (step < 3) {
        for (var i = 0; i < number.length; i++) {
            total *= splitNumbers[i];
        }
        multiple(number);
        step += 1;
    }
}

function multiple(num) {
    var splitNumbers = num.toString().split('');
    var a = splitNumbers[0];
    var b = splitNumbers[1];
    return a * b;
}
persistence(39);

函数持久性（num）{
var总计=1；
var阶跃=0；
变量编号=多个（num）；
while（步骤<3）{
对于（变量i=0；i

奇怪的是，在第二个函数中，您计算一个乘积（忽略除前两个之外的所有数字），然后在主函数中，您将其视为一个字符串（不是字符串），并再次开始将这些数字相乘。这不是递归的原理：您应该只执行一次操作，然后执行递归调用

以下是一个解决方案：

函数持久性（num）{
var digits=getDigits（num）；
如果（digits.length==1）返回0；//数字只有1位，那么我们就完成了
var product=getProduct（数字）；
return 1+persistence（product）；//我们执行了一个转换，现在递归
}
函数getDigits（num）{
return num.toString（）.split（“”）.map（Number）；//将字符转换为数字
}
函数getProduct（nums）{
返回nums.reduce（函数（a，b）{//从数组中获得1个结果的好方法
返回a*b；
}, 1);
}
console.log（持久性（39））奇怪的是，在第二个函数中，你计算一个乘积（忽略除前两个之外的所有数字），然后在主函数中，你将其视为一个字符串（它不是），并再次开始将这些数字相乘。这不是递归的原理：您应该只执行一次操作，然后执行递归调用

以下是一个解决方案：


函数持久性（num）{
var digits=getDigits（num）；
如果（digits.length==1）返回0；//数字只有1位，那么我们就完成了
var product=getProduct（数字）；
return 1+persistence（product）；//我们执行了一个转换，现在递归
}
函数getDigits（num）{
return num.toString（）.split（“”）.map（Number）；//将字符转换为数字
}
函数getProduct（nums）{
返回nums.reduce（函数（a，b）{//从数组中获得1个结果的好方法
返回a*b；
}, 1);
}
console.log（持久性（39））从一个函数开始，如果满足条件，该函数将返回结果（只剩下一位数字）。如果没有，则返回下一次迭代的结果，传递要跟踪的状态（当前计数）。也许是这样的：

function persistence(num) {
    var total = 1;
    var step = 0;
    var number = multiple(num);
    while (step < 3) {
        for (var i = 0; i < number.length; i++) {
            total *= splitNumbers[i];
        }
        multiple(number);
        step += 1;
    }
}

function multiple(num) {
    var splitNumbers = num.toString().split('');
    var a = splitNumbers[0];
    var b = splitNumbers[1];
    return a * b;
}
persistence(39);


函数持久性（num，opt_计数）{
num=parseInt（num，10）；//假设我们只处理int。
var count=opt_count | | 0；//count是可选的，所以请确保我们初始化。
如果（数值>9）{
var digits=String（num）.split（“”）；//将数字拆分为字符串。
num=digits.shift（）；
做{
num*=digits.shift（）；//注意，乘法将自动回滚。
}while（位数、长度）；
count++；//增加我们的计数
}
if（num<10）返回count；//如果小于10，则返回计数。
返回持久性（num，count）；//使用当前状态递归。
}
console.log（'39:'+persistence（39））；//3.
console.log（'999:'+持久性（999））；//4.
console.log（'4:'+持久性（4））；//0
从一个函数开始，如果满足条件，该函数将返回结果（只剩下一位数字）。如果没有，则返回下一次迭代的结果，传递要跟踪的状态（当前计数）。也许是这样的：

function persistence(num) {
    var total = 1;
    var step = 0;
    var number = multiple(num);
    while (step < 3) {
        for (var i = 0; i < number.length; i++) {
            total *= splitNumbers[i];
        }
        multiple(number);
        step += 1;
    }
}

function multiple(num) {
    var splitNumbers = num.toString().split('');
    var a = splitNumbers[0];
    var b = splitNumbers[1];
    return a * b;
}
persistence(39);


函数持久性（num，opt_计数）{
num=parseInt（num，10）；//假设我们只处理int。
var count=opt_count | | 0；//count是可选的，所以请确保我们初始化。
如果（数值>9）{
var digits=String（num）.split（“”）；//将数字拆分为字符串。
num=digits.shift（）；
做{
num*=digits.shift（）；//注意，乘法将自动回滚。
}while（位数、长度）；
count++；//增加我们的计数
}
if（num<10）返回count；//如果小于10，则返回计数。
返回持久性（num，count）；//使用当前状态递归。
}
console.log（'39:'+persistence（39））；//3.
console.log（'999:'+持久性（999））；//4.
console.log（'4:'+持久性（4））；//0
您的代码中有几个问题：


函数持久性（num）{
var总计=1；
var阶跃=0；
//这将返回一个数字
变量编号=多个（num）；
while（步骤<3）{
//这里number是一个数字，它没有长度属性，所以
//循环永远不会运行。但是，一旦你解决了这个问题。。。
对于（变量i=0；i