Luis Manuel Morales López
Alfonso Neil Jiménez Casallas
Típico reto de programación
Kevin Zavala
El método flat es inmutable que consiste en retornar un array donde los sub-arrays han sido aplanados hasta una profundidad especificada. El aplanamiento consiste en transformar un array de arrays a una sola dimensión.
Este procedimiento recibe un argumento:
Infinity.array.flat(profundidad)
Diferencia entre la estructura for y el método flat
Si se utiliza la estructura for para aplanar un array de arrays, es necesario utilizar otra estructura for para cada sub-nivel del array o recursión.
const matrix = [ [1,2,3], [4,5,6], [7,8,9], ] const flatArray = [] for(let i=0; i<matrix.length; i++){ const array = matrix[i] for(let j=0; j<array.length; j++){ flatArray.push(matrix[i][j]) } } console.log(flatArray) // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
Con el método flat solamente es necesario indicar la profundidad de aplanamiento del array.
const array = [1,2,[3,4],5,6] const result = array.flat() result// [1,2,3,4,5,6] const array2 = [1, 2, [3, 4, [5, 6]]]; const result2 = array2.flat() result2// [1, 2, 3, 4, [5, 6]] const array3 = [1, 2, [3, 4, [5, 6]]] const result3 = array3.flat(2) result3// [1, 2, 3, 4, 5, 6] const array4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]] const result4 = array4.flat(Infinity) result4// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Contribución creada por: Andrés Guano.
Luis Manuel Morales López
Alfonso Neil Jiménez Casallas
Típico reto de programación
Kevin Zavala
Frankz Lenin Alarcón Cando
También aporto mi solución, simulando flat con recursividad. (^_^)
Luis E. Gama Ramirez
Hola, me gusto tu solucion, me podrias explicar un poco, como lo hiciste. ? :)
Raycris Maldonado
Excelentisima respuesta, mejor de ahi no podria ser!
Otra forma de hacer este reto es llamar de forma recursiva a la función en un reduce.
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]
Samuel Martinez Arreola
Miguel Angel Reyes Moreno
Qué elegancia la de Francia
John Jairo Rodriguez Rivas
Una pasada el tuyo, también me ayudaste a notar que concat recibe no solo arrays para concatenar, sino también elementos, uno solo o varios a la vez, confirmado en MDN, leer documentación es importante 🤯
Derek Samuel Paúl Peña
Pensándolo un rato, creo que esta forma de aplanar el array es mucho más fácil sin importar el nivel de profundidad:
matrix.join(",").split(",").map((matrixItem) => +matrixItem)
Romen Ter Gazarian
Excelente, yo habia pensado con un spreed operation
Haikel Mustafá
Ojo con esta solución, no es óptima ya que solo funcionaria con elementos de tipo numérico, pues fuerza el dato a ese tipo, si es de otro tipo pierde su utilidad.
Julian David Alzate Cuervo
El método flat() crea una nueva matriz con todos los elementos de sub-array concatenados recursivamente hasta la profundidad especificada.
Ricardo Rito Anguiano
Rodrigo Josue Goitia Quiroga
Realice el reto pero necesite ayuda de este comentario para encontrar la solución que buscaba. Luego de revisar tu solución intenté recrearla entendiendo la lógica que usaste. Eres un capo!
David Molina
Muy vacano, gracias, fácilmente pude llegar a la solución sin indicar la profundidad, pero me demore mucho intentando recrear la función con el parámetro de la profundidad, estaba pensando en que tenia que crear una forma de obtener la profundidad, pero luego llegue a tu respuesta y me exploto la cabeza con la sencillez de tu solución. Gracias por compartir, eres un crack.
Angel Eduardo Quispe Pomajulca
Jean Bustamante
Gracias por compartirlo, ya le entendí a lo que hiciste.
Hugo Felipe Riveros Fajardo
Solucione el reto de tal forma que no se necesite saber cuantos niveles de array se encuentran dentro del array original. Debo aclara que halle a solución sin utilizar el método "flat", utilice en su lugar una función recursiva en la cual utilice los Arrow Methods "forEach" y "push". Reconozco que vi unas soluciones en los aportes que me parecen mas efectivas, pero comparto esta que fue la que desarrolle en un principio.
const membrana2 = [ [1,2,3], [4,5,6,[7,8,[10,11,12]]], [[13,14,15], [16, [17,18,19],20]] ]; let retoArray2 = []; function flatArray(matriz) { if (Array.isArray(matriz)) { matriz.forEach((item) => { if (Array.isArray(item)) { flatArray(item); } else { retoArray2.push(item); } }) } } flatArray(membrana2); console.log(retoArray2); //Expected output: [1,2,3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,19,20]
Haikel Mustafá
Reto del flat sin .flat()
const matriz = [ 1, { name: 'Haikel', lastname: 'Mustafa', age: 37 }, { name: 'Lismar', lastname: 'Soto', age: 29 }, [1,2,3], [4,5,6], [7,8,[9,10,['Haikel', 'Amir', true]]] ]; let newArray = []; const aplanadora = (arr) => { arr.map(item => { if(Array.isArray(item)) { return aplanadora(item); } else { newArray.push(item); }}); return newArray; } console.log(aplanadora(matriz)); }
Explicación del código anterior:
Se creó la función aplanadora, la cual recibe como parámetro un array, la función utiliza un .map para recorrer el arreglo y verificar si el elemento (item) es un array o no, si es un array llama de nuevo a la misma función para verificar si los elementos de ese array son otro array o no, haciendo que mientras sea un array llame a la función y cuando se tope con algo que no es un array agrega ese elemento a un nuevo array (newArray).
david alvarez
por que será que me sale error. matriz.flat(); is not a function?
Kharlos Alexander Pinedo Lavajos
Hola David, si estas ejecutando los archivos JS con node en la terminal (node 14-flat.js), tienes que tener instalado la ultima version de node (v.14.18.0) en Ubuntu o windows, si tienes la version. Te paso el link para actualizar nodejs. (https://phoenixnap.com/kb/update-node-js-version), yo segui el paso 2.
Jairo Campos Ruiz
Esta fue mi solución al problema:
const matriz = [ [1,2,3], [4,5,6, [1,2, [3,4]]], [7,8,9] ]; const myFlat = (array) => { let newArray = []; array.forEach((item) => { if (Array.isArray(item)) { newArray = newArray.concat(myFlat(item)); } else { newArray.push(item); } }) return newArray; } console.log("for", myFlat(matriz));
Leal Brigitte
Me gustó mucho tu solución
Fabio Alejandro Ramirez Saavedra
Gracias por ayudarme a entender con este código, lo cogí de referencia muchas gracias
Carolina Forner
Curso de recursividad?
Axel Yaguana
Team Platzi¡Hola, Carolina!
No hay uno en específico para recursividad ya que es más bien un tema muy puntual. Hay cursos en los que dentro puedes encontrar más sobre recursividad. Te comparto un par de clases de ellas:
Como podrás notar, la recursividad se puede aplicar con cualquier lenguaje. :D
Ariel Ezequiel Biazzo Genua
Holaa, te recomiendo ir al curso de programacion orientada a objetos intermeido. Ese lo explica genial :)
Giuliano De Leonardis
Luis Ernesto Yepes Fernandez
Mi solución aplicando recursividad.
const matriz = [ 0, [1,2,3,[4,5]], [6,7,[8,9,10,[11,12,13,[14,15]]]] ]; let arrayFinal = []; console.log("inicial", matriz); // inicial [ 0, [ 1, 2, 3, [ 4, 5 ] ], [ 6, 7, [ 8, 9, 10, [ 11 , 12 , 13 , [ 14 , 15 ] ] ] ] ] function newArray(array) { for (let i = 0; i < array.length; i++) { const element = array[i]; if (element.length > 1) { newArray(element); } else { arrayFinal.push(element); } } return arrayFinal; } console.log("final", newArray(matriz)); // final [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ]
Daniel Condía Figueredo
Tatiana Cordecci
const matrizAnidada = [ [1, 2, 3], [4, [5, 6, [7, 8]], 9], [10, 11, [12, [13, 14]]] ]; function aplanarArray(array, result = []) { for (let i = 0; i < array.length; i++) { element = array[i] if (Array.isArray(element)) { aplanarArray(element, result); } else { result.push(element); } } return result; }; const arrayAplanado = aplanarArray(matrizAnidada); console.log(arrayAplanado); // output: //output: [1, 2, 3, 4, 5, 6,7, 8, 9, 10, 11, 12,13, 14]
Ruth Lovece
Hola, les comparto mi solución con recursividad.
const newFlatRecursivo = (array) => { let newArray = []; array.forEach(item => { if (!Array.isArray(item)) { newArray.push(item) } else { newArray = newArray.concat(newFlatRecursivo(item)); } }) return newArray}
Remix Zapata
Encontré una forma equivocándome, que cuando sumas un array o lista con un string, te retorna el string con todos los elementos que tenía el array sin importar la profundidad.
El output es este:
Own Method [ '2', '3', '6', '98', '41', '48', '734', '409', '734', '462', '5', '6', '6', '43', '80', '73', '763', '837', '644', '984', '8', '9', '6', '62', '48', '62', '120', '92', '644', '983', '1', '3', '0', '91', '84', '92', '275', '325', '644', '538' ]
Casi lo mismo ya que todos los elementos son string "", pero está hecho con una equicación xd.
Jesús Alejos
Flat con for-each y concat.
La funcionalidad de Flat con recursión
Se busca recursivamente en cada elemento hasta que ya no se encuentre otra lista y se van uniendo los elementos encontrados con Cat.
Dejo también el código por si lo quieren probar:
const matriz = [ [1,2,3], [4,5,6, [1,2, [1,2]]], [7,8,9] ]; function profundidad(list) { let newList = []; if (typeof list != "object") return [list]; list.forEach(element => { newList = newList.concat(profundidad(element)); }); return newList; } const newArray = profundidad(matriz); console.log(newArray);
Interesante algoritmo, hice algo similar, pasando por referencia a otro array donde se irán agregando los demás valores:
const matriz = [ 1, [1,2,3], [4,5,6], [7,8,[9,10,[11,12]]] ]; const flatArray = (arr = [], data = []) => { if(typeof arr !== 'object') return [arr]; arr.forEach(element => { if (typeof element === 'object') { flatArray(element, data); } else { data.push(element); } }); return data; } console.log(flatArray(matriz));
Salida:
/* [ 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ] */
const matriz = [ [1, 2, 3], [4, 5, 6], [7, 8, 9], ]; const flatten = (arr) => arr.reduce((acc, el) => acc.concat(el), []); console.log(flatten(matriz));
Lisstoooooooooooooooooo
const matriz = [ [1, 2, 3], [4, 5, 6, [1, 2]], [7, 8, 9] ]; // console.log(matriz.flat(2)); function flat(array, deep = 1) { const arr = []; if (deep < 1) { return array; } array.map( (el) => { if (Array.isArray(el)) { arr.push(...el); } else { arr.push(el) } } ); deep -= 1 return flat(arr, deep); } console.log(flat(matriz, 1)); //Expected-> [ 1, 2, 3, 4, 5, 6, [ 1, 2 ], 7, 8, 9 ]
Aquí mi solución donde use algo de closures y recursividad, una forma de compactar lo aprendido.
const matriz = [ [1,2,3], [4,5,6],[1,2,[10,20,30]], [7,8,9], ]; function flatExample() { let newArray = []; function flat(matriz){ for(let i=0; i<matriz.length; i++){ if(Array.isArray(matriz[i])){ flat(matriz[i]); } else { newArray.push(matriz[i]); } } return newArray; } return flat; } const example = flatExample(); console.log(example(matriz));
Acá les dejo mi método 'flat' con una profundidad de 3 (y me llevó casi dos horas desarrollarlo 😅):
function cycleforToArrays(array, qty) { const newArray = []; switch (qty) { case 1: for (let i = 0; i < array.length; i++) { const firstArray = array[i]; for (let j = 0; j < firstArray.length; j++) { const element = array[i][j]; newArray.push(element); } } return newArray; case 2: for (let i = 0; i < array.length; i++) { const firstArray = array[i]; for (let j = 0; j < firstArray.length; j++) { const scdArray = array[i][j]; const element1 = array[i][j]; if (scdArray.length == undefined) { newArray.push(element1); continue; } else { for (let k = 0; k < scdArray.length; k++) { const element2 = array[i][j][k]; newArray.push(element2); } } } } return newArray; case 3: for (let i = 0; i < array.length; i++) { const firstArray = array[i]; for (let j = 0; j < firstArray.length; j++) { const scdArray = array[i][j]; const element1 = array[i][j]; if (scdArray.length == undefined) { newArray.push(element1); continue; } else { for (let k = 0; k < scdArray.length; k++) { const thirdArray = array[i][j][k]; const element2 = array[i][j][k]; if (thirdArray.length == undefined) { newArray.push(element2); continue; } else { for (let l = 0; l < thirdArray.length; l++) { const element3 = array[i][j][k][l]; newArray.push(element3); } } } } } } return newArray; } } function myFlat(array, depth) { if (depth == 1) return cycleforToArrays(array, depth); else if (depth == 2) return cycleforToArrays(array, depth); else if (depth == 3) return cycleforToArrays(array, depth); } console.log('Original: ', matriz); console.log('MyFlat1: ', myFlat(matriz, 1)); console.log('MyFlat2: ', myFlat(matriz, 2)); console.log('MyFlat3: ', myFlat(matriz, 3));
Buenas Soluciones, por aquí dejo una solición algo sencilla y fácil de entender
let arreglo = [ [1,2,3], [4,5,6,[4,5,6,[7,8,9]]], [7,8,9,[10,11,12,[13,14,15,[13,14,15]]]] ]; let arregloPlano = []; function aplanarArreglo(subArreglo) { for (let i = 0; i < subArreglo.length; i++) { let valor = subArreglo[i]; if (Array.isArray(valor)) { aplanarArreglo(valor); continue; } arregloPlano.push(valor); } } aplanarArreglo(arreglo); console.log('arregloPlano => ', arregloPlano); ```let arreglo = \[ 	\[1,2,3], 	\[4,5,6,\[4,5,6,\[7,8,9]]], 	\[7,8,9,\[10,11,12,\[13,14,15,\[13,14,15]]]] ]; let arregloPlano = \[]; function aplanarArreglo(subArreglo) { 	for (let i = 0; i < subArreglo.length; i++) { 	 let valor = subArreglo\[i]; 	 if (Array.isArray(valor)) { 	 aplanarArreglo(valor); 	 continue; 	 } 	 arregloPlano.push(valor); 	} } aplanarArreglo(arreglo); console.log('arregloPlano => ', arregloPlano);