배열 배열 병합/평면화

질문자 :Andy

다음과 같은 JavaScript 배열이 있습니다.

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

별도의 내부 배열을 다음과 같이 병합하는 방법은 무엇입니까?

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

concat 을 사용하여 배열을 병합할 수 있습니다.

 var arrays = [ ["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"] ]; var merged = [].concat.apply([], arrays); console.log(merged);

concat apply 방법을 사용하면 두 번째 매개변수를 배열로 사용하므로 마지막 줄은 다음과 동일합니다.

 var merged2 = [].concat(["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]);

---

Array.prototype.flat() 메서드(ES2019에 도입됨)도 있습니다. 이 메서드는 Node.js 버전 11부터 사용할 수 있고 Internet Explorer에서는 전혀 사용할 수 없지만 배열을 병합하는 데 사용할 수 있습니다.

 const arrays = [ ["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"] ]; const merge3 = arrays.flat(1); //The depth level specifying how deep a nested array structure should be flattened. Defaults to 1. console.log(merge3);

Gumbo

다음은 n차원 배열을 평면화하기 위해 새로운 JavaScript 배열 방법 중 일부를 사용하는 짧은 함수입니다.

 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]

Noah Freitas

원래 배열을 변경하지 않고 새 배열을 구성하는 혼란스럽게 숨겨진 방법이 있습니다.

 var oldArray = [[1],[2,3],[4]]; var newArray = Array.prototype.concat.apply([], oldArray); console.log(newArray); // [ 1, 2, 3, 4 ]

Nikita Volkov

자바스크립트 축소 기능으로 가장 잘 수행할 수 있습니다.

 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), []);

js 바이올린

모질라 문서

user2668376

이를 정확하게 수행하기 위해 flat 이라는 새로운 기본 메서드가 있습니다.

(2019년 말 flat 은 ECMA 2019 표준에 게시되었으며 core-js@3 (babel의 라이브러리)은 이를 polyfill 라이브러리 에 포함합니다)

 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];

Alister

여기에 있는 대부분의 답변은 거대한(예: 200,000개 요소) 배열에서 작동하지 않으며 작동하더라도 느립니다. polkovnikov.ph의 대답 은 최고의 성능을 가지고 있지만 깊은 평탄화에는 작동하지 않습니다.

다음은 여러 수준의 중첩이 있는 배열에서도 작동하는 가장 빠른 솔루션입니다 .

 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]));

거대한 배열을 잘 처리합니다. 내 컴퓨터에서 이 코드를 실행하는 데 약 14ms가 걸립니다.

중첩 배열

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

중첩 배열과 함께 작동합니다. 이 코드는 [1, 1, 1, 1, 1, 1, 1, 1] 합니다.

중첩 수준이 다른 배열

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

이와 같은 배열을 평평하게 하는 데에는 아무런 문제가 없습니다.

Michał Perłakowski

업데이트: 이 솔루션은 대형 어레이에서 작동하지 않는 것으로 나타났습니다. 더 빠르고 더 나은 솔루션을 찾고 있다면 이 답변을 확인하세요.

---

 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로 변환합니다.

Michał Perłakowski

밑줄 을 사용할 수 있습니다.

 var x = [[1], [2], [3, 4]]; _.flatten(x); // => [1, 2, 3, 4]

Todd Yandell

일반 절차는 특정 동작을 사용해야 할 때마다 복잡성을 다시 작성할 필요가 없다는 것을 의미합니다.

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 // flatten :: [[a]] -> [a] const flatten = concatMap (id) // your sample data 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) => players // Game :: (Team, Team) -> Game const Game = (teamA, teamB) => [ teamA, teamB ] // sample data 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 // flatten :: [[a]] -> [a] const flatten = concatMap (id) // deepFlatten :: [[a]] -> [a] const deepFlatten = concatMap (x => Array.isArray (x) ? deepFlatten (x) : x) // your sample data 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이라는 이름이 deepFlatten obliterate 또는 nuke 라고 부를 수 있습니다.

---

두 번 반복하지 마십시오!

물론 위의 구현은 영리하고 간결하지만 .map 다음에 .reduce 호출을 사용하면 실제로 필요한 것보다 더 많은 반복을 수행하고 있음을 의미합니다.

신뢰할 수 있는 결합 mapReduce 사용하여 mapReduce라고 부르며 반복을 최소화하는 데 도움이 됩니다. 매핑 함수 m :: a -> b , 환원 함수 r :: (b,a) ->b 취하여 새로운 환원 함수를 반환합니다. 이 결합기는 변환기 의 핵심입니다. 관심이 있으시면 그에 대한 다른 답변을 작성했습니다.

 // 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) // your sample data 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 ]

Mulan

