blocks|key|339508|text|下面是一个简短的函数，它使用一些较新的JavaScript数组方法来展平n维数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339509|function+flatten(arr)+{
++return+arr.reduce(function+(flat,+toFlatten)+{
++++return+flat.concat(Array.isArray(toFlatten)+?+flatten(toFlatten)+:+toFlatten);
++},+[]);
}|code-block|syntax|javascript|339510|用法：|339511|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]|339512|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Here's a short function that uses some of the newer JavaScript array methods to flatten an n-dimensional array.</p>

<pre><code>function flatten(arr) {
  return arr.reduce(function (flat, toFlatten) {
    return flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten);
  }, []);
}
</code></pre>

<p>Usage:</p>

<pre><code>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]
</code></pre>


blocks|key|555586|text|有一个令人困惑的隐藏方法，它构造一个新的数组，而不会改变原来的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|555587|​|555588|var+oldArray+=+[[1],[2,3],[4]];
var+newArray+=+Array.prototype.concat.apply([],+oldArray);
console.log(newArray);+//+[+1,+2,+3,+4+]|code-block|syntax|javascript|555589|555590|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>There is a confusingly hidden method, which constructs a new array without mutating the original one:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var oldArray = [[1],[2,3],[4]];
var newArray = Array.prototype.concat.apply([], oldArray);
console.log(newArray); // [ 1, 2, 3, 4 ]</code></pre>
</div>
</div>
</p>


blocks|key|339729|text|最好的方法是使用javascript+reduce函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339730|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);
},+[]);|code-block|syntax|javascript|339731|或者，使用ES2015：|339732|arrays+=+arrays.reduce((a,+b)+=>+a.concat(b),+[]);|339733|js-fiddle|offset|length|339734|Mozilla+docs|339735|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/zAzaH/|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce?v=control^0|0|0|0|0|0|9|0|0|0|C|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@$M|15|N|16|1|17]]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@$M|19|N|1A|1|1B]]|A|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]|Y|$5|T|U|V|A|$W|Z]]]]

<p>It can be best done by javascript reduce function.</p>

<pre><code>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);
}, []);
</code></pre>

<p>Or, with ES2015:</p>

<pre><code>arrays = arrays.reduce((a, b) =&gt; a.concat(b), []);
</code></pre>

<p><a href="http://jsfiddle.net/zAzaH/" rel="noreferrer">js-fiddle</a></p>

<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce?v=control" rel="noreferrer">Mozilla docs</a></p>


blocks|key|555420|text|您可以使用Underscore|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|555421|var+x+=+[[1],+[2],+[3,+4]];

_.flatten(x);+//+=>+[1,+2,+3,+4]|code-block|syntax|javascript|555422|entityMap|0|LINK|mutability|MUTABLE|url|http://underscorejs.org/^0|5|A|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<p>You can use <a href="http://underscorejs.org/" rel="noreferrer">Underscore</a>:</p>

<pre><code>var x = [[1], [2], [3, 4]];

_.flatten(x); // =&gt; [1, 2, 3, 4]
</code></pre>


blocks|key|555375|text|要展平单个元素数组的数组，不需要导入库，简单的循环既是最简单的解决方案，也是most+efficient解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|555376|for+(var+i+=+0;+i+<+a.length;+i%2B%2B)+{
++a[i]+=+a[i][0];
}|code-block|syntax|javascript|555377|致反对者:请阅读这个问题，不要投反对票，因为它不适合你非常不同的问题。对于被问到的问题，这个解决方案既快又简单。|555378|entityMap|0|LINK|mutability|MUTABLE|url|http://jsperf.com/flatten-constant-depht-array^0|12|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<p>To flatten an array of single element arrays, you don't need to import a library, a simple loop is both the simplest and <a href="http://jsperf.com/flatten-constant-depht-array" rel="noreferrer">most efficient</a> solution :</p>

<pre><code>for (var i = 0; i &lt; a.length; i++) {
  a[i] = a[i][0];
}
</code></pre>

<p>To downvoters: please read the question, don't downvote because it doesn't suit your very different problem. This solution is both the fastest and simplest for the asked question.</p>


blocks|key|339666|text|对于更一般的情况，当数组中可能有一些非数组元素时，这是一种解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339667|function+flattenArrayOfArrays(a,+r){
++++if(!r){+r+=+[]}
++++for(var+i=0;+i<a.length;+i%2B%2B){
++++++++if(a[i].constructor+==+Array){
++++++++++++r.concat(flattenArrayOfArrays(a[i],+r));
++++++++}else{
++++++++++++r.push(a[i]);
++++++++}
++++}
++++return+r;
}|code-block|syntax|javascript|339668|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>A solution for the more general case, when you may have some non-array elements in your array.</p>

<pre><code>function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i&lt;a.length; i++){
        if(a[i].constructor == Array){
            r.concat(flattenArrayOfArrays(a[i], r));
        }else{
            r.push(a[i]);
        }
    }
    return r;
}
</code></pre>


blocks|key|555635|text|如何使用JavaScript+1.8的reduce(callback[,+initialValue])方法？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|555636|list.reduce((p,n)+=>+p.concat(n),[]);|code-block|syntax|javascript|555637|就能胜任这项工作。|555638|entityMap^0|4|E|J|W|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

<p>What about using <code>reduce(callback[, initialValue])</code> method of <code>JavaScript 1.8</code></p>

<pre><code>list.reduce((p,n) =&gt; p.concat(n),[]);
</code></pre>

<p>Would do the job.</p>


blocks|key|341138|text|const+common+=+arr.reduce((a,+b)+=>+[...a,+...b],+[])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|341139|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>const common = arr.reduce((a, b) =&gt; [...a, ...b], [])
</code></pre>


blocks|key|558016|text|您还可以尝试新的Array.flat()方法。它的工作方式如下：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|558017|​|558018|let+arr+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"]].flat()

console.log(arr);|code-block|syntax|javascript|558019|558020|flat()方法创建一个新的数组，所有的子数组元素递归地连接到该数组中，直到深度为1层(即数组中的数组)|558021|如果您还想展平三维甚至更高维数组，只需多次调用flat方法即可。例如(3个维度)：|558022|558023|let+arr+=+[1,2,[3,4,[5,6]]].flat().flat().flat();

console.log(arr);|558024|558025|注意!|558026|Array.flat()方法是一种比较新的方法。像ie这样的老浏览器可能还没有实现这个方法。如果你想让你的代码在所有的浏览器上都能工作，你可能需要把你的JS转换成一个旧版本。检查当前浏览器兼容性的MDN+web+docs。|558027|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat|1|2^0|8|C|8|C|0|0|0|0|0|0|6|0|0|0|0|0|0|0|C|0|C|1|2Q|C|2|0^^$0|@$1|2|3|4|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|F|3|G|5|6|7|1F|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|1H|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1L|8|@]|D|@]|E|$]]|$1|R|3|G|5|6|7|1M|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|U|3|G|5|6|7|1O|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1P|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@$9|1T|A|1U|1|1V]|$9|1W|A|1X|1|1Y]]|E|$]]|$1|Z|3|-4|5|6|7|1Z|8|@]|D|@]|E|$]]]|10|$11|$5|12|13|14|E|$15|16]]|17|$5|12|13|14|E|$15|16]]|18|$5|12|13|14|E|$15|16]]]]

<p>You can also try the new <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat" rel="noreferrer"><code>Array.flat()</code></a> method. It works in the following manner:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]].flat()

console.log(arr);</code></pre>
</div>
</div>
</p>
<p>The <code>flat()</code> method creates a new array with all sub-array elements concatenated into it recursively up to the 1 layer of depth (i.e. arrays inside arrays)</p>
<p>If you want to also flatten out 3 dimensional or even higher dimensional arrays you simply call the flat method multiple times. For example (3 dimensions):</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let arr = [1,2,[3,4,[5,6]]].flat().flat().flat();

console.log(arr);</code></pre>
</div>
</div>
</p>
<h2>Be careful!</h2>
<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat" rel="noreferrer"><code>Array.flat()</code></a> method is relatively new. Older browsers like ie might not have implemented the method. If you want you code to work on all browsers you might have to transpile your JS to an older version. Check for <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat" rel="noreferrer">MDN web docs</a> for current browser compatibility.</p>


