No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

ES10: flat-map y trimStart-trimEnd

24/35
Recursos

La siguiente versi贸n de ECMAScript fue publicada en 2019. A continuaci贸n aprender谩s sobre aplanamiento de arrays y eliminar espacios en blanco de un string.

Qu茅 es el aplanamiento de arrays

El aplanamiento consiste en transformar un array de arrays a una sola dimensi贸n. Los m茅todos flat y flatMap permitir谩n realizar el aplanamiento.

M茅todo flat

El m茅todo flat devuelve un array donde los sub-arrays han sido propagados hasta una profundidad especificada.

Este m茅todo es inmutable, es decir, retorna un nuevo array con los cambios y no cambia el array original.

Este m茅todo recibe un argumento:

  • La profundidad del aplanamiento, por defecto, tiene un valor de 1.

Si se desea aplanar todos los sub-arrays en una sola dimensi贸n, utiliza el valor de Infinity.

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]

M茅todo flatMap

El m茅todo flatMap es una combinaci贸n de los m茅todos map y flat. Primero realiza la iteraci贸n de los elementos del array (como si fuera map), y despu茅s los aplana en una sola profundidad (como si fuera flat).

Este m茅todo es inmutable, es decir, retorna un nuevo array con los cambios y no cambia el array original.

Este m茅todo recibe los mismos argumentos que el m茅todo map.

const strings = ["Nunca pares", "de Aprender"]
strings.map(string => string.split(" ")) 
// [ [ 'Nunca', 'pares' ], [ 'de', 'Aprender' ] ]
strings.flatMap(string => string.split(" ")) 
// [ 'Nunca', 'pares', 'de', 'Aprender' ]

const numbers = [1,2, 3, 4]
numbers.map(number => [number * 2]) 
// [[2], [4], [6], [8]]
numbers.flatMap(number => [number *2]) 
// [2, 4, 6, 8]

// Cuidado, primero hace el map y luego el flat
const numbers2 = [1,[2,3], 4, 5]
numbers2.flatMap(number => [number *2]) 
// [ 2, NaN, 8, 10 ]
// * Recuerda: NaN = No a Number

Eliminar espacios en blanco de un string

Existen tres m茅todos para eliminar espacios en blanco de un string:

  • El m茅todo trim elimina los espacios en blanco al inicio y al final.
  • El m茅todo trimStart o trimLeft elimina los espacios al inicio.
  • El m茅todo trimEnd o trimRight elimina los espacios al final.
const saludo = "      hola      "
const result1 = saludo.trim()
const result2 = saludo.trimStart()
const result3 = saludo.trimEnd()

result1 // 'hola'
result2 // 'hola      '
result3 // '      hola'

Contribuci贸n creada por Andr茅s Guano (Platzi Contributor).

Aportes 47

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Hola Chic@s 馃槂
ES10:

  • Flat-map
// flat
const array = [1,1,2,3,4, [1,3,5,6,[1,2,4]]];
console.log(array.flat(3));

// flatmap
const array2 = [1,2,3,4,5];
console.log(array2.flatMap(v => [v, v *2]));
  • TrimStart-trimEnd
const hello = "       Hello World!   ";
console.log(hello.trimStart());
console.log(hello.trimEnd());

Flat


El m茅todo flat de los array permite aplanar los elementos internos de un array permitiendo eliminar array internos.

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

numbers.flat(1) // [ 1, 2, 3, 4, 5, 6, [ 7, 8, 9 ] ]
numbers.flat(2) // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Si se quiere aplanar todo el arreglo sin pasar una profundidad exacta, se puede hacer uso de Infinity.

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

numbers.flat(Infinity) // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Flat-map


Permite aplanar los elementos de un array en un nivel, pasando un funci贸n que mapeara cada elemento del nuevo array.

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

numbers2.flatMap(num => num * 2). // [ 2, 4, 6, 8, 10, 12, 14, 16, 18 ]

Este m茅todo no se podr铆a utilizar para array que tengan m谩s de un nivel de profundidad. Sin embargo, se pueden combinar los m茅todos flat y map para tener un mismo resultado.

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

numbers2.flat(Infinity).map(num => num * 2) // [ 2, 4, 6, 8, 10, 12, 14, 16, 18 ]

