A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Flat

15/19
Recursos

Aportes 63

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

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


Tambi茅n aporto mi soluci贸n, simulando flat con recursividad.
(^_^)

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

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]

El m茅todo flat() crea una nueva matriz con todos los elementos de sub-array concatenados recursivamente hasta la profundidad especificada.

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 ]

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 ]

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)
function flatten(arr) {
  return arr.reduce(function (flat, toFlatten) {
    return flat.concat(
      Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten
    );
  }, []);
}

console.log(
  flatten([
    [[1, [1.1]], 2, 3],
    [4, 5],
  ])
);

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 鈥渇lat鈥, utilice en su lugar una funci贸n recursiva en la cual utilice los Arrow Methods 鈥渇orEach鈥 y 鈥減ush鈥. 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]

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

Esto me record贸 mucho a la Reducci贸n de dimensionalidad, bastante usado en Machine Learning.

Reto cumplido!! La funci贸n aplanarArray declara un arreglo y utiliza la funci贸n aplanadora.

En la funci贸n aplanadora recibe un item y la referencia de un arreglo, si el item que pasa por par谩metro no es un objeto, entonces agregarlo al final del arreglo. De lo contrario, para cada elemento del objeto item, aplicar recursivamente hasta llegar algo distinto de un objeto. Una vez finalizada la funci贸n aplanadora, el arreglo newArray de aplanarArray ya estar谩 listo para retornar.
Al ser el pasaje de un objeto por referencia, al trabajar de forma recursiva siempre esteremos pusheando al mismo arreglo.

const matriz = [
    [1,2,3],
    [4,5,6, [1,2, [1,2]]],
    [7,8,9]
];

const matriz2 = [
    1,
    [1,2,3],
    [4,5,6],
    [7,8,[9,10,[11,12]]]
];

function aplanarArray( item ) {
    const newArray = [];
    //Envio el item a aplanar y la referencia al arreglo a retornar
    aplanadora( item, newArray);
    return newArray;
}

function aplanadora( item , arreglo) {
    //Si el item no es un objeto, agregalo al arreglo
    if( typeof item != 'object') {
        arreglo.push(item);
    } else { //De lo contrario
        //Por cada elemento del objeto, aplicar de forma recursiva el metodo hasta llegar a un no-objeto
        item.forEach( element => aplanadora( element, arreglo));
    }
}

const matrizAplanada = aplanarArray( matriz );
const matriz2Aplanada = aplanarArray( matriz2 );
console.log('(Matriz no-aplanada)', matriz);
console.log('(Matriz aplanada)', matrizAplanada);
console.log('(Matriz 2 no-aplanada)', matriz2);
console.log('(Matriz 2 aplanada)', matriz2Aplanada);

Buenos dias compa帽eros, quisiera recibir feedback de mi codigo, pueden pasarle cualquier arreglo con cualquier nivel.

const algunArray = ['a','b',['c','d','e'],'f',['g','h','i',['j','k',['l','m',['n','o',['p','q']]]]]]

const flat1= (array)=>{
    let newArray =[]
    for (let index = 0; index < array.length; index++) {
        const element = array[index];
        newArray.push(...element)       
    }
    return newArray
}
const flatFunction =(array,niveles)=>{
    let arrayFinal = []
    for (let index = 0; index <= niveles-1; index++) {
        if (index === 0){
            arrayFinal = flat1(array) 
            
        }else{
            arrayFinal = flat1(arrayFinal) 
        }               
    }
    console.log(arrayFinal) 
}
// el primer parametro que recibe es el array 
// el segundo parametro es el nivel del arreglo       

flatFunction(algunArray,4)
<code> const matriz = [
    0,[1,2,3,[4,5]],
    [6,7,[8,9,10,[11,12,13,[14,15]]]]
];

function aplanar(array){
  let ret = [];
   for(let i = 0; i < array.length; i++){
       if(Array.isArray(array[i])){
           ret = ret.concat(aplanar(array[i]));
       }else {
           ret.push(array[i]);
       }
       
   }
   return ret;
}

console.log(aplanar(matriz));

Este es mi aporte