blocks|key|341490|text|对于任何深度的嵌套数组，都可以使用带有Infinity的Array.flat()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|341491|​|341492|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]]]]+];

let+flatten+=+arr.flat(Infinity)

console.log(flatten)|code-block|syntax|javascript|341493|341494|请在此处查看浏览器compatibility|341495|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat#Browser_compatibility^0|J|8|S|C|J|8|0|S|C|1|0|0|0|0|9|D|2|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@$9|16|A|17|1|18]|$9|19|A|1A|1|1B]]|E|$]]|$1|F|3|G|5|6|7|1C|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|1E|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|P|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|Q|$R|$5|S|T|U|E|$V|W]]|X|$5|S|T|U|E|$V|Y]]|Z|$5|S|T|U|E|$V|10]]]]

<p>You can use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat" rel="noreferrer"><code>Array.flat()</code></a> with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity" rel="noreferrer"><code>Infinity</code></a> for any depth of nested array.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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]]]] ];

let flatten = arr.flat(Infinity)

console.log(flatten)</code></pre>
</div>
</div>
</p>

<p>check here for browser <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat#Browser_compatibility" rel="noreferrer">compatibility</a> </p>


blocks|key|342041|text|使用扩展运算符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342042|​|342043|const+input+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"]];
const+output+=+[].concat(...input);
console.log(output);+//+-->+["$6",+"$12",+"$25",+"$25",+"$18",+"$22",+"$10"]|code-block|syntax|javascript|342044|342045|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Using the spread operator:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]];
const output = [].concat(...input);
console.log(output); // --&gt; ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]</code></pre>
</div>
</div>
</p>


blocks|key|339424|text|如果只有一个字符串元素的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339425|[["$6"],+["$12"],+["$25"],+["$25"]].join(',').split(',');|code-block|syntax|javascript|339426|就能完成这项工作。与您的代码示例特别匹配的Bt。|339427|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>If you only have arrays with 1 string element:</p>

<pre><code>[["$6"], ["$12"], ["$25"], ["$25"]].join(',').split(',');
</code></pre>

<p>will do the job. Bt that specifically matches your code example.</p>


blocks|key|341038|text|一种类似Haskellesque的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341039|​|341040|function+flatArray([x,...xs]){
++return+x+?+[...Array.isArray(x)+?+flatArray(x)+:+[x],+...flatArray(xs)]+:+[];
}

var+na+=+[[1,2],[3,[4,5]],[6,7,[[[8],9]]],10];
++++fa+=+flatArray(na);
console.log(fa);|code-block|syntax|javascript|341041|341042|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>A Haskellesque approach</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function flatArray([x,...xs]){
  return x ? [...Array.isArray(x) ? flatArray(x) : [x], ...flatArray(xs)] : [];
}

var na = [[1,2],[3,[4,5]],[6,7,[[[8],9]]],10];
    fa = flatArray(na);
console.log(fa);</code></pre>
</div>
</div>
</p>


blocks|key|556804|text|ES6方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|556805|​|556806|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))|code-block|syntax|javascript|556807|556808|具有N次嵌套数组的ES3回退的flatten函数的ES5方式：|offset|length|style|CODE|556809|556810|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%2B%2B)+{
++++++++target+=+array[i];
++++++++arr+=+arr.concat(
++++++++++(Object.prototype.toString.call(target)+===+'[object+Array]')+?+flatten(target)+:+target
++++++++);
++++++}

++++++return+arr;
++++};
++}
}());

var+a+=+[1,+[2,+[3,+[4,+[5]]]]];
console.log(flatten(a));|556811|556812|entityMap^0|0|0|0|0|F|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@$L|10|M|11|N|O]]|9|@]|A|$]]|$1|P|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|S|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|U|$]]

<p>ES6 way:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="true">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const flatten = arr =&gt; arr.reduce((acc, next) =&gt; acc.concat(Array.isArray(next) ? flatten(next) : next), [])

const a = [1, [2, [3, [4, [5]]]]]
console.log(flatten(a))</code></pre>
</div>
</div>
</p>

<p>ES5 way for <code>flatten</code> function with ES3 fallback for N-times nested arrays:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var flatten = (function() {
  if (!!Array.prototype.reduce &amp;&amp; !!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 &lt; len; i++) {
        target = array[i];
        arr = arr.concat(
          (Object.prototype.toString.call(target) === '[object Array]') ? flatten(target) : target
        );
      }

      return arr;
    };
  }
}());

var a = [1, [2, [3, [4, [5]]]]];
console.log(flatten(a));</code></pre>
</div>
</div>
</p>


blocks|key|340082|text|var+arrays+=+[["a"],+["b",+"c"]];
Array.prototype.concat.apply([],+arrays);

//+gives+["a",+"b",+"c"]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|340083|(我只是根据@danhbear的评论，作为一个单独的答案来写这篇文章。)|unstyled|340084|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>var arrays = [["a"], ["b", "c"]];
Array.prototype.concat.apply([], arrays);

// gives ["a", "b", "c"]
</code></pre>

<p>(I'm just writing this as a separate answer, based on comment of @danhbear.)</p>


blocks|key|340975|text|我推荐一个节省空间的generator+function|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|340976|​|340977|function*+flatten(arr)+{
++if+(!Array.isArray(arr))+yield+arr;
++else+for+(let+el+of+arr)+yield*+flatten(el);
}

//+Example:
console.log(...flatten([1,[2,[3,[4]]]]));+//+1+2+3+4|code-block|syntax|javascript|340978|340979|如果需要，可以按如下方式创建平面值的数组：|340980|let+flattened+=+[...flatten([1,[2,[3,[4]]]])];+//+[1,+2,+3,+4]|340981|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*^0|A|I|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|C|$]]|$1|N|3|O|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

<p>I recommend a space-efficient <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*" rel="noreferrer">generator function</a>:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function* flatten(arr) {
  if (!Array.isArray(arr)) yield arr;
  else for (let el of arr) yield* flatten(el);
}

// Example:
console.log(...flatten([1,[2,[3,[4]]]])); // 1 2 3 4</code></pre>
</div>
</div>
</p>

<p>If desired, create an array of flattened values as follows:</p>

<pre><code>let flattened = [...flatten([1,[2,[3,[4]]]])]; // [1, 2, 3, 4]
</code></pre>