No me gusta como explica Oscar, primer curso que veo con 茅l y de verdad no me da a entender, usa muchas palabras repetidas, no usa las palabras correctas para definir un elemento (funciones, m茅todos, etc). Definitivamente de un 100% le doy 20% en sus explicaciones, el 80% se los doy al sistema de comentarios, all铆 entiendo la clase.

Les recomiendo You. Es como google pero dedicado a developers. All铆 pueden buscar todo lo relacionado a la programaci贸n.

Actualmente, se puede usar el m茅todo .trim() el cual har谩 el trimStart y el trimEnd

Para el primer ejemplo del flat solo es necesario dos niveles, es decir

console.log(array.flat(2));

Termine de entender la funcionalidad con estas pruebas. el map es porque por cada elemento ejecuta una funcion, y el flat, porque si la funcion retorna un array, entonces lo aplana en integra al principal

const array2 = [1,2,3,4,5];
console.log(array2.flatMap( v => v * 2));
console.log(array2.flatMap( v => [v, v * 2]));

No veo el punto de este curso. Entiendo que el objetivo es mostrarnos los cambios que ocurrieron a partir de ES6, pero se ven de una forma extremadamente superficial y mal explicada, el 80% de los cambios no me quedan ni m铆nimamente claros solo con ver las clases, hace falta buscar por otros lados o leer los comentarios para que m铆nimamente se entienda.
Repito, entiendo que la idea es ir viendo los cambios, pero; 驴No ser铆a mejor ir vi茅ndolos de manera mas org谩nica a lo largo de los cursos junto con alguna aplicaci贸n medianamente real? Verlos de forma suelta y sin una utilidad practica hace que sean f谩cilmente olvidables y por lo tanto hace que este curso carezca de sentido para mi.
No se si es culpa del profesor que no supo plantear suficientemente bien las clases o quien es el responsable, pero claramente este curso no esta a la altura de los dem谩s que hemos visto hasta ahora.
Espero que el siguiente curso de la ruta, que tambi茅n ser谩 con Oscar sea mas claro y organizado.

para aclarar el ejemplo de flatMap del profe, como su nombre lo indica flatMap, lo que har谩 es aplanar el array y mapearlo, osea pasar por cada valar, esto nos podr铆a servir para hacer validaciones o operaciones sea el caso,

[Input]
const array2 = [1, 2, 3, 4 ,5];
console.log(array2.flatMap(value => [ value * 3]));

[Output]
[ 3, 6, 9, 12, 15 ]

en este ejemplo se esta pasando que cada valor que mapee sera value
pero a cada value lo estamos multiplicando por otro valor en este caso 3
lo que pasara es que va a agarrar cada elemento del
array y lo multiplicara por este鈥 espero les sirva agradezco que me den feedback

Como dato extra, si usamos el metodo

trim()

脡ste nos elimina tanto los espacios a la derecha como a la izquierda 馃挭馃徏

Hellooo, I come here to the comments section because I see a lot of disappointment in the explanations of this class. I am no stranger to this and I also think there is a lack of theory that is being taken for granted, but I also understand this course is intended to show us the new features that ECMAScript has developed since the sixth version rather than a deeper explanation about them. Anyways, as I am taking all the JavaScript courses from the learning route, I have been developed a Github repository where you can find some more detailed explanations about the topics

https://github.com/Zaprovic/Javascript

I hope someone sees this comment and give a shot to my project Never stop learning guys!

El flatMap del array dos, me record贸 a las sucesiones num茅ricas:

Otra manera de probarlo 馃槂

const hello = '           Hello World!       ';
console.log(`[${hello.trimStart()}]`);
console.log(`[${hello.trimEnd()}]`);
// flat => aplana las matrices por profundidad
const array = [1, 2, 3, 4, [1, 2, 3, 4, [1, 2, 3, 4]]];
console.log(array.flat(2));

// flatMap() => Mapea y aplana, devuelve un array con los valores aplanados y da la opci贸n de ejecutar un callback por cada uno de los elementos
const array2 = [1, 2, 3, 4, 5];
console.log(array2.flatMap((v) => [v, v * 2]));

隆Hola t煤!
驴Un poco perdido con flat-map? Te recomiendo esta clase, Nicolas me parece que tiene una gran habilidad para la ense帽anza.

Importante.
Flat por defecto solo aplana un nivel. Por este motivo recibe como par谩metro el n煤mero de veces que va a aplanar.