pues este no es el codigo mas peque帽o , pero quiza sirva como documentacion de como ir llegando a enteder la recursividad
primero empece con tres ciclos for anidados ,
luego reduje a una funcion recursiva pero no me gustaba que tenia q dejar declarado el arrayAplanado fuera de la funcion , asi que al tercer intento (pero luego de horas con pausas icluidas ) tengo esto:

const matriz = [
    [1,2,3],
    [4,5,6 ,[1,2]],
    [7,8,9]
];

function aplanarArray(parametro){
    let arrayPlano = [];
    
    const recursiva=
    (parametro)=>{
        if(Array.isArray(parametro)){
                parametro.forEach(elemento=>recursiva(elemento))
            }else{
                arrayPlano.push(parametro);
            }
            return arrayPlano;
        }
    return recursiva(parametro);
}
console.log("recursiva(matriz) ;" , aplanarArray(matriz));


Mi soluci贸n al reto usando reduce y operador terniario

const matriz=[
0,
[1,2,3,[8,78]],
[665,78,[10,95,101,[115,172,143,[14,15]]]]
];

let newArray=[];
function recursiveArray(array){
return array.map(r=>{
r.length > 1
? recursiveArray庐
: newArray.push庐
}), newArray }

console.log(鈥淣ew Array鈥,recursiveArray(matriz));

馃槉Reto

  • 馃Con for
const myFlatWithFor = (array, depth) => {
    if (depth === undefined) {
        depth = 1;
    }
    let newArray = [];
    for (let i = 0; i < array.length; i++) {
        const item = array[i];
        if (Array.isArray(item) && depth > 0) {
            newArray = newArray.concat(myFlatWithFor(item, depth - 1));
        } else {
            newArray.push(item);
        }
    }
    return newArray;
}

console.log('myFlatWithFor', myFlatWithFor(matrix));
console.log('myFlatWithFor', myFlatWithFor(matrix, 2));
console.log('myFlatWithFor', myFlatWithFor(matrix, Infinity));
  • 馃獨Con for In
const myFlatWithForIn = (array, depth) => {
    if (depth === undefined) {
        depth = 1;
    }
    let newArray = [];
    for (const item in array) {
        if (Array.isArray(array[item]) && depth > 0) {
            newArray = newArray.concat(myFlatWithForIn(array[item], depth - 1));
        } else {
            newArray.push(array[item]);
        }
    }
    return newArray;
}

console.log('myFlatWithForIn', myFlatWithForIn(matrix, 2));

-馃獪 Con for of

const myFlatWithForOf = (array, depth) => {
    if (depth === undefined) {
        depth = 1;
    }
    let newArray = [];
    for (const item of array) {
        if (Array.isArray(item) && depth > 0) {
            newArray = newArray.concat(myFlatWithForOf(item, depth - 1));
        } else {
            newArray.push(item);
        }
    }
    return newArray;
}

console.log('myFlatWithForOf', myFlatWithForOf(matrix, 2));

-馃獡 Con forEach

const myFlatWithForEach = (array, depth) => {
    if (depth === undefined) {
        depth = 1;
    }
    let newArray = [];
    array.forEach(item => {
        if (Array.isArray(item) && depth > 0) {
            newArray = newArray.concat(myFlatWithForEach(item, depth - 1));
        } else {
            newArray.push(item);
        }
    });
    return newArray;
}
console.log('myFlatWithForEach', myFlatWithForEach(matrix, 3));
  • 鈿欙笍Con reduce
const myFlatWithReduce = (array, depth) => {
    if (depth === undefined) {
        depth = 1;
    }
    return depth > 0 ?
        array.reduce((accumulator, item) => accumulator.concat(Array.isArray(item) ?
            myFlatWithReduce(item, depth - 1) : item), []) :
        array.slice();
};
console.log('myFlatWithReduce', myFlatWithReduce(matrix, Infinity));

-馃挘 Con Generator

const myFlatWithGenerator = (array, depth) => {
    function* Generator(array, depth) {
        if (depth === undefined) {
            depth = 1;
        }
        for (const item of array) {
            if (Array.isArray(item) && depth > 0) {
                yield* Generator(item, depth - 1);
            } else {
                yield item;
            }
        }
    }
    return [...Generator(array, depth)];
}
console.log('myFlatWithGenerator', myFlatWithGenerator(matrix, 2));

Mi soluci贸n recursiva:

const matriz1 = [
	[1, 2, 3],
	[4, 5, 6],
	[7, 8, 9, [11, 25, [32, 15, [1, [2, [3]]]]]],
];
function flatten(data) {
	let newArray = [];
	if (!Array.isArray(data)) {
		return [data];
	} else {
		data.forEach(element => {
			newArray = newArray.concat(flatten(element));
		});
		return newArray;
	}
}
const flatArray = flatten(matriz1);
console.log(flatArray);

Hecho con for y creo que recursividad


const matriz2 = [1, [2, 3], 6, [1],
    [8, 8, 8],
    [1, 2, 3, [4, 4, 5, [1, 0, [10]]]]
];
const newArray = [];

for (let i = 0; i < matriz2.length; i++) {

    if (!matriz2[i].length) {
        newArray.push(matriz2[i])
    } else {
        extraer(matriz2[i]);

    }
}

function extraer(element) {
    const longitud = element.length;
    for (let x = 0; x < longitud; x++) {
        if (!element[x].length) {
            newArray.push(element[x])
        } else {
            extraer(element[x]);
        }
    }
}

console.log(newArray);

Respuesta:

[
  1, 2,  3, 6, 1, 8, 8,
  8, 1,  2, 3, 4, 4, 5,
  1, 0, 10
]

Second challenge solved

Challenge solved

Les comparto mi soluci贸n para aplanar un array sin el m茅todo flat. 馃槃

function flatFunction (element) {
    let newArray = [];
    const isElementArray = Object.prototype.toString.call(element) === '[object Array]';
    if (!isElementArray) return element;  
    for (const item of element) {
        newArray = newArray.concat(flatFunction(item));
    }
    return newArray;
}

const matriz = 
[
    [['a', 'b'],1, 2, 3],
    [4, 5, 6, [1, 2, [3, 4]]],
    [7, 8, 9, ['a', 'b']],
];

console.log(flatFunction(matriz));

Mi solucion usarndo recusrividad, usando una funcion:

const names = ['pedro',['juan',[['jose', [[['carlos']]]]]]]

function flatReloaded(array) {
    let newArray= []

    array.forEach(element => {
        if(Array.isArray(element)) {
            newArray = [...newArray, ...flatReloaded(element)]
        } else {
            newArray.push(element)
        }
    })

    return newArray
}

console.log(flatReloaded(names)) //[ 'pedro', 'juan', 'jose', 'carlos' ]

Aprovechando lo aprendido con join y split鈥

const a = [11,2,3,[4,51],[10,3,[9,14,[11,[15],12]]]];

const ans = a.join(',').split(',').map(item => parseInt(item))
console.log(ans)

Reto: Funcionalidad de flat con recursi贸n

Tomando el curso de complejidad algoritmica aprend铆 que una funci贸n recursiva O(!n) es peor que un bucle anidado O(n^2) as铆 que realize dos algoritmos 1 con recursividad y otro con un bucle for anidado dentro de un While aqu铆 se los dejo:

// using WhileLoop
function Flat(array) {
    let currentArr = array
    let depth = currentArr.length
    let pendingArr = []
    let result = []

    while (depth > 0) {

        for(let i = 0; i < currentArr.length; i++) {
            if( !Array.isArray(currentArr[i]) ) {
                result.push(currentArr[i])
                depth--;
                continue;
            }

            pendingArr.push(currentArr[i])
            depth--;
            depth += currentArr[i].length
        }

        if(pendingArr.length > 0) {
            currentArr = pendingArr.shift()
            depth += pendingArr.length
        }
        
        
    }

    return result

Mi soluci贸n con recursividad:

function flatRecursivo (array){
    let newArray = [];
    for(element in array){
        if(!Array.isArray(array[element])){
            newArray.push(array[element]);
        }else{
            newArray = [...newArray, ...flatRecursivo(array[element])];
        }
    }
    return newArray;
}
const matriz = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
];

const newArray = [];
for (let i = 0; i < matriz.length; i++) {
    const array = matriz[i];
    for (let j = 0; j < array.length; j++) {
        const element = array[j];
        newArray.push(element)
    }
}

console.log(newArray);

I didn鈥檛 know about flat method, but now I have learned how to use it.

Mi soluci贸n.

Se puede seguir mejorando.

Mi soluci贸n!