blocks|key|342381|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342382|var+array+=+[["$6"],+["$12","$16"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"]]
var+a+=+array.flat(Infinity);
console.log(a);|code-block|syntax|javascript|342383|342384|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var array = [["$6"], ["$12","$16"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]
var a = array.flat(Infinity);
console.log(a);</code></pre>
</div>
</div>
</p>


blocks|key|555400|text|这并不难，只需迭代数组并合并它们：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|555401|var+result+=+[],+input+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"]];

for+(var+i+=+0;+i+<+input.length;+%2B%2Bi)+{
++++result+=+result.concat(input[i]);
}|code-block|syntax|javascript|555402|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>That's not hard, just iterate over the arrays and merge them:</p>

<pre><code>var result = [], input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"]];

for (var i = 0; i &lt; input.length; ++i) {
    result = result.concat(input[i]);
}
</code></pre>


blocks|key|340128|text|我已经使用递归和闭包做到了这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340129|function+flatten(arr)+{

++var+temp+=+[];

++function+recursiveFlatten(arr)+{+
++++for(var+i+=+0;+i+<+arr.length;+i%2B%2B)+{
++++++if(Array.isArray(arr[i]))+{
++++++++recursiveFlatten(arr[i]);
++++++}+else+{
++++++++temp.push(arr[i]);
++++++}
++++}
++}
++recursiveFlatten(arr);
++return+temp;
}|code-block|syntax|javascript|340130|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I have done it using recursion and closures</p>

<pre><code>function flatten(arr) {

  var temp = [];

  function recursiveFlatten(arr) { 
    for(var i = 0; i &lt; arr.length; i++) {
      if(Array.isArray(arr[i])) {
        recursiveFlatten(arr[i]);
      } else {
        temp.push(arr[i]);
      }
    }
  }
  recursiveFlatten(arr);
  return temp;
}
</code></pre>


blocks|key|556305|text|前几天，我和ES6+Generators开玩笑，写了一篇this+gist。其中包含..。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|556306|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);|code-block|syntax|javascript|556307|基本上，我创建了一个生成器，它循环遍历原始输入数组，如果它找到一个数组，就会结合使用yield*运算符和递归来不断地扁平化内部数组。如果项不是数组，则只对单个项执行yields操作。然后使用ES6+Spread+operator+(也称为splat操作符)将生成器展平为一个新的数组实例。|556308|我还没有测试它的性能，但我认为这是一个使用生成器和收益*运算符的很好的简单示例。|556309|但再一次，我只是在开玩笑，所以我相信有更好的方法来做到这一点。|556310|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*|1|https://gist.github.com/ashwell/3dcc6702158604978d96|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield*|3|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield|4|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator^0|6|E|0|S|9|1|0|0|16|6|2|2A|6|3|2N|J|4|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]]|C|$]]|$1|D|3|E|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1C|8|@]|9|@$A|1D|B|1E|1|1F]|$A|1G|B|1H|1|1I]|$A|1J|B|1K|1|1L]]|C|$]]|$1|K|3|L|5|6|7|1M|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|1N|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]|Y|$5|R|S|T|C|$U|Z]]|10|$5|R|S|T|C|$U|11]]|12|$5|R|S|T|C|$U|13]]]]

<p>I was goofing with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*" rel="noreferrer">ES6 Generators</a> the other day and wrote <a href="https://gist.github.com/ashwell/3dcc6702158604978d96" rel="noreferrer">this gist</a>. Which contains...</p>

<pre><code>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);
</code></pre>

<p>Basically I'm creating a generator that loops over the original input array, if it finds an array it uses the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield*" rel="noreferrer">yield*</a> operator in combination with recursion to continually flatten the internal arrays. If the item is not an array it just <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield" rel="noreferrer">yields</a> the single item. Then using the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator" rel="noreferrer">ES6 Spread operator</a> (aka splat operator) I flatten out the generator into a new array instance.</p>

<p>I haven't tested the performance of this, but I figure it is a nice simple example of using generators and the yield* operator.</p>

<p>But again, I was just goofing so I'm sure there are more performant ways to do this.</p>


blocks|key|340502|text|这是最好的解决方案，不需要lodash|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340503|let+flatten+=+arr+=>+[].concat.apply([],+arr.map(item+=>+Array.isArray(item)+?+flatten(item)+:+item))|code-block|syntax|javascript|340504|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>just the best solution without lodash</p>

<pre><code>let flatten = arr =&gt; [].concat.apply([], arr.map(item =&gt; Array.isArray(item) ? flatten(item) : item))
</code></pre>


blocks|key|342077|text|下面是递归的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342078|function+flatten(arr){
++++let+newArray+=+[];
++++for(let+i=0;+i<+arr.length;+i%2B%2B){
++++++++if(Array.isArray(arr[i])){
++++++++++newArray+=++newArray.concat(flatten(arr[i]))
++++++++}else{
++++++++++newArray.push(arr[i])
++++++++}
++++}
++return+newArray;+
}

console.log(flatten([1,+2,+3,+[4,+5]+]));+//+[1,+2,+3,+4,+5]
console.log(flatten([[[[1],+[[[2]]],+[[[[[[[3]]]]]]]]]]))++//+[1,2,3]
console.log(flatten([[1],[2],[3]]))+//+[1,2,3]|code-block|syntax|javascript|342079|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is the recursive way...</p>

<pre><code>function flatten(arr){
    let newArray = [];
    for(let i=0; i&lt; arr.length; i++){
        if(Array.isArray(arr[i])){
          newArray =  newArray.concat(flatten(arr[i]))
        }else{
          newArray.push(arr[i])
        }
    }
  return newArray; 
}

console.log(flatten([1, 2, 3, [4, 5] ])); // [1, 2, 3, 4, 5]
console.log(flatten([[[[1], [[[2]]], [[[[[[[3]]]]]]]]]]))  // [1,2,3]
console.log(flatten([[1],[2],[3]])) // [1,2,3]
</code></pre>


blocks|key|556580|text|我提出了两个没有递归的简短解决方案。从计算复杂性的角度来看，它们并不是最优的，但在一般情况下工作得很好：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|556581|let+a+=+[1,+[2,+3],+[[4],+5,+6],+7,+8,+[9,+[[10]]]];

//+Solution+#1
while+(a.find(x+=>+Array.isArray(x)))
++++a+=+a.reduce((x,+y)+=>+x.concat(y),+[]);

//+Solution+#2
let+i+=+a.findIndex(x+=>+Array.isArray(x));
while+(i+>+-1)
{
++++a.splice(i,+1,+...a[i]);
++++i+=+a.findIndex(x+=>+Array.isArray(x));
}|code-block|syntax|javascript|556582|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I propose two short solutions without recursion. They are not optimal from a computational complexity point of view, but work fine in average cases:</p>

<pre><code>let a = [1, [2, 3], [[4], 5, 6], 7, 8, [9, [[10]]]];

// Solution #1
while (a.find(x =&gt; Array.isArray(x)))
    a = a.reduce((x, y) =&gt; x.concat(y), []);

// Solution #2
let i = a.findIndex(x =&gt; Array.isArray(x));
while (i &gt; -1)
{
    a.splice(i, 1, ...a[i]);
    i = a.findIndex(x =&gt; Array.isArray(x));
}
</code></pre>


blocks|key|340700|text|这里的逻辑是将输入数组转换为字符串，删除所有括号([])，并将输出解析为数组。为此，我使用了ES6模板功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340701|var+x=[1,+2,+[3,+4,+[5,+6,[7],+9],12,+[12,+14]]];

var+y=JSON.parse(`[${JSON.stringify(x).replace(/\[%7C]/g,'')}]`);

console.log(y)|code-block|syntax|javascript|340702|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>The logic here is to convert input array to string and remove all brackets([]) and parse output to array. I'm using ES6 template feature for this.</p>

<pre><code>var x=[1, 2, [3, 4, [5, 6,[7], 9],12, [12, 14]]];

var y=JSON.parse(`[${JSON.stringify(x).replace(/\[|]/g,'')}]`);

console.log(y)
</code></pre>


blocks|key|557626|text|如果您使用https://lodash.com/docs/4.17.14#flatten，您可以只使用它的flatten方法:+lodash|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|557627|lodash的好处是它也有一些方法来扁平化数组：|557628|i)递归：https://lodash.com/docs/4.17.14#flattenDeep|557629|ii)最多n层嵌套：https://lodash.com/docs/4.17.14#flattenDepth|557630|例如|557631|const+_+=+require("lodash");
const+pancake+=++_.flatten(array)|code-block|syntax|javascript|557632|entityMap|0|LINK|mutability|MUTABLE|url|https://lodash.com/docs/4.17.14#flatten|1|https://lodash.com/docs/4.17.14#flattenDeep|2|https://lodash.com/docs/4.17.14#flattenDepth^0|1H|7|5|13|0|0|0|5|17|1|0|A|18|2|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@]|D|@$9|1C|A|1D|1|1E]]|E|$]]|$1|J|3|K|5|6|7|1F|8|@]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|L|3|M|5|6|7|1J|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|1K|8|@]|D|@]|E|$Q|R]]|$1|S|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]|12|$5|V|W|X|E|$Y|13]]]]

<p>if you use lodash, you can just use its <code>flatten</code> method: <a href="https://lodash.com/docs/4.17.14#flatten" rel="nofollow noreferrer">https://lodash.com/docs/4.17.14#flatten</a></p>

<p>The nice thing about lodash is that it also has methods to flatten the arrays: </p>

<p>i) recursively: <a href="https://lodash.com/docs/4.17.14#flattenDeep" rel="nofollow noreferrer">https://lodash.com/docs/4.17.14#flattenDeep</a></p>

<p>ii) upto n levels of nesting: <a href="https://lodash.com/docs/4.17.14#flattenDepth" rel="nofollow noreferrer">https://lodash.com/docs/4.17.14#flattenDepth</a></p>

<p>For example</p>

<pre><code>const _ = require("lodash");
const pancake =  _.flatten(array)
</code></pre>


blocks|key|558112|text|我认为array.flat是一个完美的解决方案。但是平面函数是一个相对较新的函数，可能不能在较旧版本的浏览器中运行。我们可以使用递归函数来解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|558113|​|558114|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))|code-block|syntax|javascript|558115|558116|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>I think array.flat(Infinity) is a perfect solution. But flat function is a relatively new function and may not run in older versions of browsers. We can use recursive function for solving this.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const arr = ["A", ["B", [["B11", "B12", ["B131", "B132"]], "B2"]], "C", ["D", "E", "F", ["G", "H", "I"]]]
const flatArray = (arr) =&gt; {
    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))</code></pre>