.flat(3)
<code> 

Ejemplo:

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

const aplanadora = array.flat(2);
console.log(aplanadora);
<code> 

Este ser铆a el resultado:


const array = [1, 2, 3, 4, 5, 6, 7, 8, [9, 10, 11, 12, 13]];
<code> 

Esto se debe a que solo le dijimos que aplanara hasta el segundo nivel.

trim() , elimina los espacios del comienzo y final

const nombre = '             manuel               '

console.log(nombre.trim())

No entiendo como es que este bro llego tan lejos sin explicar absolutamente nada, aqu铆 ni siquiera explica por que el m茅todo flat map toma como parametros una funcion y un array y todos los cursos de esta ruta son iguales. Hasta ahora hab铆a sido divertido ver los cursos, pero ver esto se convirtio en una aut茅ntica tortura digna de una clase de universidad en donde escuchas al profesor parlotear y parlotear durante horas rezando para que el tiempo pase r谩pido y puedas tomar un respiro.

tuve que investigar todo por mi cuenta y eso alargo innecesariamente el tiempo que me tom贸 comprender esto, definitivamente mi mejor consejo es que se salten este curso y el pr贸ximo y aprendan ecmascript sobre la marcha.

```js const hello = " Hello World! "; console.log(hello.trimStart()); console.log(hello.trimEnd()); console.log(hello.trimStart().trimEnd()); ```const hello = " 聽 聽 聽 聽 Hello World! 聽 聽 ";console.log(hello.trimStart());console.log(hello.trimEnd()); console.log(hello.trimStart().trimEnd());

Oscar me cae bien, pero鈥 explica MUY MAL. el simplemente coloco la funcion, mostro el resultado, Nada de que paso detras de camara, para que se usa esa funcion, para que me puede ser util鈥 en verda, pesima explicacion! Definitivamente, si no fuera porque se que otros cursos, lo dan otros teacher, con mas entusiamos y que detallan mas y abundan mas, pues鈥 Platzi no valdria nada, por gente como Oscar.
Y que conste, amo platzi!, profesores como Diego, el gran JuanDC motivan, y ayudan a entender mejor las cosas鈥 pero es que oscar, debe de mejorar!

Tambi茅n pueden hacer esto鈥
INPUT :

const array2 = [1,2,3,4,5];
console.log(array2.flatMap(value => [[value * 2],[value]]));

OUTPUT :

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

Array.prototype.flat()

flat聽que en ingles significa 鈥減lano鈥 es el nombre del m茅todo en el prototipo del objeto Array que regresa una versi贸n 鈥渁planada鈥 del arreglo en cuesti贸n. Si no le pasamos ning煤n argumento se asume una profundidad de 1. De lo contrario si cualquier numero entero positivo es pasado como argumento este usa como la profundidad m谩xima a iterar a la hora de 鈥渁planar鈥 el arreglo.

Es decir, si tenemos el siguiente arreglo y una profundidad de 1

let a = [1, [2, 3], [4, 5], 6]

El arreglo 鈥渁planado鈥 ser铆a

[1, 2, 3, 4, 5, 6]

Si tenemos el siguiente arreglo y una profundidad de 2

let b = [1, [2, [3]], [4, [5, 6]]]

El arreglo aplanado ser铆a otra vez:

[1, 2, 3, 4, 5, 6]

Ahora para comprender mejor veamos como se comporta el m茅todo:

console.log(a.flat());
> Array(6) [ 1, 2, 3, 4, 5, 6 ]

console.log(b.flat(2));
> Array(6) [ 1, 2, 3, 4, 5, 6 ]

console.log(b.flat())
> Array(5) [1, 2, [3], 4, [5, 6]]

Noten como afecta la profundidad cuando no pasamos el argumento adecuado. Pero 驴qu茅 pasa si quisi茅ramos aplanar un arreglo cuya profundidad desconocemos? Bien JavaScript introduce la constante聽Infinity,聽de modo que podemos hacer esto:

let arreglo = [1, ...., [190736], 190737];

arreglo.flat(Infinity);

Array.prototype.flatMap()

flatMap()聽es un m茅todo disponible en el prototipo del Array que tiene el mismo efecto que usar el m茅todo聽map()聽seguido inmediatamente del m茅todo聽flat()聽con una profundidad por defecto de 1. En otras palabras,聽flatMap(),聽mapea cada valor a un nuevo valor y el resultado es aplanado a una profundidad m谩xima de 1.