const nums = [1, 2, [3, 4, [5, 6], [7, 8, [9, 10]], 11], 12, { 1: { 2: 3 } }]

const flatArray = (array, newArray = []) => {
    for (const element of array) {
        if (Array.isArray(element)) {
            flatArray(element, newArray)
        } else {
            newArray.push(element)
        }
    }
    return newArray
}

console.log(flatArray(nums))

// expected output
// [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, { '1': { '2': 3 } } ]

Ac谩 dejo mi soluci贸n

const matriz = [
    [1,2,3],
    [4,5,6, [21,22,23, [31,32,33, [41,42,43]]]],
    [7,8,9]
]

function validarElement(arrayIterar) {
    let retorno = [];
    if (Array.isArray(arrayIterar)) {
        for (let index = 0; index < arrayIterar.length; index++) {
            const element = arrayIterar[index];
            if (Array.isArray(element)) {
                retorno = [...retorno,...validarElement(element)];
            } else {
                retorno.push(element);
            }
        }
    } else {
        retorno.push(arrayIterar);
    }
    return retorno;
}

let valor = validarElement(matriz);
console.log(valor);

Con recursiidad

const matriz = [
  [1, 2, 3],
  [4, 5, 6, [1, 2, 3, [1, 4], 3]],
  [7, 8, 9]
];

const newArray = [];
function newFlat(array) {
  for (let i = 0; i < array.length; i++) {
    const e = array[i];
    if (Array.isArray(e)) {
      newFlat(e);
    } else {
      newArray.push(e);
    }
  }
}
newFlat(matriz);
console.log('for', newArray);

Esta es mi soluci贸n 馃檪

Saludos, les comparto mi soluci贸n al desaf铆o. Solo utilic茅 un ciclo for of y recursividad.

const flatArray = (element, flatElement = []) => {
  for (const i of element) {
    if (!Array.isArray(i)) flatElement.push(i)
    else flatArray(i, flatElement)
  }
  return flatElement
}

const flatMatriz = flatArray(matriz)

Otra forma, aunque es igual que las dem谩s de mis compa帽eros pero con el operador ternario:D

function flatMethod(matriz) {
  let newArray = [];
  for (element of matriz) {
    Array.isArray(element)
      ? (newArray = newArray.concat(flatMethod(element)))
      : newArray.push(element);
  }
  return newArray;
}

esta es mi soluci贸n:

function flat(array) {
    let flatened = [];

    function auxF(aux){
        aux.map((element)=> (Array.isArray(element) ? auxF(element) : flatened.push(element)))
    }

    auxF(array)
    return flatened
}

lo hice de la manera mas compacta que se me ocurri贸, para quien le cueste entenderlo solo us茅 la funcion map con una sintaxis diferente, esto:

aux.map((element)=> (Array.isArray(element) ? auxF(element) : flatened.push(element)))

es lo mismo que esto:

aux.map((element)=>{
            if (Array.isArray(element)) {
                auxF(element)
            }
            else{
                flatened.push(element)
            }
        })    

tambien se puede hacer con un for pero el codigo quedar铆a muy largo, aqu铆 les dej贸 todo el codigo:

const matriz = [
    [1,2,3],
    [4,5,6],
    [7,8,9],
]

function flat(array) {
    let flatened = [];

    function auxF(aux){
        aux.map((element)=> (Array.isArray(element) ? auxF(element) : flatened.push(element)))
    }
    auxF(array)
    return flatened
}

const array = flat(matriz)
console.log(array);

Esta fue mi solucion a aplanar el array sin flat, solo con ciclos for:

const matrix = [
    [1,2,3],
    [4,5,6,7,7, [1,2]],
    [7,8,9]
]

matrix.isArray

const newArray = [];

for(let i = 0; i < matrix.length; i++){
    const element = matrix[i];
    for(let ii = 0; ii < matrix[i].length; ii++){
        const finalElement = matrix[i][ii];
        if(!Array.isArray(finalElement)){
            newArray.push(finalElement);
        }else{
            for(let iii = 0; iii < finalElement.length; iii++){
            const finalElement2 = matrix[i][ii][iii];
            newArray.push(finalElement2)
            }
        } 
    }
}

console.log(newArray);

respuesta al reto :