</div>
</div>
</p>


blocks|key|340912|text|const+flatten+=+array+=>+array.reduce((a,+b)+=>+a.concat(Array.isArray(b)+?+flatten(b)+:+b),+[]);+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|340913|对于每个请求，分解一行基本上就是这样。|unstyled|340914|function+flatten(array)+{
++//+reduce+traverses+the+array+and+we+return+the+result
++return+array.reduce(function(acc,+b)+{
+++++//+if+is+an+array+we+use+recursion+to+perform+the+same+operations+over+the+array+we+found+
+++++//+else+we+just+concat+the+element+to+the+accumulator
+++++return+acc.concat(+Array.isArray(b)+?+flatten(b)+:+b);
++},+[]);+//+we+initialize+the+accumulator+on+an+empty+array+to+collect+all+the+elements
}|340915|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>const flatten = array =&gt; array.reduce((a, b) =&gt; a.concat(Array.isArray(b) ? flatten(b) : b), []); 
</code></pre>

<p>Per request, Breaking down the one line is basically having this. </p>

<pre><code>function flatten(array) {
  // reduce traverses the array and we return the result
  return array.reduce(function(acc, b) {
     // if is an array we use recursion to perform the same operations over the array we found 
     // else we just concat the element to the accumulator
     return acc.concat( Array.isArray(b) ? flatten(b) : b);
  }, []); // we initialize the accumulator on an empty array to collect all the elements
}
</code></pre>


blocks|key|341513|text|这是一个基于artif3x回答的Typescript版本，并为Scala迷提供了一个额外的flatMap实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|341514|function+flatten<T>(items:+T[][]):+T[]+{
++return+items.reduce((prev,+next)+=>+prev.concat(next),+[]);
}

function+flatMap<T,+U>(items:+T[],+f:+(t:+T)+=>+U[]):+U[]+{
++return+items.reduce((prev,+next)+=>+prev.concat(f(next)),+new+Array<U>());
}|code-block|syntax|javascript|341515|entityMap^0|19|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<p>Here is a version in Typescript based on the answer by artif3x, with a bonus implementation of <code>flatMap</code> for Scala fans.</p>

<pre><code>function flatten&lt;T&gt;(items: T[][]): T[] {
  return items.reduce((prev, next) =&gt; prev.concat(next), []);
}

function flatMap&lt;T, U&gt;(items: T[], f: (t: T) =&gt; U[]): U[] {
  return items.reduce((prev, next) =&gt; prev.concat(f(next)), new Array&lt;U&gt;());
}
</code></pre>


blocks|key|342159|text|function+flatten(input)+{
++let+result+=+[];
++
++function+extractArrayElements(input)+{
++++for(let+i+=+0;+i+<+input.length;+i%2B%2B){
++++++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]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|342160|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function flatten(input) {
  let result = [];
  
  function extractArrayElements(input) {
    for(let i = 0; i &lt; 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]
</code></pre>


blocks|key|342256|text|在Node环境中，如果您版本不支持Array.prototype.flat，但您使用的是es6或ts，那么您可以这样做|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|342257|​|342258|const+arrays+=+[
++["$6"],
++["$12"],
++["$25"],
++["$25"],
++["$18"],
++["$22"],
++["$10"]
];
const+merged+=+[].concat(...arrays);

console.log(merged);|code-block|syntax|javascript|342259|342260|entityMap^0|H|K|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|T|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|O|$]]

<p>In Node environment, if your version is not support <code>Array.prototype.flat</code> but you use es6 or ts, then you can do like this</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const arrays = [
  ["$6"],
  ["$12"],
  ["$25"],
  ["$25"],
  ["$18"],
  ["$22"],
  ["$10"]
];
const merged = [].concat(...arrays);

console.log(merged);</code></pre>
</div>
</div>
</p>


blocks|key|555787|text|这是另一个适用于现代浏览器的深度扁平化：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|555788|function+flatten(xs)+{
++xs+=+Array.prototype.concat.apply([],+xs);
++return+xs.some(Array.isArray)+?+flatten(xs)+:+xs;
};|code-block|syntax|javascript|555789|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here's another deep flatten for modern browsers:</p>

<pre><code>function flatten(xs) {
  xs = Array.prototype.concat.apply([], xs);
  return xs.some(Array.isArray) ? flatten(xs) : xs;
};
</code></pre>


blocks|key|555844|text|如果您的数组只包含整数或字符串，您可以使用这个肮脏的技巧：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|555845|var+arr+=+[345,2,[34],2,[524,[5456]],[5456]];
var+flat+=+arr.toString().split(',');|code-block|syntax|javascript|555846|Works，在FF，IE和Chrome还没有测试其他浏览器。|555847|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>if your array only consists out of integers or strings you can use this dirty hack:</p>

<pre><code>var arr = [345,2,[34],2,[524,[5456]],[5456]];
var flat = arr.toString().split(',');
</code></pre>

<p>Works, in FF, IE and Chrome didn't test the other browsers yet.</p>


blocks|key|339910|text|要在一行中展平二维数组，请执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|339911|[[1,+2],+[3,+4,+5]].reduce(Function.prototype.apply.bind(Array.prototype.concat))
//+=>+[+1,+2,+3,+4,+5+]|code-block|syntax|javascript|339912|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>To flatten a two-dimensional array in one line:</p>

<pre><code>[[1, 2], [3, 4, 5]].reduce(Function.prototype.apply.bind(Array.prototype.concat))
// =&gt; [ 1, 2, 3, 4, 5 ]
</code></pre>


blocks|key|340007|text|我知道这有些老生常谈，但我所知道的展平数组(任何深度)的方法必须简洁！字符串(不带逗号！)将数组转换为字符串，然后用逗号拆分字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340008|var+myArray+=[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"],+["$0"],+["$15"],["$3"],+["$75"],+["$5"],+["$100"],+["$7"],+["$3"],+["$75"],+["$5"]];
var+myFlatArray+=+myArray.toString().split(',');

myFlatArray;
//+["$6",+"$12",+"$25",+"$25",+"$18",+"$22",+"$10",+"$0",+"$15",+"$3",+"$75",+"$5",+"$100",+"$7",+"$3",+"$75",+"$5"]|code-block|syntax|javascript|340009|这应该适用于只包含字符串和数字(整数和浮点数)的任何深度的嵌套数组，但需要注意的是，数字将在该过程中转换为字符串。这可以通过一个小映射来解决：|340010|var+myArray+=[[[1,2],[3,4]],[[5,6],[7,8]],[[9,0]]];
var+myFlatArray+=+myArray.toString().split(',').map(function(e)+{+return+parseInt(e);+});
myFlatArray;
//+[1,+2,+3,+4,+5,+6,+7,+8,+9,+0]|340011|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>I'm aware that this is hacky, but the must succinct way I know of to flatten an array(of any depth!) of strings(without commas!) is to turn the array into a string and then split the string on commas:</p>

<pre><code>var myArray =[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];
var myFlatArray = myArray.toString().split(',');

myFlatArray;
// ["$6", "$12", "$25", "$25", "$18", "$22", "$10", "$0", "$15", "$3", "$75", "$5", "$100", "$7", "$3", "$75", "$5"]
</code></pre>

<p>This should work on any depth of nested arrays containing only strings and numbers(integers and floating points) with the caveat that numbers will be converted to strings in the process. This can be solved with a little mapping:</p>

<pre><code>var myArray =[[[1,2],[3,4]],[[5,6],[7,8]],[[9,0]]];
var myFlatArray = myArray.toString().split(',').map(function(e) { return parseInt(e); });
myFlatArray;
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
</code></pre>


blocks|key|340666|text|/**
*+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]);
++},+[]);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|340667|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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


/**
* flatten an array recursively
* @method flattenDeep
* @param array {Array}
* @return {Array} flatten array
*/
function flattenDeep(array) {
  return array.reduce((acc, current) =&gt; {
    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) =&gt; {
    return Array.isArray(current) ? acc.concat(flattenDepth(current, --depth)) : acc.concat([current]);
  }, []);
}
</code></pre>


blocks|key|557157|text|只是为了添加更好的解决方案。我使用递归来解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|557158|++++++++++++const+flattenArray+=+()+=>+{
++++++++++++++++let+result+=+[];
++++++++++++++++return+function+flatten(arr)+{
++++++++++++++++++++for+(let+i+=+0;+i+<+arr.length;+i%2B%2B)+{
++++++++++++++++++++++++if+(!Array.isArray(arr[i]))+{
++++++++++++++++++++++++++++result.push(arr[i]);
++++++++++++++++++++++++}+else+{
++++++++++++++++++++++++++++flatten(arr[i])
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++return+result;
++++++++++++++++}
++++++++++++}|code-block|syntax|javascript|557159|测试结果：https://codepen.io/ashermike/pen/mKZrWK|offset|length|557160|entityMap|0|LINK|mutability|MUTABLE|url|https://codepen.io/ashermike/pen/mKZrWK^0|0|0|5|13|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>Just to add to the great solutions. I used recursion to solve this.</p>

<pre><code>            const flattenArray = () =&gt; {
                let result = [];
                return function flatten(arr) {
                    for (let i = 0; i &lt; arr.length; i++) {
                        if (!Array.isArray(arr[i])) {
                            result.push(arr[i]);
                        } else {
                            flatten(arr[i])
                        }
                    }
                    return result;
                }
            }
</code></pre>

<p>Test results: <a href="https://codepen.io/ashermike/pen/mKZrWK" rel="nofollow noreferrer">https://codepen.io/ashermike/pen/mKZrWK</a></p>


blocks|key|341607|text|我编写简单扁平化实用程序|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341608|const+flatten+=+(arr,+result+=+[])+=>+{
++++if+(!Array.isArray(arr)){
++++++++return+[...result,+arr];
++++}
+++++arr.forEach((a)+=>+{
+++++++++result+=+flatten(a,+result)
++++})

++++return+result
}

console.log(flatten([1,[2,3],+[4,[5,6,[7,8]]]]))+//+[+1,+2,+3,+4,+5,+6,+7,+8+]|code-block|syntax|javascript|341609|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Simple flatten util i've written</p>

<pre><code>const flatten = (arr, result = []) =&gt; {
    if (!Array.isArray(arr)){
        return [...result, arr];
    }
     arr.forEach((a) =&gt; {
         result = flatten(a, result)
    })

    return result
}

console.log(flatten([1,[2,3], [4,[5,6,[7,8]]]])) // [ 1, 2, 3, 4, 5, 6, 7, 8 ]
</code></pre>


blocks|key|341855|text|此解决方案适用于任何深度级别的数组(指定嵌套数组结构应该有多深)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341856|function+flatten(obj)+{
++++var+out+=+[];
++++function+cleanElements(input)+{
++++++++for+(var+i++in+input){
++++++++++++if+(input[i]instanceof+Array){
++++++++++++++++cleanElements(input[i]);
++++++++++++}
++++++++++++else+{
++++++++++++++++out.push(input[i]);
++++++++++++}
++++++++}
++++}
++++cleanElements(obj);
++++return+(out);
}|code-block|syntax|javascript|341857|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>This solution will work for any depth level (specifying how deep a nested array structure should be) of array.</p>

<pre><code>function flatten(obj) {
    var out = [];
    function cleanElements(input) {
        for (var i  in input){
            if (input[i]instanceof Array){
                cleanElements(input[i]);
            }
            else {
                out.push(input[i]);
            }
        }
    }
    cleanElements(obj);
    return (out);
}
</code></pre>


blocks|key|558330|text|只需使用扩展运算符，我们就可以按以下方式展平。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|558331|​|558332|var+OriginalArray+=+[[5,+1],+[6],+[2],+[8]];
var+newArray+=+[];

for+(let+i+=+0;+i+<+OriginalArray.length;+i%2B%2B)+{
++newArray.push(...OriginalArray[i]);
}

console.log(newArray)|code-block|syntax|javascript|558333|558334|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Simply using spread operator we can flatten in the following way.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var OriginalArray = [[5, 1], [6], [2], [8]];
var newArray = [];

for (let i = 0; i &lt; OriginalArray.length; i++) {
  newArray.push(...OriginalArray[i]);
}

console.log(newArray)</code></pre>
</div>
</div>
</p>


blocks|key|555753|text|[1,[2,3],[4,[5,6]]].reduce(function(p,+c)+{
++++return+p.concat(c+instanceof+Array+?+
++++++++++++++++++++c.reduce(arguments.callee,+[])+:+
++++++++++++++++++++[c]);+
},+[]);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|555754|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>[1,[2,3],[4,[5,6]]].reduce(function(p, c) {
    return p.concat(c instanceof Array ? 
                    c.reduce(arguments.callee, []) : 
                    [c]); 
}, []);
</code></pre>


blocks|key|340476|text|可以使用Array.prototype.reduce()和Array.prototype.concat()展平数组的数组|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|340477|​|340478|var+data+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"],+["$0"],+["$15"],["$3"],+["$75"],+["$5"],+["$100"],+["$7"],+["$3"],+["$75"],+["$5"]].reduce(function(a,+b)+{
++return+a.concat(b);
},+[]);
console.log(data);|code-block|syntax|javascript|340479|340480|相关文档：https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/concat|340481|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce|340482|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/concat|1^0|4|O|T|O|0|0|0|0|5|2I|0|0|0|2L|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|P|3|Q|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|R|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|S|$T|$5|U|V|W|E|$X|Y]]|Z|$5|U|V|W|E|$X|Q]]]]

