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

Antwoord 4, autoriteit 10%

Het kan het beste worden gedaan met de Javascript-reduceerfunctie.

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

Of, met ES2015:

arrays = arrays.reduce((a, b) => a.concat(b), []);

js-fiddle

Mozilla-documenten

Antwoord 5, autoriteit 7%

Er is een nieuwe native methode genaamd flatom dit precies te doen.

(Vanaf eind 2019 is flatnu gepubliceerd in de ECMA 2019-standaard, en core-js@3(bibliotheek van babel) neemt het op in hun polyfill bibliotheek)

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

Antwoord 6, autoriteit 4%

De meeste antwoorden hier werken niet op enorme (bijvoorbeeld 200 000 elementen) arrays, en zelfs als ze dat wel doen, zijn ze traag. polkovnikov.ph’s antwoordlevert de beste prestaties, maar werkt niet voor diepe afvlakking.

Hier is de snelste oplossing, die ook werkt op arrays met meerdere nestingniveaus:

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

Voorbeelden

Enorme arrays

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

Het verwerkt grote arrays prima. Op mijn computer duurt het ongeveer 14 ms om deze code uit te voeren.

Geneste arrays

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

Het werkt met geneste arrays. Deze code produceert [1, 1, 1, 1, 1, 1, 1, 1].

Arrays met verschillende nestingniveaus

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

Het heeft geen problemen met het afvlakken van arrays zoals deze.

Antwoord 7, autoriteit 3%

Update: het bleek dat deze oplossing niet werkt met grote arrays. Als je op zoek bent naar een betere, snellere oplossing, bekijk dan dit antwoord.

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

Is breidt eenvoudig arruit en geeft het als argumenten door aan concat(), die alle arrays in één samenvoegt. Het is gelijk aan [].concat.apply([], arr).

Je kunt dit ook proberen voor diepe afvlakking:

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

Bekijk demo op JSBin.

Referenties voor ECMAScript 6-elementen die in dit antwoord worden gebruikt:

• Spread-operator
• Pijlfuncties

Kanttekening: methoden zoals find()en pijlfuncties worden niet door alle browsers ondersteund, maar dit betekent niet dat u deze functies op dit moment niet kunt gebruiken. Gebruik gewoon Babel— het transformeert ES6-code in ES5.

Antwoord 8, autoriteit 2%

U kunt Underscoregebruiken:

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

Antwoord 9, autoriteit 2%

Algemene procedures zorgen ervoor dat we de complexiteit niet elke keer hoeven te herschrijven als we een specifiek gedrag moeten gebruiken.

concatMap(of flatMap) is precies wat we nodig hebben in deze situatie.

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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