正确理解递归的方式（javascript）

Question

我正在尝试理解递归，并且我对它的直观工作方式有一定的了解，但是返回数据的聚合是我遇到的问题。

例如，在 javascript 中为了展平一个数组，我想出了以下代码：

var _flatten = function(arr){
    if(!arr instanceof Array) return arr;
    var g = [];

   function flatten(arr){

     for(var i = 0; i < arr.length;i++){
         if(arr[i] instanceof Array){
         flatten(arr[i]);
         }else{
         g.push(arr[i]);
        }
     }
   }

  flatten(arr);
  return g;
}

像这样转

var list = [1,2,3,4,5,6,[1,2,3,4,5,[1,2,3],[1,2,3,4]]];

进入这个：[ 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 1, 2, 3, 1, 2, 3, 4 ]

这很好，但全局变量 g 似乎是某种廉价的黑客行为。我不知道如何考虑到达堆栈顶部时返回的结果以及沿堆栈向下传播的函数的返回。你将如何实现这个功能，我怎样才能更好地掌握这一点？

谢谢！

Answer 1

您可以将 g 作为参数发送给 flatten 函数，而不是全局变量（使其更适合递归），然后使用 return 语句将修改后的 g 传回。

var _flatten = function(arr) {
  if (!arr instanceof Array) return arr;

  function flatten(arr, g) {
    for (var i = 0; i < arr.length; i++) {
      if (arr[i] instanceof Array) {
        flatten(arr[i], g);
      } else {
        g.push(arr[i]);
      }
    }
    return g;
  }

  return flatten(arr, []);
}

Answer 2

有many ways to write an array flattening procedure，但我知道你的问题是关于一般理解递归

g 在任何这个词的意义上都不是全局的，但它是实现选择的症状。只要您将其本地化到您的函数中，突变就不一定是坏事——g 永远不会泄露到可能有人可能观察到副作用的函数之外。

就个人而言，我认为最好将您的问题分解为小的通用过程，这样可以更容易地描述您的代码。

您会注意到，我们不必设置像g 这样的临时变量或像i 这样处理递增的数组迭代器——我们甚至不必查看数组的.length 属性。不必考虑这些事情，以声明方式编写我们的程序非常好。

// concatMap :: (a -> [b]) -> [a] -> [b]
const concatMap = f => xs => xs.map(f).reduce((x,y) => x.concat(y), [])

// id :: a -> a
const id = x => x

// flatten :: [[a]] -> [a]
const flatten = concatMap (id)

// isArray :: a -> Bool
const isArray = Array.isArray

// deepFlatten :: [[a]] -> [a]
const deepFlatten = concatMap (x => isArray(x) ? deepFlatten(x) : x)

// your sample data
let data = [0, [1, [2, [3, [4, 5], 6]]], [7, [8]], 9]

console.log(deepFlatten(data))
// [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

console.log(flatten(data))
// [ 0, 1, [ 2, [ 3, [ 4, 5 ], 6 ] ], 7, [ 8 ], 9 ]

首先你会看到我做了两个不同的展平程序。 flatten 展平一层嵌套，deepFlatten 展平任意深度的数组。

您还会看到我使用了Array.prototype.map 和Array.prototype.reduce，因为它们是由ECMAScript 提供的，但这并不意味着您只能使用您拥有的过程。您可以制定自己的程序来填补空白。这里我们制作了concatMap，这是一个由其他语言（例如 Haskell）提供的有用的泛型。

利用这些泛型，您可以看到deepFlatten 是一个非常简单的过程。

// deepFlatten :: [[a]] -> [a]
const deepFlatten = concatMap (x => isArray(x) ? deepFlatten(x) : x)

它由一个表达式组成，包括一个由一个 if 分支组成的 lambda（通过使用三元运算符 ?:）

---

也许有很多东西需要吸收，但希望它表明“编写递归过程”并不总是涉及复杂的状态变量设置和控制递归的复杂逻辑。在这种情况下，这是一个简单的

<b>if</b> (<em>condition</em>) <em>recurse</em> <b>else</b> <em>don't</em>

如果您有任何问题，请告诉我。我很乐意尽我所能帮助您。

Answer 3

其实递归编码非常简单，它的各个方面都应该包含在函数体中。任何需要传递的信息都应通过参数发送到下一个递归。全局事物的使用非常难看，应避免使用。因此，我将简单地按如下方式进行就地数组展平工作；

var list = [1,2,3,4,5,6,[1,2,3,4,5,[1,2,3],[1,2,[9,8,7],3,4]]];

function flatArray(arr){
  for (var i = 0, len = arr.length; i < len; i++)
    Array.isArray(arr[i]) && (arr.splice(i,0,...flatArray(arr.splice(i,1)[0])), len = arr.length);
  return arr;
}

console.log(flatArray(list));