<p>You can flatten an array of arrays using <code>Array.prototype.reduce()</code> and <code>Array.prototype.concat()</code></p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var data = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]].reduce(function(a, b) {
  return a.concat(b);
}, []);
console.log(data);</code></pre>
</div>
</div>
</p>

<p>Related docs:
<a href="https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/concat" rel="nofollow">https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/concat</a></p>

<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce" rel="nofollow">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce</a></p>


blocks|key|340539|text|我最初考虑使用.reduce方法并递归调用一个函数来展平内部数组，但是当您处理一个由深度嵌套数组组成的深度嵌套数组时，这可能会导致堆栈溢出。使用concat也不是最好的方法，因为每次迭代都会创建一个新的浅层数组副本。我们可以做的是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|340540|const+flatten+=+arr+=>+{
++++for(let+i+=+0;+i+<+arr.length;)+{
++++++++const+val+=+arr[i];
++++++++if(Array.isArray(val))+{
++++++++++++arr.splice(i,+1,+...val);
++++++++}+else+{
++++++++++++i+%2B%2B;
++++++++}
++++}
++++return+arr;
}|code-block|syntax|javascript|340541|我们不会通过concat创建新的数组，也不会递归调用任何函数。|340542|http://jsbin.com/firiru/4/edit?js,console|340543|entityMap|0|LINK|mutability|MUTABLE|url^0|7|7|0|0|0|0|15|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Z|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|N]]]]

<p>I originally thought to use the <code>.reduce</code> method and recursively call a function to flatten inner arrays, however this can lead to stack overflows when you are working with a deeply nested array of deeply nested arrays. Using concat is also not the best way to go, because each iteration will create a new shallow copy of the array. What we can do instead is this:</p>

<pre><code>const flatten = arr =&gt; {
    for(let i = 0; i &lt; arr.length;) {
        const val = arr[i];
        if(Array.isArray(val)) {
            arr.splice(i, 1, ...val);
        } else {
            i ++;
        }
    }
    return arr;
}
</code></pre>

<p>We are not creating new arrays via concat and we are not recursively calling any functions.</p>

<p><a href="http://jsbin.com/firiru/4/edit?js,console" rel="nofollow noreferrer">http://jsbin.com/firiru/4/edit?js,console</a></p>


blocks|key|556659|text|适用于所有数据类型的递归版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|556660|+/*jshint+esversion:+6+*/

//+nested+array+for+testing
let+nestedArray+=+["firstlevel",+32,+"alsofirst",+["secondlevel",+456,"thirdlevel",+["theinnerinner",+345,+{firstName:+"Donald",+lastName:+"Duck"},+"lastinner"]]];