단일 요소 배열의 배열을 병합하기 위해 라이브러리를 가져올 필요가 없습니다. 간단한 루프가 가장 간단하고 효율적인 솔루션입니다.

 for (var i = 0; i < a.length; i++) { a[i] = a[i][0]; }

반대 투표자: 질문을 읽고 매우 다른 문제에 적합하지 않기 때문에 반대 투표를 하지 마십시오. 이 솔루션은 질문에 대해 가장 빠르고 간단합니다.

Denys Séguret

배열에 배열이 아닌 요소가 있을 수 있는 보다 일반적인 경우에 대한 솔루션입니다.

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

Trindaz

JavaScript 1.8 reduce(callback[, initialValue]) 메서드를 사용하는 것은 어떻습니까?

 list.reduce((p,n) => p.concat(n),[]);

일을 할 것입니다.

rab

기능적 스타일의 또 다른 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( flatten([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] 

 let arr = [1, 2, [3, 4]]; console.log( arr.flat() ); arr = [1, 2, [3, 4, [5, 6]]]; console.log( arr.flat() ); console.log( arr.flat(1) ); console.log( arr.flat(2) ); console.log( arr.flat(Infinity) );

diziaq

const common = arr.reduce((a, b) => [...a, ...b], [])

YairTawil

Array.flat() 메서드를 사용해 볼 수도 있습니다. 다음과 같은 방식으로 작동합니다.

 let arr = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]].flat() console.log(arr);

flat() 메서드는 깊이의 1 레이어(즉, 배열 내부의 배열)까지 재귀적으로 연결된 모든 하위 배열 요소가 있는 새 배열을 만듭니다.

3차원 또는 더 높은 차원의 배열도 평면화하려면 평면 메서드를 여러 번 호출하기만 하면 됩니다. 예(3차원):

 let arr = [1,2,[3,4,[5,6]]].flat().flat().flat(); console.log(arr);

조심하세요!

Array.flat() 메서드는 비교적 새롭습니다. ie와 같은 이전 브라우저는 이 방법을 구현하지 않았을 수 있습니다. 코드가 모든 브라우저에서 작동하도록 하려면 JS를 이전 버전으로 변환해야 할 수 있습니다. 현재 브라우저 호환성에 대해서는 MDN 웹 문서 를 확인하십시오.

Willem van der Veen

중첩 배열의 모든 깊이에 대해 Infinity 와 함께 Array.flat() 를 사용할 수 있습니다.

 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 Maniac

참고: Function.prototype.apply ( [].concat.apply([], arrays) ) 또는 확산 연산자( [].concat(...arrays) )를 사용하면 둘 다 함수의 모든 인수가 스택에 저장되기 때문에 큰 배열의 경우 스택 오버플로가 발생합니다.

다음은 가장 중요한 요구 사항을 서로 비교하는 기능적 스타일의 스택 안전 구현입니다.

• 재사용 성
• 가독성
• 간결
• 성능

 // small, reusable auxiliary functions: const foldl = f => acc => xs => xs.reduce(uncurry(f), acc); // aka reduce const uncurry = f => (a, b) => f(a) (b); const concat = xs => y => xs.concat(y); // the actual function to flatten an array - a self-explanatory one-line: const flatten = xs => foldl(concat) ([]) (xs); // arbitrary array sizes (until the heap blows up :D) const xs = [[1,2,3],[4,5,6],[7,8,9]]; console.log(flatten(xs)); // Deriving a recursive solution for deeply nested arrays is trivially now // yet more small, reusable auxiliary functions: const map = f => xs => xs.map(apply(f)); const apply = f => a => f(a); const isArray = Array.isArray; // the derived recursive function: const flattenr = xs => flatten(map(x => isArray(x) ? flattenr(x) : x) (xs)); const ys = [1,[2,[3,[4,[5],6,],7],8],9]; console.log(flattenr(ys));

커리 형식의 작은 화살표 함수, 함수 구성 및 고차 함수에 익숙해지면 이 코드는 산문처럼 읽힙니다. 그런 다음 프로그래밍은 부작용이 없기 때문에 항상 예상대로 작동하는 작은 빌딩 블록을 모으는 것으로 구성됩니다.

user6445533

ES6 한 줄 병합

lodash flatten , 밑줄 flatten 참조 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 One Line Deep Flatten

lodash flattenDeep , 밑줄 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]); });

zurfyx

스프레드 연산자 사용:

 const input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"], ["$22"], ["$10"]]; const output = [].concat(...input); console.log(output); // --> ["$6", "$12", "$25", "$25", "$18", "$22", "$10"]

Catfish

문자열 요소가 1개인 배열만 있는 경우:

 [["$6"], ["$12"], ["$25"], ["$25"]].join(',').split(',');

일을 할 것입니다. 귀하의 코드 예제와 구체적으로 일치하는 Bt.

Florian Salihovic

하스켈레스크 접근

 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);

Redu

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))