let transporte = ["avi贸n", "auto", "barco"];
let tipoTransporte = ["a茅reo", "terrestre", "mar铆timo"];

let transportesMapeados = transporte.map(
        (transporte, indice) => [transporte, tipoTransporte[indice]]
    );

let transportesMapeadosYAplanados = transporte.flatMap(
        (transporte, indice) => [transporte, tipoTransporte[indice]]
    );

Al correr estos ejemplos podemos ver claramente la diferencia principal entre uno y otro. El resultado de imprimir la variable聽transportesMapeados聽ser铆a el siguiente:

[
  [ "avi贸n", "a茅reo" ]
  [ "auto", "terrestre" ]
  [ "barco", "mar铆timo" ]
]

Entonces si la definici贸n de聽flatMap聽dice que al resultado de un聽map聽se le aplica聽flat聽de profundidad 1, al imprimir聽transportesMapeadosYAplanados聽tendr铆amos como resultado el siguiente arreglo:

[ "avi贸n", "a茅reo", "auto", "terrestre", "barco", "mar铆timo" ]

Compatibilidad

El soporte para estos dos m茅todos ya esta disponible en las ultimas versiones de los navegadores:

  • Chrome 69+
  • Firefox 12+
  • Safari 12+

informaci贸n extra: el m茅todo trim elimina los espacios libres en el inicio y el final, puede que ahorra mas l铆neas de codigo usar este metodo馃榾

const greeting = '   Hello world!   ';

console.log(greeting);
// Expected output: "   Hello world!   ";

console.log(greeting.trim());
// Expected output: "Hello world!";

鈫扐puntes 馃崕鈫
flat

Se usa el metodo integrado .flat para aplanar objetos,arrays y trabajar de mejor manera con los datos.

const array = [1,2,4,2,1,2,5,[1,2,3,5,3,[1,2,4]]];
console.log(array.flat(3));
//output: 
[
  1, 2, 4, 2, 1, 2,
  5, 1, 2, 3, 5, 3,
  1, 2, 4
]

flatmap

aplica una funci贸n a cada uno de los valores uno por uno de un array.

const array2 = [1,2,4,6,4,2]
console.log(array2.flatMap(v =>(v, v * 3)));
//ouput: [ 3, 6, 12, 18, 12, 6 ]

TrimStart y trimEnd 馃殌

El trimStart() m茅todo de String values elimina el espacio en blanco desde el principio de esta cadena y devuelve una nueva cadena, sin modificar la cadena original. trimLeft() es un alias de este m茅todo.

const hello = '              Estudio en platzi         ';
let hello1 = hello.trimStart();
console.log(hello1.trimEnd());

Edit : Regalame un like por el resumen 馃槂

trimStart = es un m茅todo que se usa para eliminar espacios de la parte inicial;
trimEnd = se usa para lo mismo pero elimina espacios de la parte final;

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimStart
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimEnd

Personalmente me he encontrado en la situacion donde no entiendo nada de lo que epxlica el profe gndx. pero sucede que nunca hab铆a estudiado esto, entonces pues, buscar en Google o YouTube y seguir lineas paralelas al curso (cierto, eso despista y quite tiempo), pero es lo que d谩 maestr铆a. O al menos eso creo. como Sea, no se rindan!馃 tenemos un trabajo en tecnolog铆a esper谩ndonos

ES10: flatMap y trimStart-trimEnd


En ECMAScript 2019 (tambi茅n conocido como ES10), se introdujeron varias caracter铆sticas nuevas en JavaScript. Dos de estas caracter铆sticas son 鈥淢apa Plano鈥 (flatMap) y los m茅todos trimStart y trimEnd. Aqu铆 te explico brevemente cada una de ellas:

1. Mapa Plano (flatMap):
flatMap es una funci贸n que se agreg贸 a los arreglos en ES10. Combina los pasos de mapeo y aplanamiento en un solo paso. La funci贸n flatMap toma una funci贸n como argumento y esta funci贸n se aplica a cada elemento del arreglo. Luego, los resultados se aplanan en un solo arreglo. Esto es 煤til cuando deseas transformar cada elemento del arreglo y luego unir los resultados en un solo arreglo.

Ejemplo:

const numeros = [1, 2, 3, 4];

const duplicados = numeros.flatMap(numero => [numero, numero]);

console.log(duplicados); // Resultado: [1, 1, 2, 2, 3, 3, 4, 4]


2. M茅todos trimStart y trimEnd:
Los m茅todos trimStart y trimEnd se agregaron a las cadenas de texto en ES10. trimStart elimina los espacios en blanco y caracteres de salto de l铆nea al comienzo de una cadena, mientras que trimEnd hace lo mismo al final de la cadena.

Ejemplo:

const texto = "   隆Hola, mundo!   ";

console.log(texto.trimStart()); // Resultado: "隆Hola, mundo!   "
console.log(texto.trimEnd());   // Resultado: "   隆Hola, mundo!"


Estos m茅todos son 煤tiles para limpiar cadenas de texto que pueden contener espacios en blanco adicionales al principio o al final.

Estas caracter铆sticas de ES10 hacen que trabajar con arreglos y cadenas de texto sea m谩s conveniente y expresivo al permitir operaciones m谩s concisas y efectivas.


Explicado de manera m谩s sencilla



Veamos estas caracter铆sticas de JavaScript de manera m谩s sencilla:

1. Mapa Plano (flatMap):
Imagina que tienes una caja llena de bloques de colores diferentes. Quieres tomar cada bloque, hacer una copia de 茅l y poner ambas copias en una fila. Al final, tendr谩s una fila de bloques duplicados. Eso es lo que hace flatMap.

En t茅rminos de programaci贸n, si tienes una lista de n煤meros y usas flatMap con una regla, tomar谩 cada n煤mero, aplicar谩 la regla y luego pondr谩 los resultados juntos en una lista.

Por ejemplo, si tienes [1, 2, 3] y aplicas una regla que duplica cada n煤mero, obtendr谩s [1, 1, 2, 2, 3, 3]. Es como si hubieras duplicado cada n煤mero y luego los pusieras en fila.

2. M茅todos trimStart y trimEnd:
Imagina que est谩s escribiendo una carta y accidentalmente dejas demasiados espacios al principio o al final de la p谩gina. Parece un poco desordenado, 驴verdad? trimStart y trimEnd son como una goma de borrar m谩gica que borra esos espacios extras al principio o al final de una frase.

En t茅rminos de programaci贸n, si tienes una palabra o una oraci贸n con espacios extra al principio o al final, puedes usar trimStart para borrar los espacios al principio, y trimEnd para borrar los espacios al final. Esto te ayuda a mantener las cosas ordenadas y limpias.

En resumen, estas caracter铆sticas en JavaScript (Mapa Plano y trimStart/trimEnd) son como trucos 煤tiles que te permiten hacer cosas interesantes con listas de n煤meros y cadenas de texto. Hacen que el c贸digo sea m谩s simple y te ayudan a mantener tus datos ordenados y sin cosas innecesarias.

Espero sea de utilidad. 馃懆鈥嶐煉

Esto es excelente porque, (aun no s茅) hay m茅todos como el join() que en ciertos entornos de desarrollo retornan un array dentro de otro array. :C o aveces algunos json al hacer la conversion a array, estos retornan como un array anidado y para no andar accediendo manualmente con el m茅todo de entrar al array. [0], este m茅todo es bueno justamente para combatir esa manipulaci贸n de objetos avanzada

Resumen a punta de c贸digo:

const hello = '  Hello world  '
console.log(hello.trimStart()) // 'Hello world  '
console.log(hello.trimEnd()) // '  Hello world'
console.log(hello.trim()) // 'Hello world'
const matriz = [1, 1, 2, 3, 4, [1, 3, 5, 6, [1, 2, 4]]]
console.log(matriz.flat(0))
// OUT - [ 1, 1, 2, 3, 4, [ 1, 3, 5, 6, [ 1, 2, 4 ] ] ]
console.log(matriz.flat(1))
// OUT - [ 1, 1, 2, 3, 4, 1, 3, 5, 6, [ 1, 2, 4 ] ]
console.log(matriz.flat(Infinity))
// OUT - [ 1, 1, 2, 3, 4, 1, 3, 5, 6, 1, 2, 4 ]
const numbers = [1,2, 3, 4]
numbers.flatMap(number => [number *2]) 
// [2, 4, 6, 8]