//+wrapper+function+to+protect+inner+variable+tempArray+from+global+scope;
function+flattenArray(arr)+{

++let+tempArray+=+[];

++function+flatten(arr)+{
++++arr.forEach(function(element)+{
++++++Array.isArray(element)+?+flatten(element)+:+tempArray.push(element);+++++//+ternary+check+that+calls+flatten()+again+if+element+is+an+array,+hereby+making+flatten()+recursive.
++++});
++}

++//+calling+the+inner+flatten+function,+and+then+returning+the+temporary+array
++flatten(arr);
++return+tempArray;
}

//+example+usage:
let+flatArray+=+flattenArray(nestedArray);|code-block|syntax|javascript|556661|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Recursive version that works on all datatypes</p>

<pre><code> /*jshint esversion: 6 */

// nested array for testing
let nestedArray = ["firstlevel", 32, "alsofirst", ["secondlevel", 456,"thirdlevel", ["theinnerinner", 345, {firstName: "Donald", lastName: "Duck"}, "lastinner"]]];

// wrapper function to protect inner variable tempArray from global scope;
function flattenArray(arr) {

  let tempArray = [];

  function flatten(arr) {
    arr.forEach(function(element) {
      Array.isArray(element) ? flatten(element) : tempArray.push(element);     // ternary check that calls flatten() again if element is an array, hereby making flatten() recursive.
    });
  }

  // calling the inner flatten function, and then returning the temporary array
  flatten(arr);
  return tempArray;
}

// example usage:
let flatArray = flattenArray(nestedArray);
</code></pre>


blocks|key|341067|text|下面的代码将展平深度嵌套的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341068|/**
+*+[Function+to+flatten+deeply+nested+array]
+*+@param++{[type]}+arr++++++++++[The+array+to+be+flattened]
+*+@param++{[type]}+flattenedArr+[The+flattened+array]
+*+@return+{[type]}++++++++++++++[The+flattened+array]
+*/
function+flattenDeepArray(arr,+flattenedArr)+{
++let+length+=+arr.length;

++for(let+i+=+0;+i+<+length;+i%2B%2B)+{
++++if(Array.isArray(arr[i]))+{
++++++flattenDeepArray(arr[i],+flattenedArr);
++++}+else+{
++++++flattenedArr.push(arr[i]);
++++}
++}

++return+flattenedArr;
}

let+arr+=+[1,+2,+[3,+4,+5],+[6,+7]];

console.log(arr,+'=>',+flattenDeepArray(arr,+[]));+//+[+1,+2,+[+3,+4,+5+],+[+6,+7+]+]+'=>'+[+1,+2,+3,+4,+5,+6,+7+]

arr+=+[1,+2,+[3,+4],+[5,+6,+[7,+8,+[9,+10]]]];

console.log(arr,+'=>',+flattenDeepArray(arr,+[]));+//+[ 1, 2, [ 3, 4 ], [ 5, 6, [ 7, 8, [Object] ] ] ] '=>' [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]|code-block|syntax|javascript|341069|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>The following code will flatten deeply nested arrays:</p>

<pre><code>/**
 * [Function to flatten deeply nested array]
 * @param  {[type]} arr          [The array to be flattened]
 * @param  {[type]} flattenedArr [The flattened array]
 * @return {[type]}              [The flattened array]
 */
function flattenDeepArray(arr, flattenedArr) {
  let length = arr.length;

  for(let i = 0; i &lt; length; i++) {
    if(Array.isArray(arr[i])) {
      flattenDeepArray(arr[i], flattenedArr);
    } else {
      flattenedArr.push(arr[i]);
    }
  }

  return flattenedArr;
}

let arr = [1, 2, [3, 4, 5], [6, 7]];

console.log(arr, '=&gt;', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4, 5 ], [ 6, 7 ] ] '=&gt;' [ 1, 2, 3, 4, 5, 6, 7 ]

arr = [1, 2, [3, 4], [5, 6, [7, 8, [9, 10]]]];

console.log(arr, '=&gt;', flattenDeepArray(arr, [])); // [ 1, 2, [ 3, 4 ], [ 5, 6, [ 7, 8, [Object] ] ] ] '=&gt;' [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
</code></pre>


blocks|key|557050|text|您可以继续使用Array.flat()方法来实现这一点，即使数组的嵌套程度更高。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|557051|[1,2,3,[2]].flat()+|code-block|syntax|javascript|557052|等同于|557053|[1,2,3,[2]].flat(1)|557054|因此，随着嵌套的增加，您可以继续增加嵌套数量。|557055|例如：|557056|[1,[2,[3,[4]]]].flat(3)+//+[1,+2,+3,+4]|557057|如果您不确定嵌套的级别，您可以将Infinity作为参数传递|557058|[1,2,3,[2,[3,[3,[34],43],[34]]]].flat(Infinity)+//[1,+2,+3,+2,+3,+3,+34,+43,+34]|557059|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

<p>You can just keep on using Array.flat() method to achieve this even when array is a lot more nested.</p>

<pre><code>[1,2,3,[2]].flat() 
</code></pre>

<p>is equivalent to </p>

<pre><code>[1,2,3,[2]].flat(1)
</code></pre>

<p>so as your nesting increases you can keep on increasing number.</p>

<p>eg: </p>

<pre><code>[1,[2,[3,[4]]]].flat(3) // [1, 2, 3, 4]
</code></pre>

<p>And if you are not sure about level of nesting you can just pass Infinity as parameter</p>

<pre><code>[1,2,3,[2,[3,[3,[34],43],[34]]]].flat(Infinity) //[1, 2, 3, 2, 3, 3, 34, 43, 34]
</code></pre>


blocks|key|341192|text|let+arr+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"],+["$0"],+["$15"],["$3"],+["$75"],+["$5"],+["$100"],+["$7"],+["$3"],+["$75"],+["$5"]];
arr+=+arr.reduce((a,+b)+=>+a.concat(b));+//+flattened|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|341193|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>let arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];
arr = arr.reduce((a, b) =&gt; a.concat(b)); // flattened
</code></pre>


blocks|key|557821|text|由于ES2019引入了flat和flatMap，然后是flat，所以任何数组都可以像这样完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|557822|const+myArr+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"]]
const+myArrFlat=+myArr.flat(Infinity);
console.log(myArrFlat);+//+["$6",+"$12",+"$25",+...]|code-block|syntax|javascript|557823|参考https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat|offset|length|557824|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat^0|0|0|2|2J|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>Since ES2019 has introduced flat and flatMap then flat any array can be done like this:</p>

<pre><code>const myArr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]
const myArrFlat= myArr.flat(Infinity);
console.log(myArrFlat); // ["$6", "$12", "$25", ...]
</code></pre>

<p>Ref. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat" rel="nofollow noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat</a></p>


blocks|key|557894|text|递归调用deepFlatten函数，这样我们就可以在不使用任何外部帮助器方法的情况下扩展内部数组。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|557895|const+innerArr+=+['a',+'b'];
const+multiDimArr+=+[[1,+2],+3,+4,+[5,+6,+innerArr],+9];

const+deepFlatten+=+(arr)+=>+{
++const+flatList+=+[];
++arr.forEach(item+=>+{
++++Array.isArray(item)
+++++?+flatList.push(...deepFlatten(item))+//+recursive+call
+++++:+flatList.push(item)
++});
++return+flatList;
}|code-block|syntax|javascript|557896|entityMap^0|4|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<p>Recursively calling the <code>deepFlatten</code> function so we can spread the inner array without using any external helper method is the way to go.</p>

<pre><code>const innerArr = ['a', 'b'];
const multiDimArr = [[1, 2], 3, 4, [5, 6, innerArr], 9];

const deepFlatten = (arr) =&gt; {
  const flatList = [];
  arr.forEach(item =&gt; {
    Array.isArray(item)
     ? flatList.push(...deepFlatten(item)) // recursive call
     : flatList.push(item)
  });
  return flatList;
}
</code></pre>


blocks|key|558071|text|只需一行代码即可解决此问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|558072|​|558073|function+unflatten(arr){
++++return+arr.reduce((prevProps,+nextProps)+=>+{
++++++++return+prevProps.concat(Array.isArray(nextProps)+?+unflatten(nextProps)+:+nextProps)
++++},+[])
}|code-block|syntax|javascript|558074|558075|https://codepen.io/jyotishman/pen/BayVeoQ|offset|length|558076|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|0|15|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@$L|Z|M|10|1|11]]|A|$]]|$1|N|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|K]]]]