let a = [1,3,2,4,[32,3,[3,5,[1,8],3,3],3,4],2,4]


let newArray = []
function flatByHand(array,resultArray){
  array.forEach(item => {
    if(typeof item == 'object'){
      flatByHand(item,resultArray)
    }else{
      resultArray.push(item)
    }
  })
  return resultArray
}
console.log(flatByHand(a,newArray))

Flat y FlatMap

  • Estos metodos son nuevos en JS

  • Se utilizar para manupular array con array dentro en recursividad

  • Se utiliza para aplanar el array en uno mas simple

function myFlat(arr, deep = 1) {
  let cnt = 0
  let rest= JSON.parse(JSON.stringify(arr))
  while (cnt < deep) {
    rest = rest.reduce((acum, item) => {
      if (item instanceof Array) {
        acum = acum.concat(item)
      }
      else {
        acum.push(item)
      }
      return acum
    }, [])
    cnt++;
  }

  return rest
}

const arr = [1, [2,[4, 3]], 4, [4, 5]]

console.log(myFlat(arr,2))

Comparto mi soluci贸n

Hola! les comparto mi versi贸n del reto 馃槃:

const hardMatrix = [
  [1, 2, [3, 3]],
  [4, [5, 5, [4, 2]], 6],
  [[1, [2, 3, 4, [3, [2, 1]]]], 8, 9],
];

const recursiveArray = [];

//La funci贸n recibe un array y el 铆ndice que se quiere evaluar
const flatFunction = (array, index) => {
  // Si el 铆ndice ya es igual a lenght no hay comparaci贸n por hacer
  if (index === array.length) {
    return;
  }

  // Si el valor del array en ese 铆ndice es un objeto, vuelvo a llamar esta funci贸n con el 铆ndice cero.
  if (typeof array[index] === 'object') {
    flatFunction(array[index], 0);
  } else {
    // Si no es un objeto, es un valor, as铆 que puedo hacer push()
    recursiveArray.push(array[index]);
  }
  // Independiente del If, hay que seguir evaluando las dem谩s posiciones del array recibido.
  flatFunction(array, index + 1);
};

flatFunction(hardMatrix, 0);
console.log('recursive:', recursiveArray);

Aqu铆 esta mi soluci贸n al reto:

const array = [1, 2, 3, 4, [5, 6, [7, 8], [9, 10, [11, 12]]], 13, 14, 15, [16, 17, 18, [19, [20]]]];

const newArray = aplanar(array);

console.log(newArray);

function aplanar(array, newArray = undefined) {
    newArray = newArray ? newArray : [];
    array.forEach((item) => {
        if (!Array.isArray(item)) {
            newArray.push(item);
        } else {
            aplanar(item, newArray);
        }
    })
    return newArray;
}

Resultado

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]

M茅todo flat : manipular arrays que tienen arrays dentro y volverlos un solo array.

const matriz = [
  [1, 2, 3],
  [4, 5, 6, [1, 2]],
  [7, 8, 9],
];

const flatMetod = matriz.flat(2);
console.log(flatMetod);

RETO RESUELTO

const matriz = [
  [1, 2, 3],
  [4, 5, 6, [1, 2]],
  [7, 8, 9],
];
const newArray = []
for (let i = 0; i < matriz.length; i++) {
    const matrizElement = matriz[i];
   
    for (let j  = 0; j < matrizElement.length; j++) {
        const element = matrizElement[j];
        //console.log(element.length);
        if(!element.length){ newArray.push( element)}
            else {
                for (let k = 0; k < element.length; k++) {
                    const elementA = element[k];
                    newArray.push( elementA)
            }   
        }
    }  
}

console.log(newArray);
const matriz = [
  [1,2,3],
  [4,5,6,[20,40]],
  [7,8,9]
];

const newArray = []
for (let i = 0; i < matriz.length; i++) {
  const array = matriz[i];
  for (let j = 0; j < array.length; j++) {
    const element = array[j];
    if(Array.isArray(array[j])){
      for (let z = 0; z < element.length; z++) {
        const goku = element[z];
        newArray.push(goku)
      }
    } else {
      newArray.push(element)
    }      
  }
}

console.log('for',newArray)

Esta seria mi manera de encarar un 鈥渁planador鈥 en caso de que halla arrays, dentro de arrays, dentro de un gran array jajaja.

