Javascript 持久性Bugger-帮助清除某些0

我需要一些关于创建一个函数的帮助，这个函数只接受整数，然后互相相乘，直到只得到一个数字。答案是《泰晤士报》：

示例：功能（39）-答案：3 因为3*9=27，2*7=14，1*4=4，4只有一个数字

示例2：功能（999）-答案：4 因为9*9*9=729，7*2*9=126，1*2*6=12，最后1*2=2

示例3：功能（4）-答案：0 因为它已经有一个数字了

因此，在多次失败后，我试图找出解决方法，最后编写了以下代码：

function persistence(num) {
   
  let div = parseInt(num.toString().split(""));
  let t = 0;
  
  if(Number.isInteger(num) == true){
    
    if(div.length > 1){
      
      for(let i=0; i<div.length; i++){
        
        div = div.reduce((acc,number) => acc * number);
        t += 1;
        div = parseInt(div.toString().split(""))
        
        if(div.length == 1){ 
          return t } else {continue}
        
      } return t
              
    } else { return t }
       
  } else { return false }
  
  }

console.log(persistence(39),3);
console.log(persistence(4),0);
console.log(persistence(25),2);
console.log(persistence(999),4);

/*
output: 0 3
        0 0
        0 2
        0 4
*/
  

console.log（）

可以接受许多参数

例如，

console.log（“A”，“B”）

将输出

“A”“B”

所以所有这些零都是

持久性

函数的输出。。。另一个数字就是您作为第二个参数提供的数字

所以我想你还是要“坚持”。。。因为函数总是返回

0

---

提示：您正在进行此比较：

div.length>1

但是

div

不是数组。。。这是一个数字，被严格化，被分割。。。最后解析为整数

)()祝你好运

---

请注意，您尝试的计算称为。所以在学习JS的同时。。。历史专家组不会伤害你的。。。这可能是求职面试中的一句好台词

---

我最好的提示 使用函数中的控制台日志来帮助您对其进行除根。这是您的未更改代码，其中只有几个代码

函数持久性（num）{
设div=parseInt（num.toString（）.split（“”）；
设t=0；
console.log（“div.length”，div.length）
if（Number.isInteger（num）==true）{
如果（分段长度>1）{
for（设i=0；i附件*编号）；
t+=1；
div=parseInt（div.toString（）.split（“”）；
如果（div.length==1）{
控制台日志（“返回#1”）
返回t；
}否则{
继续；
}
}
控制台日志（“返回#2”）
返回t；
}否则{
console.log（“return#3”）
返回t；
}
}否则{
console.log（“return#4”）
返回false；
}
}
console.log（持久性（39），3）；
console.log（持久性（4），0）；
console.log（持久性（25），2）；
console.log（持久性（999），4）您在这里遇到了一些问题：

let div=parseInt（num.toString（）.split（“”）您正在将一个数组强制转换为一个数字，假设您正在尝试将单个数字提取到一个数组中，您已经接近了，但不需要使用parseInt

function persistence(input, count = 0) {
    var output = input;
    while (output >= 10) {
        var numbers = (output + '').split('');
        output = numbers.reduce((acc, next) {
            return Number(next) * acc;
        }, 1);
        count += 1;
    }
​
    return count;
};

对于需要不断检查的内容，最好使用函数反复检查条件，这样就不需要任何子循环

在这里，您可以利用少数es6功能来实现相同的结果！现在跳入es6可能有点太远了，但这里有一个使用递归的示例

function recursive(input, count = 0) {
    // convert the number into an array for each number
    const numbers = `${input}`.split('').map(n => Number(n));
    // calculate the total of the values
    const total = numbers.reduce((acc, next) => next * acc, 1);
    // if there's more than 1 number left, total them up and send them back through
    return numbers.length > 1 ? recursive(total, count += 1) : count;
};

如果（长度为1）返回0？请编辑您的标题，使其对未来用户有意义谢谢您在这里看到@epascarello返回t，并用计数更新？否！Shannon，
t
从未“更新”请看我的“最佳提示”。我没有看到，我只是建议它…持久性！=递归的，它是递归的，OP通过使用这个函数肯定学到了很多东西。。。在没有相关解释的情况下给出专业解决方案并不是一个很好的“服务”。我还没有完成我的回答@LouySpatriceBesetteok。。。但考虑到OP被console.log打印的内容弄错了。。。我不认为“最新”的ES6功能是他应该首先学习的。非常感谢Shannon！我不知道我可以创建一个数组，这样做
var numbers=（output+“”）。split（“”）
允许我在其中只包含数字，同时我也感谢您向我展示了一些es6功能，是的，它对我来说有点高级，但仍然很有用。我从你们身上学到了很多新东西@Louyspatricebesette@Shannon Hochkins天哪，你是认真的吗？？我现在想死，哈哈，我真的以为我可以解决，尽管有那些零，但这让我很开心，哈哈哈。。。非常感谢你给我你的建议，并告诉我我正在尝试做卡普雷卡的例行工作！学习就是犯错误。不要每次都“死”！！！哈哈。关于这个数学挑战：当数字不止一个的时候，你在乘法。因此，关键在于能够
拆分
它们，并检查数组的
长度
<代码>而
…；）好的，明白了！我要再试一次>：）再次谢谢你！
function recursive(input, count = 0) {
    // convert the number into an array for each number
    const numbers = `${input}`.split('').map(n => Number(n));
    // calculate the total of the values
    const total = numbers.reduce((acc, next) => next * acc, 1);
    // if there's more than 1 number left, total them up and send them back through
    return numbers.length > 1 ? recursive(total, count += 1) : count;
};

console.log(recursive(39),3);
console.log(recursive(4),0);
console.log(recursive(25),2);
console.log(recursive(999),4);

function persistance (num) {
    if (typeof num != 'number') throw 'isnt a number'
  let persist = 0
  while(num >= 10) {
    let size = '' + num
    size = size.length
    // Get all number of num
    const array = new Array(size).fill(0).map((x, i) => {
        const a = num / Math.pow(10, i)
      const b = parseInt(a, 10)
      return b % 10
    })
    console.log('here', array)
    // actualiser num
    num = array.reduce((acc, current) => acc * current, 1)
    persist++
  }
  return persist
}
console.log(persistance(39))
console.log(persistance(999))