JavaScript错误：函数返回NaN，即使函数返回“typeof”；“数字”；_Javascript_Ecmascript 6_Ecmascript 5

JavaScript错误：函数返回NaN，即使函数返回“typeof”；“数字”；

javascript ecmascript-6

JavaScript错误：函数返回NaN，即使函数返回“typeof”；“数字”；,javascript,ecmascript-6,ecmascript-5,Javascript,Ecmascript 6,Ecmascript 5,我想找出一个给定数的排列所产生的最大数如果给定的数字是123，则由其排列产生的最大数字是321 编辑通过改变，我取得了一些进展 if (str.length === 0) return ""; if (str.length === 1) return str; 到但是，仍然存在一个问题：函数返回一个字符串。事实上，数组成员是字符串而不是数字函数findPerms（num）{ var str=num.toString（）；如果（str.length==0）{ 返回

我想找出一个给定数的排列所产生的最大数

如果给定的数字是123，则由其排列产生的最大数字是321

编辑通过改变，我取得了一些进展

if (str.length === 0) return "";
if (str.length === 1) return str;

到

但是，仍然存在一个问题：函数返回一个字符串。事实上，数组成员是字符串而不是数字

函数findPerms（num）{
var str=num.toString（）；
如果（str.length==0）{
返回“”；
}否则{
返回str；
}
让结果=[]；
for（设i=0；i编辑

我想这就是你想做的。

使用递归将数字的所有数字排列组成一个数组。

对数组进行排序。

返回具有最大数字的排列。

这可以通过将问题分解为两个函数来实现。

第一个函数返回一个数字的所有排列的数组。

第二个函数从第一个函数获取数组结果，然后对其进行排序。然后返回最后一个值。

您的递归操作不正常。这就是它不起作用的原因
<html><head><title>6770990</title>
<script>
function findPerms(num) {
  var str = num.toString(); var result = [];
  if (str.length == 0) return result;
  if (str.length == 1) return [parseInt(str)];
  for (var i = 0; i < str.length; i++) {
    const currentChar = str[i];
    const remainingChars = str.slice(0, i) + str.slice(i + 1)
    var perms = findPerms(remainingChars) //----Permutation array of remaining chars.
    for (var j = 0; j < perms.length; j++) {
      result.push(parseInt("" + currentChar + perms[j]));
    }
  }
  return result; //----All permutations for num.
}
function findLargestPerm(num)
{ var perms = findPerms(num); perms.sort(function(a,b) {return a-b;});
  return perms[perms.length-1];
}
</script>
</head></body>
<script>
var r = findLargestPerm(11121); alert("r=" + r);
</script>
</body></html>

6770990
函数findPerms（num）{
var str=num.toString（）；var result=[]；
if（str.length==0）返回结果；
if（str.length==1）返回[parseInt（str）]；
对于（变量i=0；i

先前的答复
将数字按相反顺序排序并连接成一个数字会更有效。这将是最大的排列
函数findPerms（）试图查找一组数字的最大排列。有时，将函数重命名为它的功能会有所帮助，以便更容易遵循逻辑
再次使用递归调用函数的行只需要为每个当前字符调用一次
下面的代码显示了发生的步骤
<html><head><title>6770990</title>
<script>
var msg="";
function findLargestPermutation(num)
{ var str = num.toString(); msg += "findLargestPermutation(" + str + ")<br>";
  if (str.length === 0) return "";
  if (str.length === 1) return str;
  let result = [];
  for (let i = 0; i < str.length; i++)
  { const currentChar = str[i];
    const remainingChars = str.slice(0, i) + str.slice(i + 1);
    msg += "currentChar=" + currentChar + " remainingChars=" + remainingChars + "<br>";
    //----The j loop should be removed and just use this line.
    var num = Number(currentChar + findLargestPermutation(remainingChars));
    msg += "num=" + num + "<br>";
    result.push(num);
  }
  result.sort(function(a, b) {return a - b;});
  msg += "findLargestPermutation()=" + result[result.length - 1] + "<br>";
  return result[result.length - 1];
}
</script>
</head><body>
<div id="div"></div>
<script>
var lp = findLargestPermutation(11121);
alert("lp=" + lp + " typeof lp=" + typeof lp);
document.getElementById("div").innerHTML = msg;
</script>
</body></html>

6770990
var msg=“”；
函数findLargestPermutation（num）
{var str=num.toString（）；msg+=“findlargestpermutate（“+str+”）
”；
如果（str.length==0）返回“”；
if（str.length==1）返回str；
让结果=[]；
for（设i=0；i”；
//----应拆下j形回路，只需使用此管路即可。
var num=数量（currentChar+FindLargesPermutate（remainingChars））；
msg+=“num=“+num+”
”；
结果：推送（num）；
}
sort（函数（a，b）{返回a-b；}）；
msg+=“findlargestpermutate（）=”+result[result.length-1]+“
”；
返回结果[result.length-1]；
}
var lp=Findlargestermutate（11121）；
警报（“lp=“+lp+”lp类型=“+lp类型”）；
document.getElementById（“div”）.innerHTML=msg；
您的代码有几个问题，但让我们先尝试正确定义需求。
如果我知道你想做的是找到一个数字的所有排列，然后选择数字中可能的最高排列。
您试图做的是这样的：
创建一个空列表
循环遍历初始数字的数字
对于每个数字循环，通过剩余的数字找到所有可能的组合，并将它们添加到初始空列表中
在列表中有所有可能的数字组合后，对它们进行排序并返回最高结果
这里有两个问题，首先是代码执行过程中出现了一些错误，而且您的算法效率不高。
让我们来解决第一个问题：
当您在递归函数中定义结果列表时，这意味着它将在每次递归调用时被一个空数组覆盖。通常，当应用此技术时，要么在递归函数外部定义结果数组，要么将其作为参数传递，以便能够迭代结果。
您似乎没有很好地掌握JS中函数作用域和闭包的工作方式。我建议为此阅读一些有关MDN的参考资料
这里的另一个问题是，您希望函数接收一个数字作为参数，但是当您调用它时
result.push(Number(currentChar + findPerms(remainingChars)

remainingChars是一个字符串，因此是NaN结果
现在进入第二个问题。考虑到您希望从一系列数字中获得尽可能高的数字，您可以将数字从高到小排序，并提供结果。
如：
如果数字是18，您可以像[8，1]一样对其进行数组排序，然后将其连接到81。
代码可能看起来像：
function findHighestPerm(no) {
  const arr = no.toString().split('');
  return parseInt(arr.sort((a, b) => b - a).join(''));
}

PS：我知道我的代码不是最高效或最优雅的，但我只是懒惰，而且它可以工作；）
 您的问题是为什么它返回NaN
，或者为什么typeof NaN==“number”
（这将是的副本）？您进行了哪些调试？您是否尝试过断言currentChar+findPerms（re
function findHighestPerm(no) {
  const arr = no.toString().split('');
  return parseInt(arr.sort((a, b) => b - a).join(''));
}