递归闭包

Question

JSFiddle

联的小提琴表明，使用递归拉平任何尺寸的阵列（感谢用户BERGI和Exlord他们在第一部分的帮助），并返回一个函数具有最高索引的数组。在我能够得到一些有用的东西之前，我曾经尝试过很多东西。我想澄清一些事情：

1. 它是代码的气味，如果你有一个内部函数在一个明确接受参数的闭包内？例如：
2. 为什么第二个脚本以最大调用堆栈大小超过错误结束？

-

return { 
     data: flatten(array), 
     rank: ranks.sort().reverse()[0] 
     //smelly code? 
} 

JS

//working code block 
    (function() { 
     function flattenAll(array) { 
      var ranks = []; 
      function flatten(array) { 
       var rank = 0; 
       var data = []; 
       $.each(array, function (index, item) { 
        //recursion here 
        typeof (item) !== 'object' ? data.push(item) : data = data.concat(flatten(item)); 
        rank++ 
       }); 
       ranks.push(rank); 
       return data; 
      }; 
      return { 
       data: flatten(array), 
       rank: ranks.sort().reverse()[0] 
      } 

     } 
     console.log(flattenAll([3, 4, [[[[[[4]]]]]], [[1, 4, 5]], [4]])); 
    })(); 
/****** second code block******************/ 
    (function() { 
     function flattenAll(array) { 
      var ranks = [], 
       //tried different approach for returning data 
       //this approach of setting returnData= data 
       //only grabs the last element in the array 
       returnData = []; 
      function flatten() { 
       var rank = 0; 
       var data = []; 
       $.each(array, function (index, item) { 
        //recursion here 
        $.isArray(item) ? data = flatten(item) : data.push(item); 
        rank++ 
       }); 
       ranks.push(rank); 
       returnData = data; 
       return data; 
      }; 
      return { 
       data: flatten(), //no parens here vs the first code block 
       rank: ranks.sort().reverse()[0] 
      } 

     } 
     console.log(flattenAll([3, 4, [[[[[[4]]]]]], [[1, 4, 5]], [4]])); 
    })(); 

是否有处理倒闭内处理递归有道？我不理解这里发生的一切。

Answer 1

也许我失去了一些东西，但它看起来像你在第二个例子中看起来无限，因为你反复调用flatten（item）。平坦不存在争论。这意味着你一直循环着同一个数组，这个数组就是你最初称之为flattenAll的数组，直到你超出了调用栈的限制。

Answer 2

对于代码气味的问题，您是否在谈论对ranks.sort().reverse()[0]的调用？如果是这样，并且你对此感觉不好，那么你可以保持对maxRank的引用，而不是所有的等级。

这里是你的第二个代码块：

(function() { 
    function flattenAll(array) { 
     var ranks = [], 
      //tried different approach for returning data 
      //this approach of setting returnData= data 
      //only grabs the last element in the array 
      returnData = []; 
     function flatten() { 
      var rank = 0; 
      var data = []; 
      $.each(array, function (index, item) { 
       //recursion here 
       $.isArray(item) ? data = flatten(item) : data.push(item); 
       rank++ 
      }); 
      ranks.push(rank); 
      returnData = data; 
      return data; 
     }; 
     return { 
      data: flatten(), //no parens here vs the first code block 
      rank: ranks.sort().reverse()[0] 
     } 

    } 
    console.log(flattenAll([3, 4, [[[[[[4]]]]]], [[1, 4, 5]], [4]])); 
})(); 

这里只有一个array变量，它永远不会改变。因此，您拨打flattenAll的原始数组与$.each中的始终使用的数组相同。那么，这是否有道理，至于为什么你会得到一个调用堆栈异常？ array指向外部array，因为没有隐藏它。