las v => [v, v donde salieron o para que sirve

me estan pareciendo terribles las explicaciones

馃摑 Archivos del Proyecto 馃摑


Pasos 馃搶


鈥 Vamos a VS Code, dentro de la carpeta src, se crea la carpeta es10.
鈥 Dentro de la carpeta es10, crear el archivo llamado: 00-flat-map.js
鈼 El c贸digo queda:

//Compilar: seleccionar el c贸digo + click derecho + Run Code

// flat
//Ejercicio #1

const array = [1, 1, 2, 3, 4 [1, 3, 5, 6 [1, 2, 4]]];
console.log(array.flat(3));

/*output: sale undeined porque no se separ贸 con comas al comenzar los otros arreglos
[ 1, 1, 2, 3, undefined ]
*/

//Ejercicio #2

const array2 = [1, 1, 2, 3, 4, [1, 3, 5, 6, [1, 2, 4]]];
console.log(array2.flat(3));

/*output: sale undeined porque no se separ贸 con comas al comenzar los otros arreglos
[
1, 1, 2, 3, 4,
1, 3, 5, 6, 1,
2, 4
]
*/

// flatmap
//Ejercicio #3

const array3 = [1, 2, 3, 4, 5];
console.log(array3.flatMap(v => [v, v * 2]));

/*output:
[
1, 2, 2, 4, 3,
6, 4, 8, 5, 10
]
*/


鈥 Dentro de la carpeta es10, crear el archivo llamado: 01-trimstart-trimend.js
鈼 El c贸digo queda:

//Compilar: seleccionar el c贸digo + click derecho + Run Code

//Ejercicio #1
const hello = ' Hello World! ';
console.log(hello.trimStart());

/*output: elimin贸 los espacios de inicio
Hello World! 
*/

console.log(hello.trimEnd());

/*output: elimin贸 los espacios despu茅s de la frase
Hello World!
*/

adiosarraysinfinitos asl帽dk帽lsadk

Mi resumen:

Probablemente sea un dato menor, pero en el primer ejemplo que se da para aplicar el metodo .flat() , el array SI, tiene una profundidad de 3, pero con que le pases 2 como parametro esta bien.
Piensalo como, si le pones 1, solo se lo aplicara a los arrays que se encuentre en el primer nivel, si le pones dos, a los que se encuentren en el segundo lugar, etcetera

Un ejemplo

let numbers = [1, 2, 3, [4, 5, 6, [7, 8, 9]]]; // Este array se puede aplanar hasta el nivl 2
console.log(numbers.flat(0)); // no aplana [ 1, 2, 3, [ 4, 5, 6, [ 7, 8, 9 ] ] ]
console.log(numbers.flat(1)); // aplana 1 nivel [ 1, 2, 3, 4, 5, 6, [ 7, 8, 9 ] ]
console.log(numbers.flat(2)); // aplana 2 niveles [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

24/35 ES10: flat-map y trimStart-trimEnd
Los m茅todos flat y flatMap para realizar aplanamiento de arrays, es decir, convertir un array de arrays en una sola dimensi贸n. El m茅todo flat recibe como argumentos la profundidad del aplanamiento y retorna un nuevo array con los cambios sin modificar el array original. El m茅todo flatMap es una combianci贸n de los m茅todos map y flat, realiza la iteraci贸n de los elementos del array y despu茅s los aplana e una sola profundidad.

Tres m茅todos para eliminar espacios en blanco de un string: trim, trimStart o trimLeft y trimEnd o trimRight. El m茅todo trim elimina los espacios al inicio y trimEnd o trimRight elimina los espacios al final.

Ejemplos:

  • Aplanamiento de arrays:
    • El array [1,2,[3,4],5,6] se puede aplanar con el m茅todo flat sin argumentos y retorna [1,2,3,4,5,6].
    • El array [1, 2, [3, 4, [5, 6]]] se puede aplanar con el m茅todo flat sin argumentos y retorna [1, 2, 3, 4, [5, 6]].
    • El array [1, 2, [3, 4, [5, 6]]] se puede aplanar con el m茅todo flat con un argumento de 2 y retorna [1, 2, 3, 4, 5, 6].
    • El array [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]] se puede aplanar con el m茅todo flat con un argumento de Infinity y retorna [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].
    • El m茅todo flatMap se puede utilizar para iterar y aplanar los elementos de un array al mismo tiempo, por ejemplo, se puede utilizar el m茅todo flatMap para dividir una cadena en palabras y aplanarlas en una sola dimensi贸n.
  • Eliminaci贸n de espacios en blanco de un string
    • La cadena " hola " se puede eliminar los espacios en blanco al inicio y al final utilizando el m茅todo trim y retorna 鈥渉ola鈥.
    • La cadena " hola " se puede eliminar los espacios en blanco al inicio utilizando el m茅todo trimStart o trimLeft y retorna "hola ".
    • La cadena " hola " se puede eliminar los espacios en blanco al final utilizando el m茅todo trimEnd o trimRight y retorna " hola".