N배 중첩 배열에 대한 ES3 폴백이 있는 flatten 기능을 위한 ES5 방법:

 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) : target ); } return arr; }; } }()); var a = [1, [2, [3, [4, [5]]]]]; console.log(flatten(a));

Artem Gavrysh

var arrays = [["a"], ["b", "c"]]; Array.prototype.concat.apply([], arrays); // gives ["a", "b", "c"]

(나는 이것을 @danhbear의 의견을 기반으로 별도의 답변으로 쓰고 있습니다.)

VasiliNovikov

공간 효율적인 생성기 기능을 권장합니다.

 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

원하는 경우 다음과 같이 병합된 값의 배열을 만듭니다.

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

le_m

배열을 평평하게 만드는 2가지 방법이 있습니다.

* 1- Array.prototype.flat 메서드를 사용할 수 있는 첫 번째 방법

 const veryDeep = [[1, [2, 2, [3, [4, [5, [6]]]]], 1]]; veryDeep.flat(Infinity) // [1, 2, 2, 3, 4, 5, 6, 1] /** If you don't know the depth of the array, simply pass Infinity **\

또는 배열이 얼마나 중첩되어 있는지 안다면 인수를 넣을 수 있습니다.

 const twoLevelsDeep = [[1, [2, 2], 1]]; //depth = 1 twoLevelsDeep.flat(); [1, [2, 2], 1] //depth = 2 twoLevelsDeep.flat(2); // [1, 2, 2, 1]

* ES6에서 스프레드 연산자를 사용하여 배열을 평면화할 수 있는 2초 방법과 연결은 중첩된 수에 관계없이 배열을 평면화합니다

 const multidimension = [, [, , ], , [, ]]; [].concat(...multidimension); // This will return: [, , , , , , ] const multidimension = [1, [2, 3, 4], 5, [6, 7]]; [].concat(...multidimension); // This will return: [1, 2, 3, 4, 5, 6, 7]

Yazan Najjar

차라리 전체 배열을 있는 그대로 문자열로 변환하고 싶지만 다른 답변과 달리 JSON.stringify 를 사용하고 toString() 메서드를 사용하지 않아 원하지 않는 결과를 생성합니다.

JSON.stringify 출력을 사용하여 남은 것은 모든 대괄호를 제거하고 결과를 시작 및 종료 대괄호로 다시 래핑하고 문자열을 "생명"으로 되돌리는 JSON.parse

• 속도 비용 없이 무한 중첩 배열을 처리할 수 있습니다.
• 쉼표가 포함된 문자열인 배열 항목을 올바르게 처리할 수 있습니다.

 var arr = ["abc",[[[6]]],["3,4"],"2"]; var s = "[" + JSON.stringify(arr).replace(/\[|]/g,'') +"]"; var flattened = JSON.parse(s); console.log(flattened)

• 문자열/숫자의 다차원 배열에만 해당(객체 제외)

vsync

어렵지 않습니다. 배열을 반복하고 병합하기만 하면 됩니다.

 var result = [], input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"]]; for (var i = 0; i < input.length; ++i) { result = result.concat(input[i]); }

Niko

이것은 RECURSION의 작업처럼 보입니다!

• 여러 수준의 중첩 처리
• 빈 배열과 배열이 아닌 매개변수를 처리합니다.
• 돌연변이가 없다
• 최신 브라우저 기능에 의존하지 않음

암호:

 var flatten = function(toFlatten) { var isArray = Object.prototype.toString.call(toFlatten) === '[object Array]'; if (isArray && toFlatten.length > 0) { var head = toFlatten[0]; var tail = toFlatten.slice(1); return flatten(head).concat(flatten(tail)); } else { return [].concat(toFlatten); } };

용법:

 flatten([1,[2,3],4,[[5,6],7]]); // Result: [1, 2, 3, 4, 5, 6, 7]

Jai

재귀와 클로저를 사용하여 수행했습니다.

 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; }

balajivijayan

나는 요전에 ES6 Generators를 가지고 놀다가 이 요지를 썼습니다. 포함하는...

 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* 연산자를 재귀와 함께 사용하여 내부 배열을 지속적으로 평평하게 만듭니다. 항목이 배열이 아니면 단일 항목 만 산출합니다. 그런 다음 ES6 Spread 연산자 (일명 splat 연산자)를 사용하여 생성기를 새 배열 인스턴스로 병합합니다.

이 성능을 테스트하지는 않았지만 생성기와 yield* 연산자를 사용하는 좋은 간단한 예라고 생각합니다.

그러나 다시 말하지만, 나는 단지 바보짓을 하고 있었기 때문에 이것을 할 수 있는 더 효과적인 방법이 있다고 확신합니다.

ashwell

출처 : http:www.stackoverflow.com/questions/10865025/merge-flatten-an-array-of-arrays