我有一个 JavaScript 数组,例如:
[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]
我将如何将单独的内部数组合并为一个:
["$6", "$12", "$25", ...]
reduce
+ concat
的所有解决方案都是 O((N^2)/2),其中作为可接受的答案(只需一次调用 concat
)在 a 上最多为 O(N*2)坏的浏览器和好的浏览器 O(N)。 Denys 解决方案还针对实际问题进行了优化,比单个 concat
快 2 倍。对于 reduce
的人来说,编写小代码感觉很酷很有趣,但例如,如果数组有 1000 个单元素子数组,则所有 reduce+concat 解决方案都将执行 500500 operations,而单个 concat 或简单循环将执行 1000 次操作。
您可以使用 concat
来合并数组:
var 数组 = [ ["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"] ]; var 合并 = [].concat.apply([], 数组);控制台.log(合并);
使用 concat
的 apply
方法只会将第二个参数作为一个数组,因此最后一行与此相同:
var merged2 = [].concat(["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]);
还有 Array.prototype.flat()
方法(在 ES2019 中引入),您可以使用它来展平数组,尽管 it is only available in Node.js starting with version 11, and not at all in Internet Explorer。
常量数组 = [ ["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"] ]; const merge3 = arrays.flat(1); //指定嵌套数组结构应该展平的深度级别。默认为 1。 console.log(merge3);
这是一个简短的函数,它使用一些较新的 JavaScript 数组方法来展平 n 维数组。
function flatten(arr) {
return arr.reduce(function (flat, toFlatten) {
return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
}, []);
}
用法:
flatten([[1, 2, 3], [4, 5]]); // [1, 2, 3, 4, 5]
flatten([[[1, [1.1]], 2, 3], [4, 5]]); // [1, 1.1, 2, 3, 4, 5]
reduce
的匿名函数时 flat
的值。如果未指定,则第一次调用 reduce
会将数组中的第一个值绑定到 flat
,这最终会导致在两个示例中 1
都绑定到 flat
。 1.concat
不是函数。
const flatten = (arr) => arr.reduce((flat, next) => flat.concat(next), []);
const flatten = (arr) => arr.reduce((flat, next) => flat.concat(Array.isArray(next) ? flatten(next) : next), []);
有一个令人困惑的隐藏方法,它构造一个新数组而不改变原始数组:
var oldArray = [[1],[2,3],[4]]; var newArray = Array.prototype.concat.apply([], oldArray);控制台.log(newArray); // [ 1, 2, 3, 4 ]
[].concat(...[ [1],[2,3],[4] ])
。
flat = (e) => Array.isArray(e)? [].concat.apply([], e.map(flat)) : e
最好通过javascript reduce函数来完成。
var arrays = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];
arrays = arrays.reduce(function(a, b){
return a.concat(b);
}, []);
或者,使用 ES2015:
arrays = arrays.reduce((a, b) => a.concat(b), []);
arrays.reduce((flatten, arr) => [...flatten, ...arr])
有一个名为 flat 的新本机方法可以准确地执行此操作。
(截至 2019 年底,flat
现已在 ECMA 2019 标准中发布,core-js@3
(babel 的库)将其包含在他们的 polyfill library 中)
const arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
// Flatten 2 levels deep
const arr3 = [2, 2, 5, [5, [5, [6]], 7]];
arr3.flat(2);
// [2, 2, 5, 5, 5, [6], 7];
// Flatten all levels
const arr4 = [2, 2, 5, [5, [5, [6]], 7]];
arr4.flat(Infinity);
// [2, 2, 5, 5, 5, 6, 7];
这里的大多数答案都不适用于大型(例如 200 000 个元素)数组,即使可以,它们也很慢。 polkovnikov.ph's answer 具有最佳性能,但不适用于深度展平。
这是最快的解决方案,它也适用于具有多级嵌套的数组:
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, 1, 1, 1, 1, 1]
。
具有不同嵌套级别的数组
flatten([1, [1], [[1]]]);
像这样的展平阵列没有任何问题。
RangeError: Maximum call stack size exceeded
)。对于 20 000 个元素的数组,它需要 2-5 毫秒。
更新:事实证明,此解决方案不适用于大型数组。如果您正在寻找更好、更快的解决方案,请查看this answer。
function flatten(arr) {
return [].concat(...arr)
}
Is 只是扩展 arr
并将其作为参数传递给 concat()
,它将所有数组合并为一个。它相当于 [].concat.apply([], arr)
。
你也可以试试这个进行深度展平:
function deepFlatten(arr) {
return flatten( // return shalowly flattened array
arr.map(x=> // with each x in array
Array.isArray(x) // is x an array?
? deepFlatten(x) // if yes, return deeply flattened x
: x // if no, return just x
)
)
}
请参阅 JSBin 上的演示。
此答案中使用的 ECMAScript 6 元素的参考:
扩展运算符
箭头函数
旁注:并非所有浏览器都支持 find()
和箭头函数等方法,但这并不意味着您现在不能使用这些功能。只需使用 Babel — 它将 ES6 代码转换为 ES5。
apply
,所以我从你的评论中删除了我的评论。我仍然认为以这种方式使用 apply
/spread 是不好的建议,但由于没有人关心...
const flatten = arr => [].concat(...arr)
您可以使用 Underscore:
var x = [[1], [2], [3, 4]];
_.flatten(x); // => [1, 2, 3, 4]
true
for the second argument。
通用过程意味着我们不必在每次需要使用特定行为时重写复杂性。
concatMap
(或 flatMap
)正是我们在这种情况下所需要的。
// concat :: ([a],[a]) -> [a] const concat = (xs,ys) => xs.concat (ys) // concatMap :: (a -> [b]) -> [a] -> [b] const concatMap = f => xs => xs.map(f).reduce(concat, []) // id :: a -> a const id = x => x // 展平:: [[a]] -> [a] const flatten = concatMap (id) // 你的样本数据 const data = [["$6"], ["$12"], ["$25"], ["$25" ], ["$18"], ["$22"], ["$10"]] console.log (flatten (data))
远见
是的,你猜对了,它只变平了一层,这正是它应该如何工作的
想象一些这样的数据集
// Player :: (String, Number) -> Player const Player = (name,number) => [ name, number ] // team :: ( . Player) -> Team const Team = (...players) = > 玩家 // Game :: (Team, Team) -> Game const Game = (teamA, teamB) => [ teamA, teamB ] // 样本数据 const teamA = Team (Player ('bob', 5), Player ( 'alice', 6)) const teamB = Team (Player ('ricky', 4), Player ('julian', 2)) const game = Game (teamA, teamB) console.log (game) // [ [ [ 'bob', 5 ], ['alice', 6 ] ], // [ ['ricky', 4 ], ['julian', 2 ] ] ]
好的,现在假设我们要打印一份名单,显示所有将参加 game
的球员......
const gamePlayers = game =>
flatten (game)
gamePlayers (game)
// => [ [ 'bob', 5 ], [ 'alice', 6 ], [ 'ricky', 4 ], [ 'julian', 2 ] ]
如果我们的 flatten
过程也将嵌套数组展平,我们最终会得到这个垃圾结果……
const gamePlayers = game =>
badGenericFlatten(game)
gamePlayers (game)
// => [ 'bob', 5, 'alice', 6, 'ricky', 4, 'julian', 2 ]
滚得很深,宝贝
这并不是说有时您也不想展平嵌套数组——只是这不应该是默认行为。
我们可以轻松地制作一个deepFlatten
程序……
// concat :: ([a],[a]) -> [a] const concat = (xs,ys) => xs.concat (ys) // concatMap :: (a -> [b]) -> [a] -> [b] const concatMap = f => xs => xs.map(f).reduce(concat, []) // id :: a -> a const id = x => x // 展平:: [[a]] -> [a] const flatten = concatMap (id) // deepFlatten :: [[a]] -> [a] const deepFlatten = concatMap (x => Array.isArray (x) ? deepFlatten (x) : x) // 你的样本数据 const 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 ] console.log (deepFlatten (data)) // [ 0 , 1, 2, 3, 4, 5, 6, 7, 8, 9]
那里。现在,您为每项作业提供了一个工具 - 一个用于压缩一层嵌套 flatten
,另一个用于消除所有嵌套 deepFlatten
。
如果您不喜欢 deepFlatten
这个名字,也许您可以称它为 obliterate
或 nuke
。
不要重复两次!
当然,上述实现既聪明又简洁,但使用 .map
后调用 .reduce
意味着我们实际上进行了不必要的迭代
使用我称为 mapReduce
的可靠组合器有助于将迭代保持在最小;它接受一个映射函数 m :: a -> b
、一个归约函数 r :: (b,a) ->b
并返回一个新的归约函数 - 这个组合器是 transducers 的核心;如果您有兴趣,I've written other answers about them
// mapReduce = (a -> b, (b,a) -> b, (b,a) -> b) const mapReduce = (m,r) => (acc,x) => r (acc, m (x)) // concatMap :: (a -> [b]) -> [a] -> [b] const concatMap = f => xs => xs.reduce (mapReduce (f, concat), []) // concat :: ([a],[a]) -> [a] const concat = (xs,ys) => xs.concat (ys) // id :: a -> a const id = x => x // flatten :: [[a]] -> [a] const flatten = concatMap (id) // deepFlatten :: [[a]] -> [a] const deepFlatten = concatMap (x => Array.isArray ( x) ? deepFlatten (x) : x) // 你的样本数据 const data = [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 5, 6 ], [ 7, 8 ] ] ] console.log (flatten (data)) // [ [ 1. 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ] console.log (deepFlatten (data)) // [ 1, 2, 3 , 4, 5, 6, 7, 8]
concat
本身不会炸毁堆栈,只有 ...
和 apply
会炸毁(以及非常大的数组)。我没看到。我现在只是觉得很可怕。
concat
与 Haskell 中的含义不同。 Haskell 的 concat
([[a]] -> [a]
) 在 Javascript 中将被称为 flatten
并被实现为 foldr (++) []
(Javascript:foldr(concat) ([])
假设为 curried 函数)。 Javascript 的 concat
是一个奇怪的附加(Haskell 中的 (++)
),它可以同时处理 [a] -> [a] -> [a]
和 a -> [a] -> [a]
。
flatMap
,因为这正是 concatMap
的含义:list
monad 的 bind
实例。 concatpMap
实现为 foldr ((++) . f) []
。翻译成 Javascript:const flatMap = f => foldr(comp(concat) (f)) ([])
。这当然类似于您没有 comp
的实现。
要展平单个元素数组的数组,您不需要导入库,一个简单的循环既是最简单的也是 most efficient 解决方案:
for (var i = 0; i < a.length; i++) {
a[i] = a[i][0];
}
致反对者:请阅读问题,不要反对,因为它不适合您非常不同的问题。对于所提出的问题,此解决方案是最快和最简单的。
['foo', ['bar']]
“扁平化”为 ['f', 'bar']
。
更一般情况下的解决方案,当您的数组中可能有一些非数组元素时。
function flattenArrayOfArrays(a, r){
if(!r){ r = []}
for(var i=0; i<a.length; i++){
if(a[i].constructor == Array){
flattenArrayOfArrays(a[i], r);
}else{
r.push(a[i]);
}
}
return r;
}
flattenArrayOfArrays (arr, 10)
或这个 flattenArrayOfArrays(arr, [1,[3]]);
- 这些第二个参数被添加到输出中。
函数式风格的另一个 ECMAScript 6 解决方案:
声明一个函数:
const flatten = arr => arr.reduce(
(a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
);
并使用它:
flatten( [1, [2,3], [4,[5,[6]]]] ) // -> [1,2,3,4,5,6]
const flatten = arr => arr.reduce( (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), [] ); console.log( 展平([1, [2,3], [4,[5],[6,[7,8,9],10],11],[12],13]) )
还要考虑在现代浏览器的最新版本中提供的本机函数 Array.prototype.flat()(ES6 提案)。 感谢@(Константин Ван) 和@(Mark Amery) 在评论中提到它。
flat
函数有一个参数,指定预期的数组嵌套深度,默认等于 1
。
[1, 2, [3, 4]].flat(); // -> [1, 2, 3, 4]
[1, 2, [3, 4, [5, 6]]].flat(); // -> [1, 2, 3, 4, [5, 6]]
[1, 2, [3, 4, [5, 6]]].flat(2); // -> [1, 2, 3, 4, 5, 6]
[1, 2, [3, 4, [5, 6]]].flat(Infinity); // -> [1, 2, 3, 4, 5, 6]
让 arr = [1, 2, [3, 4]];控制台.log(arr.flat()); arr = [1, 2, [3, 4, [5, 6]]];控制台.log(arr.flat());控制台.log(arr.flat(1)); console.log(arr.flat(2)); console.log(arr.flat(Infinity));
RangeError: Maximum call stack size exceeded
您也可以尝试新的 Array.flat()
方法。它以下列方式工作:
让 arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]].flat()控制台.log(arr);
flat()
方法创建一个新数组,其中所有子数组元素递归连接到其中,直到 1 层深度(即数组内的数组)
如果您还想展平 3 维甚至更高维的数组,您只需多次调用 flat 方法。例如(3 个维度):
让 arr = [1,2,[3,4,[5,6]]].flat().flat().flat();控制台.log(arr);
当心!
Array.flat()
方法相对较新。像 ie 这样的旧浏览器可能没有实现该方法。如果您希望您的代码可以在所有浏览器上工作,您可能必须将您的 JS 转换为旧版本。检查 MDN web docs 以了解当前浏览器的兼容性。
Infinity
参数的扁平化方法。像这样:arr.flat(Infinity)
使用 JavaScript 1.8
的 reduce(callback[, initialValue])
方法怎么样
list.reduce((p,n) => p.concat(n),[]);
会做这项工作。
const common = arr.reduce((a, b) => [...a, ...b], [])
您可以将 Array.flat()
与 Infinity
一起用于任何深度的嵌套数组。
var arr = [ [1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2,3,4,[1 ,2,3,4]]], [[1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2 ,3,4,[1,2,3,4]]]]];让 flatten = arr.flat(Infinity) console.log(flatten)
在此处查看浏览器 compatibility
请注意:当使用 Function.prototype.apply
([].concat.apply([], arrays)
) 或扩展运算符 ([].concat(...arrays)
) 来展平数组时,两者都可能导致大型数组的堆栈溢出,因为函数存储在堆栈中。
这是一个功能风格的堆栈安全实现,它权衡了最重要的需求:
可重用性
可读性
简明
表现
// 小的、可重用的辅助函数: const foldl = f => acc => xs => xs.reduce(uncurry(f), acc); // 又名 reduce const uncurry = f => (a, b) => f(a) (b); const concat = xs => y => xs.concat(y); // 展平数组的实际函数 - 不言自明的一行: const flatten = xs => foldl(concat) ([]) (xs); // 任意数组大小(直到堆爆炸 :D) const xs = [[1,2,3],[4,5,6],[7,8,9]];控制台日志(扁平化(xs)); // 为深度嵌套的数组导出递归解决方案现在很简单 // 还有更小的、可重用的辅助函数: const map = f => xs => xs.map(apply(f));常量应用 = f => a => f(a);常量 isArray = Array.isArray; // 派生的递归函数: const flattenr = xs => flatten(map(x => isArray(x) ? flattenr(x) : x) (xs));常量 ys = [1,[2,[3,[4,[5],6,],7],8],9]; console.log(flattenr(ys));
一旦你习惯了柯里化形式的小箭头函数、函数组合和高阶函数,这段代码读起来就像散文一样。然后,编程仅包括将始终按预期工作的小构建块组合在一起,因为它们不包含任何副作用。
const flatten = (arr) => arr.reduce((a, b) => a.concat(b), []);
即可为您节省视觉垃圾和向您的队友解释为什么您需要 3 个额外函数和一些函数调用。
ES6 单行展平
请参阅 lodash flatten、underscore flatten (shallow true
)
function flatten(arr) {
return arr.reduce((acc, e) => acc.concat(e), []);
}
function flatten(arr) {
return [].concat.apply([], arr);
}
经测试
test('already flatted', () => {
expect(flatten([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});
test('flats first level', () => {
expect(flatten([1, [2, [3, [4]], 5]])).toEqual([1, 2, [3, [4]], 5]);
});
ES6 单行深度展平
请参阅 lodash flattenDeep、underscore flatten
function flattenDeep(arr) {
return arr.reduce((acc, e) => Array.isArray(e) ? acc.concat(flattenDeep(e)) : acc.concat(e), []);
}
经测试
test('already flatted', () => {
expect(flattenDeep([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});
test('flats', () => {
expect(flattenDeep([1, [2, [3, [4]], 5]])).toEqual([1, 2, 3, 4, 5]);
});
Array.prototype.concat.apply([], arr)
,因为您创建一个额外的数组只是为了访问 concat
函数。运行时在运行它时可能会或可能不会优化它,但在原型上访问函数看起来并不比现在更难看。
使用扩展运算符:
常量输入 = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];常量输出 = [].concat(...输入);控制台.log(输出); // --> ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]
var 数组 = [["$6"], ["$12","$16"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]] var a = array.flat(Infinity);控制台.log(a);
如果您只有包含 1 个字符串元素的数组:
[["$6"], ["$12"], ["$25"], ["$25"]].join(',').split(',');
将完成这项工作。与您的代码示例特别匹配的 Bt。
['$4', ["$6"], ["$12"], ["$25"], ["$25", "$33", ['$45']]].join(',').split(',')
[1,4, [45, 't', ['e3', 6]]].toString().split(',')
---- 或 ----- [1,4, [45, 't', ['e3', 6], false]].toString().split(',')
我推荐一个节省空间的 generator function:
函数* flatten(arr) { if (!Array.isArray(arr)) yield arr; else for (let el of arr) yield* flatten(el); } // 示例:console.log(...flatten([1,[2,[3,[4]]]])); // 1 2 3 4
如果需要,创建一个扁平值数组,如下所示:
let flattened = [...flatten([1,[2,[3,[4]]]])]; // [1, 2, 3, 4]
...
来迭代生成器。
Haskellesque 方法
函数 flatArray([x,...xs]){ 返回 x ? [...Array.isArray(x) ? flatArray(x) : [x], ...flatArray(xs)] : []; } var na = [[1,2],[3,[4,5]],[6,7,[[[8],9]]],10]; fa = flatArray(na);控制台.log(fa);
我已经使用递归和闭包完成了它
function flatten(arr) {
var temp = [];
function recursiveFlatten(arr) {
for(var i = 0; i < arr.length; i++) {
if(Array.isArray(arr[i])) {
recursiveFlatten(arr[i]);
} else {
temp.push(arr[i]);
}
}
}
recursiveFlatten(arr);
return temp;
}
ES6方式:
const flatten = arr => arr.reduce((acc, next) => acc.concat(Array.isArray(next) ? flatten(next) : next), []) const a = [1, [2, [3 , [4, [5]]]]] console.log(flatten(a))
flatten
函数的 ES5 方式与 N 次嵌套数组的 ES3 后备:
var flatten = (function() { if (!!Array.prototype.reduce && !!Array.isArray) { return function(array) { return array.reduce(function(prev, next) { return prev.concat(Array. isArray(next) ? flatten(next) : next); }, []); }; } else { return function(array) { var arr = []; var i = 0; var len = array.length; var target ; for (; i < len; i++) { target = array[i]; arr = arr.concat( (Object.prototype.toString.call(target) === '[object Array]') ? flatten(target) : 目标); } 返回 arr; }; } }()); var a = [1, [2, [3, [4, [5]]]]];控制台.log(扁平化(a));
如果你使用 lodash,你可以使用它的 flatten
方法:https://lodash.com/docs/4.17.14#flatten
lodash 的好处是它还有扁平化数组的方法:
i) 递归:https://lodash.com/docs/4.17.14#flattenDeep
ii) 最多 n 层嵌套:https://lodash.com/docs/4.17.14#flattenDepth
例如
const _ = require("lodash");
const pancake = _.flatten(array)
前几天我在和 ES6 Generators 开玩笑,写了 this gist。其中包含...
function flatten(arrayOfArrays=[]){
function* flatgen() {
for( let item of arrayOfArrays ) {
if ( Array.isArray( item )) {
yield* flatten(item)
} else {
yield item
}
}
}
return [...flatgen()];
}
var flatArray = flatten([[1, [4]],[2],[3]]);
console.log(flatArray);
基本上我正在创建一个循环遍历原始输入数组的生成器,如果它找到一个数组,它使用 yield* 运算符结合递归来不断展平内部数组。如果该项目不是一个数组,它只是 yields 单个项目。然后使用 ES6 Spread operator(又名 splat 运算符)我将生成器展平为一个新的数组实例。
我还没有测试过它的性能,但我认为这是使用生成器和 yield* 运算符的一个很好的简单示例。
但同样,我只是在胡说八道,所以我确信有更多高效的方法可以做到这一点。
只是没有 lodash 的最佳解决方案
let flatten = arr => [].concat.apply([], arr.map(item => Array.isArray(item) ? flatten(item) : item))
我宁愿将整个数组按原样转换为字符串,但与其他答案不同,我会使用 JSON.stringify
而不是使用 toString()
方法,这会产生不需要的结果。
使用该 JSON.stringify
输出,剩下的就是删除所有括号,用 start & 包装结果再次结束括号,并使用 JSON.parse
提供结果,使字符串恢复“生命”。
可以处理无限的嵌套数组,而无需任何速度成本。
可以正确处理包含逗号的字符串的数组项。
var arr = ["abc",[[[6]]],["3,4"],"2"]; var s = "[" + JSON.stringify(arr).replace(/\[|]/g,'') +"]"; var flattened = JSON.parse(s); console.log(扁平化)
仅适用于字符串/数字的多维数组(不是对象)
["345", "2", "3,4", "2"]
时它将包含逗号,而不是将这些值中的每一个分隔为单独的索引
"3,4"
。
我认为 array.flat(Infinity) 是一个完美的解决方案。但是平面函数是一个比较新的函数,可能无法在旧版本的浏览器中运行。我们可以使用递归函数来解决这个问题。
const arr = ["A", ["B", [["B11", "B12", ["B131", "B132"]], "B2"]], "C", ["D", " E", "F", ["G", "H", "I"]]] const flatArray = (arr) => { const res = [] for (const item of arr) { if (Array.isArray( item)) { const subRes = flatArray(item) res.push(...subRes) } else { res.push(item) } } return res } console.log(flatArray(arr))
不定期副业成功案例分享
Array.prototype.concat.apply([], arrays)
。var merged = [].concat(...arrays)
Array.prototype.concat(...arrays)
。此版本适用于 Typescript 的 2.3.0--strict
模式。不适用于嵌套数组(它不是递归的)。