У меня есть массив 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);

Использование applyметода concatпросто примет второй параметр в качестве массива, поэтому последняя строка идентична этой:

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

Вот короткая функция, которая использует некоторые из новых методов массива 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 ]

Лучше всего это сделать с помощью функции сокращения JavaScript.

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-скрипка

Документы Mozilla

Для этого существует новый нативный метод 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];

Большинство ответов здесь не работают с огромными (например, 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]));

Он отлично справляется с огромными массивами. На моей машине выполнение этого кода занимает около 14 мс.

Вложенные массивы

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

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.

Вы можете использовать Underscore :

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последующего вызова to .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;
}

Чтобы сгладить массив массивов из одного элемента, вам не нужно импортировать библиотеку, простой цикл является и самым простым, и наиболее эффективным решением:

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

Для даунвотеров: пожалуйста, прочитайте вопрос, не понизьте голос, потому что это не устраивает вашу совсем другую проблему. Это решение является самым быстрым и простым для задаваемого вопроса.

Как насчет использования 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), доступную в последних выпусках современных браузеров. Благодаря @ (Константин Ван) и @ (Марк Эмери) упомянули это в комментариях.

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

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 One Line Flatten

См. 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 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]);
});

Вы можете использовать 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)

проверьте здесь для совместимости браузера

Хаскельский подход

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

Способ ES5 для flattenфункции с ES3 откатом для N-кратных вложенных массивов:

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 слоя глубины (т.е. массивы внутри массивов)

Если вы также хотите сгладить трехмерные или даже более многомерные массивы, вы просто вызываете метод flat несколько раз. Например (3 измерения):

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

console.log(arr);

Быть осторожен!

Array.Flat()метод относительно новый. Старые браузеры, такие как ie, возможно, не реализовали этот метод. Если вы хотите, чтобы ваш код работал во всех браузерах, вам, возможно, придется перенести 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]);
}

Похоже, это похоже на работу для рекурсии!

• Обрабатывает несколько уровней вложенности
• Обрабатывает пустые массивы и не массив параметров
• Не имеет мутации
• Не полагается на современные функции браузера

Код:

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 *.

Но опять же, я был просто дураком, так что я уверен, что есть более эффективные способы сделать это.

просто лучшее решение без лодаш

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