Buen d铆a amigos, mi soluci贸n. 馃捇

<
const matriz = [
    [1,2,[1,5,[1,2]]],
    [4,5,6,[5,6,8],[5,9]],
    [7,8,9,[1,[2,[3]]]]
];

const array = [];

const inspeccion = (object) => {    
    for(const i of object) {
        typeof(i)==='object'? 
            inspeccion(i):
            array.push(i);
    }
}

inspeccion(matriz);
console.log(array);
> 

He intentado hacer el ejercicio aplicando recursividad y me ha salido, aqu铆 os dejo mi c贸digo por si a alguien le interesa.

Si les sale el error flat is not defined es posible que solo tengan que actualizar Node, les dejo un link para sus diferentes casos.
How to Update Node.js to Latest Version {Linux, Windows, and macOS}

Mi soluci贸n con recursividad 馃馃:

Les dejo mi soluci贸n con recursividad

const matrix = [
    [1, 2, 3],
    [4, 5, 6, [4, 5, 6]],
    [7, 8, 9, [10, 11, 12, [13, 14, 15]]]
];

const recursiveFlat = (matrix) => {
    let flat = [];
    for (let i = 0; i < matrix.length; i++) {
        if (Array.isArray(matrix[i])) {
            flat = flat.concat(recursiveFlat(matrix[i]));
        } else {
            flat.push(matrix[i]);
        }
    }
    return flat;
}

console.log(recursiveFlat(matrix));
const matriz = [
  [1,2],[3,4,5],6,[6,8,[9,11, [2,3,4,[4,5,2]],13]]
]

const flatArray = (array) =>{

  return (array.reduce((acc,curr) =>(
    Array.isArray(curr) ? 
      acc.concat(flatArray(curr)) :
      acc.concat(curr)
  ),[]))
}

flatArray(matriz)

Comparto mi soluci贸n

const matriz = [
    [1,2,3],
  [4,5,6, [1,2, [1,2]]],
  [7,8,9]
];

const newFlat = arr => arr.reduce((acc, cur) => {
    let element = Array.isArray(cur) ? newFlat(cur) : cur;
    return acc.concat(element);
},[])

const rta = newFlat(matriz);
console.log("rta", rta)

Les dejo mi Flat artesanal, implementado con Recursividad y split operator.

const matriz = [
    [1,2,3],
    [4,5,6, [1,2]],
    [7,8,9]
];


function artesanalFlat(array){
    const newArray = [];
    for(let i = 0; i < array.length; i++){
        const element = array[i];
        if(typeof(element) === 'object'){
            newArray.push(...artesanalFlat(element));
        }else{
            newArray.push(element);
        }
       
    }

    return(newArray);
}

const flateredArray = artesanalFlat(matriz);
console.log('El nuevo Array', flateredArray);

Dejo mi aportito de recursion ;D

const arr = [1,2,3, [4,5,6,[3,4],[5,4,[1]]],2,5]

const FLAT = array => {
  let newArray = [];

  if(typeof array == "object") {
    array.forEach(element => {
      newArray = newArray.concat(FLAT(element));
    })
    return newArray
 }

  return array;
}

let flatArray = FLAT(arr);

console.log(flatArray);

Otra solucion

console.clear();

const matriz = [[1, 2, 3], [4, 5, 6, [4, 5, 6]], , [7, 8, 9, [1, 2, 3, [77, 88, 13, [144, 666, 55]]]]];

function flatArray2(array) {
  const newMatriz = [];
  array.forEach((element) => {
    if (Array.isArray(element)) {
      newMatriz.push(...flatArray2(element));
    } else {
      newMatriz.push(element);
    }
  });
  return newMatriz;
}

const newMatriz1 = flatArray2(matriz);
console.log('newMatriz1', newMatriz1);

console.clear();

const matriz = [[1, 2, 3], [4, 5, 6, [4, 5, 6]], , [7, 8, 9, [1, 2, 3, [77, 88, 13]]]];

function getElements(array, newArray) {
  array.forEach((element) => {
    if (Array.isArray(element)) {
      getElements(element, newArray);
    } else {
      newArray.push(element);
    }
  });
}

const newMatriz = [];
getElements(matriz, newMatriz);
console.log('newMatriz', newMatriz);