Seg煤n entend铆, flat convierte un arreglo de arreglos anidados en una matriz con n filas

FlatMap para que se entienda un poquito mas su concepto

// flatmap
const array2 = [1, 2, 3, 4];
const flatMapArray = array2.flatMap(v => [v * 2]);
console.log(array2); // [ 1, 2, 3, 4 ]
console.log(flatMapArray); // [ 2, 4, 6, 8 ]

Un ejemplo para entender mas graficamente los trim

const cadena ='          Cadena sin higienizar                ';
const resultado=[
    [cadena,cadena.length],
    [cadena.trimStart(),cadena.trimStart().length],
    [cadena.trimStart().trimEnd(),cadena.trimStart().trimEnd.length]];;
console.table(resultado);

Muestra en consola una tabla con las longitudes despues de cada uso sin alterar el string

Paso a comentarles que se puede hacer console.log(nombreVariable.trimStart().trimEnd()); en una sola l铆nea.

Al flat se le puede poner como argumento Infinity y quitar谩 todos los sub-arrays

He notado que las clases estan muy basadas en w3schools,

Un Website que yo consideraba el Wikipedia de algunos lenguajes ya que funciona pero hay mas o menos.

https://www.w3schools.com/js/js_2019.asp#mark_trim_start

Ni modo veo los videos, W3schools y Firefox

Pq este curso lo termino o lo termino, aunque no termino encantando

Algunos ejemplos de los m茅todos flat y flatMap

//M茅todo flat
//Tenemos un arreglo de 3 dimensiones.
const array = [1,1,2,3,4, [1,3,5,6, [1,2,4]]];

const array2 = array.flat(3); //El m茅todo flat aplana la profundidad del arreglo, generando uno nuevo de una sola dimensi贸n llamado array2. 

//Ahora ya podemos acceder a cada uno de sus elementos facilmente,por ejemplo con un for...
for (let i in array2){
  console.log(i);
}

//El m茅todo flatmap
//Tenenos inicialmente un arreglo plano en una dimensi贸n
const array3 = [1,2,3,4,5];

//Con el m茅todo flatMap, podemos modificar o paras una funci贸n que modifique o haga alguna operaci贸n con los valores de 茅ste arreglo, devolviendo un arreglo con 茅stos valores modificados.
//Ejemplo 1, modificamos los valores del arreglo inicial multiplicandolos por 2
const array4 = array3.flatMap(v => [v*2]);
console.log(array4);

//Ejemplo 2. MOdificamos el arreglo inicial dividiendo los valores en 2 y creando un nuevo arreglo con los valores modificados

const array5 = array3.flatMap(v => [v/2]);
console.log(array5);

//Ejemplo 3. Modificamos el arreglo sumandole 2  cada elemento, pero creamos un arreglo con la convinaci贸n de los dos arreglos, el inicial y el modificado.
const array6 = array3.flatMap(v => [v, v + 2]);
console.log(array6);

En realidad el nivel de profundidad para aplanar este array o matriz seria 2, es decir, con flat(2) es suficiente.

**trimStart-trimEnd
**
trim elimina los espacios al inicio .trimstart() o al final .trimend() o a ambos lados .trim()

Ejemplo:

const hello = '                  Hola Mundo!!                  ';
console.log(hello.trimStart());
console.log(hello.trimEnd());
console.log(hello.trim());
respuesta de consola: 
Hola Mundo!!               ;
               Hola Mundo!!;
 Hola Mundo!!;
const hello = '        Hello!        ';
// Recorta los espacios de un string al inicio
console.log(hello.trimStart());
// Recorta los espacios de un string al final
console.log(hello.trimEnd());