<p>solve this problem using single line of code..</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function unflatten(arr){
    return arr.reduce((prevProps, nextProps) =&gt; {
        return prevProps.concat(Array.isArray(nextProps) ? unflatten(nextProps) : nextProps)
    }, [])
}</code></pre>
</div>
</div>
</p>

<p><a href="https://codepen.io/jyotishman/pen/BayVeoQ" rel="nofollow noreferrer">https://codepen.io/jyotishman/pen/BayVeoQ</a></p>


blocks|key|342137|text|使用此方法展开两个数组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342138|arr1.concat(...arr2);|code-block|syntax|javascript|342139|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Use this method to flat two arrays</p>
<pre><code>arr1.concat(...arr2);
</code></pre>


blocks|key|342337|text|这是使用堆栈的非递归展平深度的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342338|++++function+flatten(input)+{
++++++++const+stack+=+[...input];
++++++++const+res+=+[];
++++++++while+(stack.length)+{
++++++++++++const+next+=+stack.pop();
++++++++++++if+(Array.isArray(next))+{
++++++++++++++++stack.push(...next);
++++++++++++}+else+{
++++++++++++++++res.push(next);
++++++++++++}
++++++++}
++++++++return+res.reverse();
++++}
++++const+arrays+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"]];
++++flatten(arrays);|code-block|syntax|javascript|342339|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here is the solution non recursive flatten deep using a stack.</p>
<pre><code>    function flatten(input) {
        const stack = [...input];
        const res = [];
        while (stack.length) {
            const next = stack.pop();
            if (Array.isArray(next)) {
                stack.push(...next);
            } else {
                res.push(next);
            }
        }
        return res.reverse();
    }
    const arrays = [[&quot;$6&quot;], [&quot;$12&quot;], [&quot;$25&quot;], [&quot;$25&quot;], [&quot;$18&quot;], [&quot;$22&quot;], [&quot;$10&quot;]];
    flatten(arrays);
</code></pre>


blocks|key|556173|text|如果您需要支持IE8，因此不能使用诸如reduce或isArray之类的方法，那么这里有一个可能的解决方案。这是一个冗长的方法，可以帮助您理解递归算法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|556174|function+flattenArray(a){

++++var+aFinal+=+[];

++++(function+recursiveArray(a){

++++++++var+i,
++++++++++++iCount+=+a.length;

++++++++if+(Object.prototype.toString.call(a)+===+'[object+Array]')+{
++++++++++++for+(i+=+0;+i+<+iCount;+i+%2B=+1){
++++++++++++++++recursiveArray(a[i]);
++++++++++++}
++++++++}+else+{
++++++++++++aFinal.push(a);
++++++++}

++++})(a);

++++return+aFinal;

}

var+aMyArray+=+[6,3,4,[12,14,15,[23,24,25,[34,35],27,28],56],3,4];

var+result+=+flattenArray(aMyArray);

console.log(result);|code-block|syntax|javascript|556175|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>If you need to support IE8 and, therefore, can't use methods such as reduce or isArray, here is a possible solution. It is a verbose approach to help you to understand the recursive algorithm.</p>

<pre><code>function flattenArray(a){

    var aFinal = [];

    (function recursiveArray(a){

        var i,
            iCount = a.length;

        if (Object.prototype.toString.call(a) === '[object Array]') {
            for (i = 0; i &lt; iCount; i += 1){
                recursiveArray(a[i]);
            }
        } else {
            aFinal.push(a);
        }

    })(a);

    return aFinal;

}

var aMyArray = [6,3,4,[12,14,15,[23,24,25,[34,35],27,28],56],3,4];

var result = flattenArray(aMyArray);

console.log(result);
</code></pre>


blocks|key|340389|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340390|var+arrays+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"],+["$0"],+["$15"],["$3"],+["$75"],+["$5"],+["$100"],+["$7"],+["$3"],+["$75"],+["$5"]];
var+merged+=+[].concat.apply([],+arrays);
alert(merged);|code-block|syntax|javascript|340391|340392|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var arrays = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"], ["$0"], ["$15"],["$3"], ["$75"], ["$5"], ["$100"], ["$7"], ["$3"], ["$75"], ["$5"]];
var merged = [].concat.apply([], arrays);
alert(merged);</code></pre>
</div>
</div>
</p>


blocks|key|556358|text|Array.prototype.flatten+=+Array.prototype.flatten+%7C%7C+function()+{
++++return+[].reduce.call(this,+function(flat,+toFlatten)+{
++++++++return+flat.concat(Array.isArray(toFlatten)+?+toFlatten.flatten()+:+toFlatten);
++++},[])
};|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|556359|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>Array.prototype.flatten = Array.prototype.flatten || function() {
    return [].reduce.call(this, function(flat, toFlatten) {
        return flat.concat(Array.isArray(toFlatten) ? toFlatten.flatten() : toFlatten);
    },[])
};
</code></pre>


blocks|key|556757|text|当展平不是很深的时候，我没有在这里找到大型数组的解决方案。所以，我的版本是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|556758|function+flatten(arr){
++++result+=+[]
++++for+(e+of+arr)
++++++++result.push(...e)
++++return+result
}|code-block|syntax|javascript|556759|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I didn't find here solution for large arrays when flattening is not deep. So, my version:</p>

<pre><code>function flatten(arr){
    result = []
    for (e of arr)
        result.push(...e)
    return result
}
</code></pre>


blocks|key|557091|text|尝试这种方法，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|557092|​|557093|arr+=+[["$6"],+["$12"],+["$25"],+["$25"],+["$18"],+["$22"],+["$10"]]
concat_arr+=+arr.concat.apply([],+arr)
console.log(concat_arr)|code-block|syntax|javascript|557094|557095|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>try this method,</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]
concat_arr = arr.concat.apply([], arr)
console.log(concat_arr)</code></pre>
</div>
</div>
</p>


blocks|key|341276|text|我只用ES6回答这个问题，假设深度数组是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|341277|const+deepArray+=+['1',[['a'],['b']],[2],[[[['4',[3,'c']]]],[5]]];|code-block|syntax|javascript|341278|如果您知道或猜测数组的深度不超过7这样的数字，请使用以下代码：|341279|const+flatArray+=+deepArray.flat(7);|341280|但是如果你不知道深度数组的深度，或者你的JavaScript引擎不像react-native+JavaScriptCore那样支持flat，那么可以使用下面的函数，它使用了JavaScript的reduce函数：|341281|+const+deepFlatten+=+arr+=>
+++++++++arr.reduce(
+++++++++++(acc,+val)+=>
+++++++++++++Array.isArray(val)+
+++++++++++++++?+acc.concat(deepFlatten(val))+
+++++++++++++++:+acc.concat(val),
+++++++++++++[]
+++++++++);|341282|这两个方法都会在result下面返回：|341283|["1",+"a",+"b",+2,+"4",+3,+"c",+5]|341284|entityMap^0|3|3|0|0|G|1|0|0|K|A|Y|C|1B|E|1T|4|2E|A|2P|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1K|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1L|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|X|$]]

<p>I answer this question just with <code>ES6</code>, assume the deep array is:</p>

<pre><code>const deepArray = ['1',[['a'],['b']],[2],[[[['4',[3,'c']]]],[5]]];
</code></pre>

<p>If you know or guess the depth of your arrays is not more than a number like <code>7</code>, use below code:</p>

<pre><code>const flatArray = deepArray.flat(7);
</code></pre>

<p>But if you don't know the depth of your deep arrays or your <code>JavaScript</code> engine doesn't support <code>flat</code> like <code>react-native</code> <code>JavaScriptCore</code>, use below function that is used <code>JavaScript</code> <code>reduce</code> function:</p>

<pre><code> const deepFlatten = arr =&gt;
         arr.reduce(
           (acc, val) =&gt;
             Array.isArray(val) 
               ? acc.concat(deepFlatten(val)) 
               : acc.concat(val),
             []
         );
</code></pre>

<p>Both of methods return below result:</p>

<pre><code>["1", "a", "b", 2, "4", 3, "c", 5]
</code></pre>


blocks|key|341369|text|我有一个简单的解决方案，不需要在特殊的js函数中使用。(如reduce等)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341370|const+input+=+[[0,+1],+[2,+3],+[4,+5]]
let+flattened=[];

