我有一个JavaScript数组,如:

[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]

如何将单独的内部数组合并为一个,例如:

["$6", "$12", "$25", ...]

当前回答

我只使用ES6回答这个问题,假设深度阵列是:

const deepArray = ['1',[['a'],['b']],[2],[[[['4',[3,'c']]]],[5]]];

如果您知道或猜测阵列的深度不超过7这样的数字,请使用以下代码:

const flatArray = deepArray.flat(7);

但如果你不知道深度数组的深度,或者你的JavaScript引擎不支持像react原生JavaScriptCore那样的flat,请使用下面的JavaScript reduce函数:

 const deepFlatten = arr =>
         arr.reduce(
           (acc, val) =>
             Array.isArray(val) 
               ? acc.concat(deepFlatten(val)) 
               : acc.concat(val),
             []
         );

这两种方法都返回以下结果:

["1", "a", "b", 2, "4", 3, "c", 5]

其他回答

/**
* flatten an array first level
* @method flatten
* @param array {Array}
* @return {Array} flatten array
*/
function flatten(array) {
  return array.reduce((acc, current) => acc.concat(current), []);
}


/**
* flatten an array recursively
* @method flattenDeep
* @param array {Array}
* @return {Array} flatten array
*/
function flattenDeep(array) {
  return array.reduce((acc, current) => {
    return Array.isArray(current) ? acc.concat(flattenDeep(current)) : acc.concat([current]);
  }, []);
}

/**
* flatten an array recursively limited by depth
* @method flattenDepth
* @param array {Array}
* @return {Array} flatten array
*/
function flattenDepth(array, depth) {
  if (depth === 0) {
    return array;
  }
  return array.reduce((acc, current) => {
    return Array.isArray(current) ? acc.concat(flattenDepth(current, --depth)) : acc.concat([current]);
  }, []);
}

最好是以递归的方式执行,这样如果另一个数组中还有另一个,就可以很容易地过滤。。。

const flattenArray = arr =>
  arr.reduce(
    (res, cur) =>
       !Array.isArray(cur) 
       ? res.concat(cur)
       : res.concat(flattenArray(cur)), []);

你可以这样称呼它:

flattenArray([[["Alireza"], "Dezfoolian"], ["is a"], ["developer"], [[1, [2, 3], ["!"]]]);

结果如下:

["Alireza", "Dezfoolian", "is a", "developer", 1, 2, 3, "!"]

这里的大多数答案都不适用于大型(例如200000个元素)阵列,即使这样,它们也很慢。

以下是最快的解决方案,它也适用于具有多层嵌套的阵列:

const flatten = function(arr, result = []) {
  for (let i = 0, length = arr.length; i < length; i++) {
    const value = arr[i];
    if (Array.isArray(value)) {
      flatten(value, result);
    } else {
      result.push(value);
    }
  }
  return result;
};

示例

巨大的阵列

flatten(Array(200000).fill([1]));

它可以很好地处理巨大的数组。在我的机器上,执行这段代码需要大约14毫秒。

嵌套数组

flatten(Array(2).fill(Array(2).fill(Array(2).fill([1]))));

它适用于嵌套数组。此代码生成[1,1,1,2,1,3,1,1]。

具有不同嵌套级别的数组

flatten([1, [1], [[1]]]);

它对像这样的扁平化阵列没有任何问题。

制作平面阵列的方法

使用Es6 flat()使用Es6 reduce()使用递归使用字符串操作

[1,[2,[3,[4,[5,[6,7],8],9],10]]] - [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

//使用Es6 flat()设arr=[1,[2,[3,[4,[5,[6,7],8],9],10]]]console.log(arr.flat(无限))//使用Es6 reduce()let flatIt=(array)=>array.reduce((x,y)=>x.concat(Array.isArray(y)?flatIt(y):y),[])console.log(flatIt(arr))//使用递归函数myFlat(数组){let flat=[].contat(…数组);返回flat.some(Array.isArray)?myFlat(平面):平面;}console.log(myFlat(arr));//使用字符串操作let strArr=arr.toString().split(',');for(设i=0;i<strArr.length;i++)strArr[i]=parseInt(strArr[i]);console.log(strArr)

function flatten(input) {
  let result = [];
  
  function extractArrayElements(input) {
    for(let i = 0; i < input.length; i++){
      if(Array.isArray(input[i])){
        extractArrayElements(input[i]);
      }else{
        result.push(input[i]);
      }
    }
  }
  
  extractArrayElements(input);
  
  return result;
}


// let input = [1,2,3,[4,5,[44,7,8,9]]];
// console.log(flatten(input));

// output [1,2,3,4,5,6,7,8,9]