다음과 같은 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);

applyof 메소드를 사용하면 concat두 번째 매개 변수를 배열로 사용하므로 마지막 줄은 다음과 같습니다.

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

Array.prototype.flat()배열을 평평하게하는 데 사용할 수 있는 방법 (ES2019에 도입 됨)도 있지만 Internet Explorer에서는 버전 11부터 Node.js에서만 사용할 수 있지만 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);
    

다음은 최신 JavaScript 배열 메소드 중 일부를 사용하여 n 차원 배열을 평탄화하는 간단한 함수입니다.

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

용법:

flatten([[1, 2, 3], [4, 5]]); // [1, 2, 3, 4, 5]
flatten([[[1, [1.1]], 2, 3], [4, 5]]); // [1, 1.1, 2, 3, 4, 5]

혼란스럽게 숨겨져있는 메소드가 있는데,이 메소드는 원래 배열을 변경하지 않고 새 배열을 구성합니다.

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

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

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 바이올린

모질라 문서

이를 위해 flat 이라는 새로운 기본 메소드가 있습니다 .

(2019 년 말 flat현재 ECMA 2019 표준으로 출판되었으며, core-js@3(바벨 라이브러리)는 해당 폴리 필 라이브러리 에 포함합니다 )

const arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

// Flatten 2 levels deep
const arr3 = [2, 2, 5, [5, [5, [6]], 7]];
arr3.flat(2);
// [2, 2, 5, 5, 5, [6], 7];

// Flatten all levels
const arr4 = [2, 2, 5, [5, [5, [6]], 7]];
arr4.flat(Infinity);
// [2, 2, 5, 5, 5, 6, 7];

여기의 대부분의 답변은 거대한 (예 : 200,000 요소) 배열에서는 작동하지 않으며 그렇게하더라도 느립니다. polkovnikov.ph의 답변 이 최고의 성능을 발휘하지만 심층 평 평화에는 효과가 없습니다.

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

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

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

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

function flatten(arr) {
  return [].concat(...arr)
}

단순히 확장 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로 변환됩니다.

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

var x = [[1], [2], [3, 4]];

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

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

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입니다.

전화 obliterate하거나 nuke이름이 마음에 들지 않을 수 deepFlatten있습니다.

두 번 반복하지 마십시오!

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

내가 부르는 신뢰할 수있는 결합 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 ]

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

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

사용 reduce(callback[, initialValue])방법은 어떻습니까JavaScript 1.8

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

일을 할 것입니다.

기능적 스타일의 또 다른 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) );

단일 요소 배열의 배열을 평면화하려면 라이브러리를 가져올 필요가 없습니다. 간단한 루프는 가장 간단하고 효율적인 솔루션입니다.

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

downvoters : 질문을 읽고, 매우 다른 문제에 맞지 않기 때문에 downvote하지 마십시오. 이 솔루션은 질문에 가장 빠르고 간단합니다.

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

제발 참고 하면 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));

커리 양식, 함수 구성 및 고차 함수의 작은 화살표 함수에 익숙해 지 자마자이 코드는 산문처럼 읽습니다. 프로그래밍은 부작용을 포함하지 않기 때문에 항상 예상대로 작동하는 작은 빌딩 블록을 구성하는 것입니다.

ES6 한 줄 평평

참조 lodash 펼치기 , 밑줄 펼치기 (얕은를 true)

function flatten(arr) {
  return arr.reduce((acc, e) => acc.concat(e), []);
}

또는

function flatten(arr) {
  return [].concat.apply([], arr);
}

테스트

test('already flatted', () => {
  expect(flatten([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});

test('flats first level', () => {
  expect(flatten([1, [2, [3, [4]], 5]])).toEqual([1, 2, [3, [4]], 5]);
});

ES6 한 줄 깊이 평평

lodash flattenDeep 참조 , 밑줄 평탄화

function flattenDeep(arr) {
  return arr.reduce((acc, e) => Array.isArray(e) ? acc.concat(flattenDeep(e)) : acc.concat(e), []);
}

테스트

test('already flatted', () => {
  expect(flattenDeep([1, 2, 3, 4, 5])).toEqual([1, 2, 3, 4, 5]);
});

test('flats', () => {
  expect(flattenDeep([1, [2, [3, [4]], 5]])).toEqual([1, 2, 3, 4, 5]);
});

당신은 사용할 수 있습니다 Array.flat()와 Infinity중첩 된 배열의 깊이.

var arr = [ [1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2,3,4,[1,2,3,4]]], [[1,2,3,4], [1,2,[1,2,3]], [1,2,3,4,5,[1,2,3,4,[1,2,3,4]]]] ];

let flatten = arr.flat(Infinity)

console.log(flatten)

브라우저 호환성에 대해서는 여기를 확인하십시오

Haskellesque 접근

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

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

flattenN 배 중첩 배열에 대한 ES3 폴백 기능을 위한 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));

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

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

일을 할 것입니다. Bt는 코드 예제와 특별히 일치합니다.

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

// gives ["a", "b", "c"]

(@danhbear의 의견에 따라 별도의 답변으로 작성하고 있습니다.)

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

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]

오히려 전체 배열을 그대로 문자열로 변환하지만 다른 답변과 달리 원하지 않는 결과를 생성하는 메서드 를 사용 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)

코드 스 니펫 실행결과 숨기기

스 니펫 확장

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

새로운 Array.Flat()방법을 시도 할 수도 있습니다 . 다음과 같은 방식으로 작동합니다.

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

console.log(arr);

이 flat()방법은 모든 하위 배열 요소를 깊이가 1 레이어까지 반복적으로 연결된 새 배열을 만듭니다 (예 : 배열 내부 배열).

3 차원 또는 더 높은 차원의 배열을 평면화하려면 flat 메소드를 여러 번 호출하면됩니다. 예를 들어 (3 차원) :

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

console.log(arr);

조심해!

Array.Flat()방법은 비교적 새로운 방법입니다. 예를 들어 이전 브라우저는 메소드를 구현하지 않았을 수 있습니다. 코드를 모든 브라우저에서 작동 시키려면 JS를 이전 버전으로 변환해야 할 수도 있습니다. 최신 브라우저 호환성에 대해서는 MD 웹 문서를 확인하십시오.

스프레드 연산자 사용 :

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

그것은 어렵지 않습니다. 배열을 반복하고 병합하십시오.

var result = [], input = [["$6"], ["$12"], ["$25"], ["$25"], ["$18"]];

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

이것이 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] 

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

function flatten(arr) {

  var temp = [];

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

나는 며칠 전에 ES6 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 * 연산자를 사용하는 좋은 예라고 생각합니다.

그러나 다시, 나는 방황하고 있었기 때문에 이것을 수행하는 더 효과적인 방법이 있다고 확신합니다.

lodash가없는 최고의 솔루션

let flatten = arr => [].concat.apply([], arr.map(item => Array.isArray(item) ? flatten(item) : item))