¿Hay alguna manera fácil de hacer que la matriz anidada sea plana?

Question

Eso es hacer esto:

[ ['dog','cat', ['chicken', 'bear'] ],['mouse','horse'] ]

en:

['dog','cat','chicken','bear','mouse','horse']

Answer 1

var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) { 
    return a.concat(b); 
}); 
// flattened is [0, 1, 2, 3, 4, 5] 

Es nota digna que reducen ISN No es compatible con IE 8 y versiones anteriores.

developer.mozilla.org reference

Answer 2

Un enfoque que podría tomar sería, usando la biblioteca JSON2:

1. JSON.stringify la matriz
2. Stri p out todo, excepto el primero y el último [ y ] (o quítelos todos y vuelva a agregar los de inicio y final).
3. JSON.parse de nuevo a una matriz de JavaScript

estoy suponiendo, por supuesto, usted no está comenzando con una matriz de JavaScript. Si es una cadena, los pasos 1 y 3 son irrelevantes.

Answer 3

Toma underscore.js y utiliza la función flatten.

_.flatten([ ['dog','cat', ['chicken', 'bear'] ],['mouse','horse'] ]); 

Answer 4

Suponiendo un array que ya está desempaquetado de JSON, intente esto:

Array.prototype.flatten = function() { 
    var r = []; 
    for (var i = 0; i < this.length; ++i) { 
     var v = this[i]; 
     if (v instanceof Array) { 
      Array.prototype.push.apply(this, v.flatten()); 
     } else { 
      r.push(v); 
     } 
    } 
    return r; 
}; 

Parece que funciona correctamente en su entrada - ver http://jsfiddle.net/alnitak/Ws7L5/

Answer 5

En los navegadores modernos se puede hacer esto sin ninguna biblioteca externa en unas pocas líneas:

Array.prototype.flatten = function() { 
    return this.reduce(function(prev, cur) { 
    var more = [].concat(cur).some(Array.isArray); 
    return prev.concat(more ? cur.flatten() : cur); 
    },[]); 
}; 

console.log([['dog','cat',['chicken', 'bear']],['mouse','horse']].flatten()); 
//^ ["dog", "cat", "chicken", "bear", "mouse", "horse"] 

Answer 6

Pequeño solución para solución ChewOnThis_Trident y funciona perfecto:

Array.prototype.flatten = function() { 
    return this.reduce(function(a, b) { 
     return a.concat(b); 
    }, []); 
}; 

Answer 7

I Sé que esto es tarde, pero también me encontré con una situación en la que necesitaba hacer una matriz multidimensional en 1 matriz e hice una función de la siguiente manera.

function nested(arr) { 
    var noNest = arr.toString().split(',').filter(Boolean), 
     i = 0; 

    for(i;i<noNest.length; i++){ 
     if(isNaN(noNest[i])){ 
      return console.log(noNest); 
     } else { 
      noNest[i] = parseInt(noNest[i]); 
     } 
    } 
    return console.log(noNest); 
} 

nested([[['a']], [['b']]]); 

Esto también tomar las matrices anidadas dentro de la matriz probado y se asegura de su una matriz como el último out puso

Answer 8

¿Qué hay de éste código de revestimiento?

[ ['dog','cat', ['chicken', 'bear'] ],[['mouse','horse'],'lion'] ].join().split(',') 

básicamente se unen hará cadena separada por comas de matriz anidada y el uso de la división se pueden obtener matriz 1d, bonita? bono que va a trabajar en todos los navegadores, así :)

lo que la salida será: -

["dog", "cat", "chicken", "bear", "mouse", "horse", "lion"] 

Answer 9

Esta solución ha estado trabajando muy bien para mí, y me resulta particularmente fácil de seguir:

function flattenArray(arr) { 
    // the new flattened array 
    var newArr = []; 

    // recursive function 
    function flatten(arr, newArr) { 
    // go through array 
    for (var i = 0; i < arr.length; i++) { 
     // if element i of the current array is a non-array value push it 
     if (Array.isArray(arr[i]) === false) { 
     newArr.push(arr[i]); 
     } 
     // else the element is an array, so unwrap it 
     else { 
     flatten(arr[i], newArr); 
     } 
    } 
    } 

    flatten(arr, newArr); 

    return newArr; 
} 

Answer 10

Por eso me encanta javascript:

function flattenArray(source) { 
    return source.toString().split(','); 
} 

flattenArray([['dog', 'cat', ['chicken', 'bear']], ['mouse', 'horse']]); 
// -> ['dog','cat','chicken','bear','mouse','horse'] 

Answer 11

También puede usar este array-flatMap componente de fuente abierta.

Ejemplo:

flatMap([[1, 2, 3], [4, 5, 6]], val => val) // => [1, 2, 3, 4, 5, 6] 

Uno de su prueba muestra este ejemplo relevante para este caso:

flatMap() should flatten the multi-dimensional array to a single-dimensional one