Javascript JS-将嵌套数组分隔为包含的数组

我想在嵌套数组中获取所有子数组，从每个深度生成一个新数组（包括原始输入数组），然后将它们放入一个新数组中

输入：

var array = ["cat", ["dog", ["rabbit"]], "hamster"]

输出：

newArray = [
             ["cat", ["dog", ["rabbit"]], "hamster"], 
             ["dog", ["rabbit"]], 
             ["rabbit"]
           ]

尝试：

var unnest = function(array) {
  var container = [array];
    for (var i in array) {
        if (array[i] instanceof Array) {
          container.push(array[i]);
        }
    }
  return container
}

---

我知道这需要某种迭代或递归过程，但这正是我遇到的问题（我是JavaScript新手）。谢谢。

你就快到了！您只需要更改一件事：将for循环包装到函数中，以便可以递归调用它。这里有一种方法

var unnest = function(array) {
  var container = [array];

  var collectNestedArrays = function(array) {
    array.forEach(function(x) {
      if (x instanceof Array) {
        container.push(x);
        collectNestedArrays(x);
      }
    });
  };

  collectNestedArrays(array);

  return container;
};

---

因为我们迭代一个数组并为树中的父数组和每个子数组创建元素，所以使用递归DFS算法最好解决这个问题

function unnest(src) {
  // overload the parameters and take the target array as a second argument.
  // this helps us avoid having nested functions, improve performance 
  // and reduce boilerplate
  var target = arguments[1] || [];

  // add the current array to the target array
  target.push(src);

  // iterate on the parent array and recursively call our function, 
  // assigning the child array, and the target array as function parameters
  src.forEach(function (node) {
    if (node instanceof Array) {
      unnest(node, target);
    }
  });
  return target;
}

---

这是一个递归实现

var unNest = function(array) {
  // Create a results array to store your new array
  var resultsArr = [];
  // Recursive function that accepts an array
  var recurse = function(array) {
    // Push the passed-in array to our results array
    resultsArr.push(array);
    // Iterate over the passed-in array
    for (var i = 0; i < array.length; i++) {
      // If an element of this array happens to also be an array,
      if (Array.isArray(array[i])) {
        // Run the recursive function, passing in that specific element which happens to be an array
        recurse(array[i]);
      }
    }
  }
  // Invoke our recurse function, passing in the original array that unNest takes in
  recurse(array);
  // Return the results array
  return resultsArr;
}

var unNest=函数（数组）{
//创建结果数组以存储新数组
var resultsArr=[]；
//接受数组的递归函数
var recurse=函数（数组）{
//将传入的数组推送到我们的结果数组
resultsArr.push（数组）；
//迭代传入的数组
对于（var i=0；i

那么你尝试了什么？@Oka抱歉，刚才添加了我尝试的解决方案。啊，这很清楚。感谢您在代码中的注释。这帮了大忙。很高兴你发现它很有用！谢谢你，@troyastorino。当涉及递归部分时，我遇到了麻烦，但这很有帮助。