for+(let+i=0;+i<input.length;+%2B%2Bi)+{
++++let+current+=+input[i];
++++for+(let+j=0;+j<current.length;+%2B%2Bj)
++++++++flattened.push(current[j]);
}|code-block|syntax|javascript|341371|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I have a simple solution without using in a special js function. (like reduce etc)</p>

<pre><code>const input = [[0, 1], [2, 3], [4, 5]]
let flattened=[];

for (let i=0; i&lt;input.length; ++i) {
    let current = input[i];
    for (let j=0; j&lt;current.length; ++j)
        flattened.push(current[j]);
}
</code></pre>


blocks|key|341421|text|更简单和直截了当的一个；选择深度扁平化；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|341422|const+flatReduce+=+(arr,+deep)+=>+{
++++return+arr.reduce((acc,+cur)+=>+{
++++++++return+acc.concat(Array.isArray(cur)+&&+deep+?+flatReduce(cur,+deep)+:+cur);
++++},+[]);
};

console.log(flatReduce([1,+2,+[3],+[4,+[5]]],+false));+//+=>++1,2,3,4,[5]
console.log(flatReduce([1,+2,+[3],+[4,+[5,+[6,+7,+8]]]],+true));+//+=>+1,2,3,4,5,6,7,8|code-block|syntax|javascript|341423|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Much simpler and straight-forward one; with option to deep flatten;</p>

<pre><code>const flatReduce = (arr, deep) =&gt; {
    return arr.reduce((acc, cur) =&gt; {
        return acc.concat(Array.isArray(cur) &amp;&amp; deep ? flatReduce(cur, deep) : cur);
    }, []);
};

console.log(flatReduce([1, 2, [3], [4, [5]]], false)); // =&gt;  1,2,3,4,[5]
console.log(flatReduce([1, 2, [3], [4, [5, [6, 7, 8]]]], true)); // =&gt; 1,2,3,4,5,6,7,8
</code></pre>


blocks|key|342348|text|const+arr+=+[1,+2,+[3,+4]];

arr.reduce((acc,+val)+=>+acc.concat(val),+[]);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|342349|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>const arr = [1, 2, [3, 4]];

arr.reduce((acc, val) =&gt; acc.concat(val), []);

</code></pre>


blocks|key|342399|text|let+arr+=+[1,+[2,+3,+[4,+5,+[6,+7],+[8,+9,+10,+11,+12]]]];

function+flattenList(nestedArr)+{
++let+newFlattenList+=+[];

++const+handleFlat+=+(array)+=>+{
++++let+count+=+0;
++++while+(count+<+array.length)+{
++++++let+item+=+array[count];
++++++if+(Array.isArray(item))+{
++++++++handleFlat(item);
++++++}+else+{
++++++++newFlattenList.push(item);
++++++}
++++++count%2B%2B;
++++}
++};
++handleFlat(nestedArr);
++return+newFlattenList;
}`enter+code+here`

console.log(flattenList(arr));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|342400|CodeSandBox+Link|unstyled|offset|length|342401|entityMap|0|LINK|mutability|MUTABLE|url|https://codesandbox.io/s/flatten-array-javascript-xijsvr?file=/src/index.js^0|0|0|G|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@$G|S|H|T|1|U]]|A|$]]|$1|I|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

<pre><code>let arr = [1, [2, 3, [4, 5, [6, 7], [8, 9, 10, 11, 12]]]];

function flattenList(nestedArr) {
  let newFlattenList = [];

  const handleFlat = (array) =&gt; {
    let count = 0;
    while (count &lt; array.length) {
      let item = array[count];
      if (Array.isArray(item)) {
        handleFlat(item);
      } else {
        newFlattenList.push(item);
      }
      count++;
    }
  };
  handleFlat(nestedArr);
  return newFlattenList;
}`enter code here`

console.log(flattenList(arr));
</code></pre>
<p><a href="https://codesandbox.io/s/flatten-array-javascript-xijsvr?file=/src/index.js" rel="nofollow noreferrer">CodeSandBox Link</a></p>


blocks|key|556229|text|我认为最好的方法是这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|556230|var+flatten+=+function+()+{
++return+[].slice.call(arguments).toString().split(',');
};|code-block|syntax|javascript|556231|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I believe that the best way to do this would be something like this:</p>

<pre><code>var flatten = function () {
  return [].slice.call(arguments).toString().split(',');
};
</code></pre>


blocks|key|557580|text|ES6的纯粹魔力|type|unstyled|depth|inlineStyleRanges|entityRanges|data|557581|const+flat+=+A+=>+A.reduce((A,+a)+=>+Array.isArray(a)+?+[...A,+...flat(a)]+:+[...A,+a],+[]);|code-block|syntax|javascript|557582|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Sheer Magic of ES6</p>

<pre><code>const flat = A =&gt; A.reduce((A, a) =&gt; Array.isArray(a) ? [...A, ...flat(a)] : [...A, a], []);
</code></pre>


blocks|key|339946|text|使用there中的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|339947|我会写道：|339948|myArray.enumerable().selectMany(function(x)+{+return+x;+}).array()|code-block|syntax|javascript|339949|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codeproject.com/Tips/805364/LINQ-for-JavaScript^0|2|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<p>Using code from <a href="http://www.codeproject.com/Tips/805364/LINQ-for-JavaScript" rel="nofollow">there</a>.</p>

<p>I would write:</p>

<pre><code>myArray.enumerable().selectMany(function(x) { return x; }).array()
</code></pre>


blocks|key|340432|text|我只是在寻找一种更快更简单的解决方案来做这件事，为什么？因为我把这个作为一个面试问题，我很好奇，所以我做了这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|340433|function+flattenArrayOfArrays(a,+r){
++++if(!r){+r+=+[]}
++++for(var+i=0;+i<a.length;+i%2B%2B){
++++++++if(a[i].constructor+==+Array){
++++++++++++flattenArrayOfArrays(a[i],+r);
++++++++}else{
++++++++++++r.push(a[i]);
++++++++}
++++}
++++return+r;
}

var+i+=+[[1,2,[3]],4,[2,3,4,[4,[5]]]],+output;

//+Start+timing+now
console.time("flatten");
output+=+new+Array(JSON.stringify(i).replace(/[%5E\w\s,]/g,""));+
output
//+...+and+stop.
console.timeEnd("flatten");

//+Start+timing+now
console.time("flatten2");
output+=+[].concat.apply([],+i)
output
//+...+and+stop.
console.timeEnd("flatten2");

//+Start+timing+now
console.time("flatten3");
output+=+flattenArrayOfArrays(i)
output
//+...+and+stop.
console.timeEnd("flatten3");|code-block|syntax|javascript|340434|我在这里使用了最流行的答案和我的解决方案。我猜有人会觉得这很有趣。干杯!|340435|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>I was just looking for the faster and easy solution to do this, why? because I get this as a one interview question and I got curious, so I made this:</p>

<pre><code>function flattenArrayOfArrays(a, r){
    if(!r){ r = []}
    for(var i=0; i&lt;a.length; i++){
        if(a[i].constructor == Array){
            flattenArrayOfArrays(a[i], r);
        }else{
            r.push(a[i]);
        }
    }
    return r;
}

var i = [[1,2,[3]],4,[2,3,4,[4,[5]]]], output;

// Start timing now
console.time("flatten");
output = new Array(JSON.stringify(i).replace(/[^\w\s,]/g,"")); 
output
// ... and stop.
console.timeEnd("flatten");

// Start timing now
console.time("flatten2");
output = [].concat.apply([], i)
output
// ... and stop.
console.timeEnd("flatten2");

// Start timing now
console.time("flatten3");
output = flattenArrayOfArrays(i)
output
// ... and stop.
console.timeEnd("flatten3");
</code></pre>

<p>I used the most popular answers here and my solution. I guess somebody will find this interesting. Cheers!</p>


<p>I have a JavaScript array like:</p>

<pre><code>[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]
</code></pre>

<p>How would I go about merging the separate inner arrays into one like:</p>

<pre><code>["$6", "$12", "$25", ...]
</code></pre>


Merge/flatten an array of arrays

JSON

我有一个像这样的JavaScript数组：[["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]我该如何将独立的内部数组合并成一个这样的数组：["$6", "$12", "$25", ...]

问合并/展平数组的数组
EN

回答 65

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问合并/展平数组的数组EN

回答 65

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问合并/展平数组的数组
EN