Esta clase es otro nivel. Yo hubiera pensado que map mutó mi array, pero resulta que no, que solo lo dejó en la referencia de la memoria. Y la técnica para agregar sin cambiar la referencia vale su peso en oro.
Por cosas así es que pago por Platzi.
Ahora que ya sabes cómo funciona el método map de arrays estudiemos diferentes situaciones que deberás manejar array de objetos como los siguientes datos de orders.
const orders = [ { customerName: "Nicolas", total: 60, delivered: true, }, { customerName: "Zulema", total: 120, delivered: false, }, { customerName: "Santiago", total: 180, delivered: true, }, { customerName: "Valentina", total: 240, delivered: true, }, ]
Extrayendo datos necesarios
De un conjunto de datos a veces necesitas ciertos atributos para realizar una operación, extraer los nombres o cuantificar un suceso. El método map te permite extraer estos datos según los puedas utilizar.
const totales = orders.map(order => order.total) console.log(totales) // [ 60, 120, 180, 240 ]
Transformando objetos dentro de un array
De un conjunto de datos, de los cuales son objetos, a veces requieres añadir una propiedad nueva o eliminar una que no es necesaria. Si necesitas transformar objetos dentro de un array, debes tener en cuenta que cada objeto tiene una referencia en memoria propia. Por lo que si transformas un objeto, también lo harás en el original como en el nuevo, aun cuando el método map es inmutable.
Los parámetros por referencia los debes tener presente cuando manejes objetos y arrays.
// Ejemplo donde transformas los objetos originales const tarifas = orders.map(order => { order.tax = 0.19 return order }) tarifas[0] === orders[0] // true tarifas[1] === orders[1] // true
Una forma de evitar este comportamiento, es crear un nuevo objeto con el spread operator (operador de propagación).
// Ejemplo donde no transformas los objetos originales const tarifas = orders.map(order => { return { ...order, item: 0.19, } }) tarifas[0] === orders[0] // false tarifas[1] === orders[1] // false
Contribución creada por: Andrés Guano.
Ahora que ya sabes cómo funciona el método map de arrays estudiemos diferentes situaciones que deberás manejar array de objetos como los siguientes datos de orders.
const orders = [
{
customerName: "Nicolas",
total: 60,
delivered: true,
},
{
customerName: "Zulema",
total: 120,
delivered: false,
},
{
customerName: "Santiago",
total: 180,
delivered: true,
},
{
customerName: "Valentina",
total: 240,
delivered: true,
},
]
De un conjunto de datos a veces necesitas ciertos atributos para realizar una operación, extraer los nombres o cuantificar un suceso. El método map te permite extraer estos datos según los puedas utilizar.
const totales = orders.map(order => order.total)
console.log(totales) // [ 60, 120, 180, 240 ]
De un conjunto de datos, de los cuales son objetos, a veces requieres añadir una propiedad nueva o eliminar una que no es necesaria. Si necesitas transformar objetos dentro de un array, debes tener en cuenta que cada objeto tiene una referencia en memoria propia. Por lo que si transformas un objeto, también lo harás en el original como en el nuevo, aun cuando el método map es inmutable.
Los parámetros por referencia los debes tener presente cuando manejes objetos y arrays.
// Ejemplo donde transformas los objetos originales
const tarifas = orders.map(order => {
order.tax = 0.19
return order
})
tarifas[0] === orders[0] // true
tarifas[1] === orders[1] // true
Una forma de evitar este comportamiento, es crear un nuevo objeto con el spread operator (operador de propagación).
// Ejemplo donde no transformas los objetos originales
const tarifas = orders.map(order => {
return {
...order,
item: 0.19,
}
})
tarifas[0] === orders[0] // false
tarifas[1] === orders[1] // false
Contribución creada por: Andrés Guano.
Esta clase es otro nivel. Yo hubiera pensado que map mutó mi array, pero resulta que no, que solo lo dejó en la referencia de la memoria. Y la técnica para agregar sin cambiar la referencia vale su peso en oro.
Por cosas así es que pago por Platzi.
Aquí va el array de objetos para el ejercicio :)
const orders = [
{
customerName: "Nicolas",
total: 60,
delivered: true,
},
{
customerName: "Zulema",
total: 120,
delivered: false,
},
{
customerName: "Santiago",
total: 180,
delivered: true,
},
{
customerName: "Valentina",
total: 240,
delivered: true,
},
];
Usos comunes o clásicos de map() sobre los arrays:
.
Tener en cuenta que cuando trabajamos con objetos y map() y retornamos el mismo objeto estamos copiando la referencia en memoria que tiene el objeto original que le aplicamos el map() (esto lo vimos en la clase de mutable vs inmutable, te dejo una lectura: https://platzi.com/tutoriales/1642-javascript-profesional/4559-estructuras-de-datos-inmutables/). Esto provoca que como estamos modificando la referencia en memoria, el original también sea . Entonces en conclusión, por más que sea en este punto estamos copiando la referencia en memoria y por eso hace el cambio en el original.
arraymap()// Estamos retornando el objeto
// por ende se copia la refencia en memoria
const rta = orders.map(item => {
item.tax = .19
return item;
})
Para evitarlo, y poder realizar una copia y evitar la referencia en memoria, utilizamos el spread operator de ES6 (https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Spread_syntax), donde generamos un nuevo objeto con los valores del objeto original y luego agregamos el nuevo valor que nos interesa.
const rta = orders.map(item => {
// retornamos un nuevo objeto
//pero evitamos hacer ref. en memoria
return {
...item,
tax: .19,
}
})

Y esas líneas se pueden reducir aún más :):
const withTax = orders.map(order => ({ ...order, tax: .17 }))
Para entender por qué se modifica el array cuando trabajamos con objetos les recomiendo la clase donde JuanDC nos explica como funciona la memoria en JS: https://platzi.com/clases/2419-javascript-poo-intermedio/39811-como-funciona-la-memoria-en-javascript/
Faltó como modificar una propiedad en otra referencia en memoria sin modificar el original:
// Modificar el original en otro objeto en memoria
const resp4 = orders.map(item => {
return {
...item,
total: item.total + 5,
};
});
console.log('Resp4:', resp4);
console.log('Original:', orders);
Tener cuidado con el spread operator. si el objeto contiene otros objetos, se seguirán copiando las referencias en memoria de estos. Les recomiendo el curso POO intermedio donde profundiza este tema.
Utilizando el spread operator, cogemos los valores de person y los insertamos directamente en X. Así evitamos anidar un abjeto dentro de otro
Con el spread operator, podemos sumar arrays, hacer copias, añadir nuevos elementos…
Fuente: https://dev.to/lydiahallie/interactive-javascript-quiz-2-4pi1
Los navegadores web usan dos tipos de memorias: Stack y Heap.
Es veloz, pero sin tanto espacio.
Aquí se guardan los valores primitivos (booleanos, strings, números…).
Es más lenta, pero permite guardar enormes cantidades de información.
Gonzalo Palacios
José Luis Encastin Flores
Irving Juárez
Lucas Frezzini
German Cavani
Marcos Edwin Day
Lucas Frezzini
Nazareno Aznar Altamiranda
Lucas Frezzini
Jeremy Palomino
Juan Jose Mayorga
Alex hernandez mitre
Stephany Plaza
Stefan Sanchez
Nicolas Molina
ProfesorJulian David Orozco Colorado
Carlos Rodríguez
Nicolas Molina
ProfesorJeffrey Vegas
Luis Fernando Cortes Duque
milton coronado
jesus gomez
Oriana Morillo
Stephany Plaza
Jesús Velázquez Jiménez
Irving Juárez
Iván Rodríguez
Kevin Zavala
Luis Gómez ojeda
Obed Paz
Bramucci Candela
Nicolas Molina
ProfesorJesús David Mejía Orozco
José Alberto Ramírez Quiroz
Irving Juárez
Orangel Gonzalez
Luciano Marchese
Esta clase es otro nivel. Yo hubiera pensado que map mutó mi array, pero resulta que no, que solo lo dejó en la referencia de la memoria. Y la técnica para agregar sin cambiar la referencia vale su peso en oro.
Por cosas así es que pago por Platzi.
Coincido, leí otros métodos de clonación en internet, pero eran demasiado complejos, y en este caso lo hicieron más sencillo.
En el curso intermedio de POO con js se profundiza en esto e incluso te enseñan como hacer variables privadas paras tus prototipos, algo que no viene por defecto en JS pero que se puede inplementar gracias a los closures
Aquí va el array de objetos para el ejercicio :)
const orders = [ { customerName: "Nicolas", total: 60, delivered: true, }, { customerName: "Zulema", total: 120, delivered: false, }, { customerName: "Santiago", total: 180, delivered: true, }, { customerName: "Valentina", total: 240, delivered: true, }, ];
Muchas gracias!
Genio!. Gracias!
Usos comunes o clásicos de map() sobre los arrays:
.
Tener en cuenta que cuando trabajamos con objetos y map() y retornamos el mismo objeto estamos copiando la referencia en memoria que tiene el objeto original que le aplicamos el map() (esto lo vimos en la clase de mutable vs inmutable, te dejo una lectura: https://platzi.com/tutoriales/1642-javascript-profesional/4559-estructuras-de-datos-inmutables/). Esto provoca que como estamos modificando la referencia en memoria, el array original también sea modificado. Entonces en conclusión, por más que map() sea inmutable en este punto estamos copiando la referencia en memoria y por eso hace el cambio en el original.
// Estamos retornando el objeto // por ende se copia la refencia en memoria const rta = orders.map(item => { item.tax = .19 return item; })
Para evitarlo, y poder realizar una copia y evitar la referencia en memoria, utilizamos el spread operator de ES6 (https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Spread_syntax), donde generamos un nuevo objeto con los valores del objeto original y luego agregamos el nuevo valor que nos interesa.
const rta = orders.map(item => { // retornamos un nuevo objeto //pero evitamos hacer ref. en memoria return { ...item, tax: .19, } })
No termino de entender por qué hacer una copia de la referencia de la memoria hace que el original también cambie, es algo que quizas da para profundizar pero no se por donde buscar ¿Tenés alguna idea de esto?
@nazarenoalt sí caballero, de todo lo que he leido, la mejor definicion e ilustración para que quede bien claro lo encontre acá: https://es.javascript.info/object-copy y está super sencillo. Te recomiendo echarle un vistazo si tienes tiempo a todo el libro, es super completo e intuitivo.
Y esas líneas se pueden reducir aún más :):
const withTax = orders.map(order => ({ ...order, tax: .17 }))
excelente solución !!
crack!!
Para entender por qué se modifica el array cuando trabajamos con objetos les recomiendo la clase donde JuanDC nos explica como funciona la memoria en JS: https://platzi.com/clases/2419-javascript-poo-intermedio/39811-como-funciona-la-memoria-en-javascript/
Genial gran clase que aporta mucho a este tema.
ahora si lo comprendi completo
Faltó como modificar una propiedad en otra referencia en memoria sin modificar el original:
// Modificar el original en otro objeto en memoria const resp4 = orders.map(item => { return { ...item, total: item.total + 5, }; }); console.log('Resp4:', resp4); console.log('Original:', orders);
Muy buen ejemplo
Tener cuidado con el spread operator. si el objeto contiene otros objetos, se seguirán copiando las referencias en memoria de estos. Les recomiendo el curso POO intermedio donde profundiza este tema.
Ya sabia esto un poco y muchas gracias por recordarlo a todos y raro que el profe no exponga estas situaciones. Hasta ahora no he visto una clase especifica para spread operator
es poco usual realizar copias de objetos y que sean diferentes, es mas javascript no tiene ningun metodo para esto... lo comun y "normal" es realizar copias conreferencia al mismo objeto.
solo en casos muy especificos y poco usuales es necesario realizar copias del objeto propiamente dicho y no la referencia en memoria.
fuente: stack overflow
Spread Operator
Utilizando el spread operator, cogemos los valores de person y los insertamos directamente en X. Así evitamos anidar un abjeto dentro de otro Con el spread operator, podemos sumar arrays, hacer copias, añadir nuevos elementos…
Excelente aporte!
super valioso muchas gracias
Los navegadores web usan dos tipos de memorias: Stack y Heap.
Stack
Es veloz, pero sin tanto espacio.
Aquí se guardan los valores primitivos (booleanos, strings, números…).
Heap
Es más lenta, pero permite guardar enormes cantidades de información.
Podriamos agregar la propiedad tax de una manera un poco mas real de la siguiente manera:
const products = [ { name: "Chiken", price: 43 }, { name: "Ken", price: 12 }, { name: "Horse", price: 234 }, ]; const wTax = products.map((product) => { let thetax = product.price * 0.16; return { ...product, tax: thetax, total: thetax + product.price }; }); console.log("original", products); console.log("with tax", wTax);
gracias tq
De mis métodos favoritos <3 el array map, realmente te ayuda a hacer un código mucho más limpio y a implementar o mapear todo para evitar errores al momento de trabajar con arrays de objetos que no traigan la información en un formato correspondiente, por ejemplo, si el objeto trae los números en cadenas de caracteres puedes transformarlos en números dentro del map y evitarte validaciones futuras.
cuando trabajamos con objetos hay que entender un concepto muy importante a la hora de copiarlos ++La referencia en memoria:++ Cuando creamos un objeto, este es almacenado en dos tipos de memorias: memoria stack: -Esta es una memoria dinámica pero con poco espacio
memoria heap: -Esta es una memoria mas lenta pero mas ordenada y con mas espacio -En esta memoria es donde se almacenan los arrays y los objetos
Que joyita de clase 😮😮
Por qué el título 'Map Reloaded' ? Es simplemente una forma de decir que vamos a ver el método más a profundidad?
Si es correcto solo es una forma de decir que vamos a ver más detalles de esa función y casos de uso.
Spread Operator
Esto puede ser muy útil en casos donde tenemos que pasar una lista de argumentos (no un array) a un método/función.
Antes de comenzar es importante resaltar el spread operator fue incluido en la nueva versión de Javascript ES6 y ya funciona en todos los navegadores.
Comencemos!
let numeros = [4, 16, 25, 2, 45, 8]; let numeroMayor = Math.max(numeros); console.log(numeroMayor); // NaN
Observamos que el valor de la variable numeroMayor es NAN, esto es porque el método max() puede recibir una lista de argumentos y no le podemos pasar un array.
Entonces podríamos hacer los siguiente:
let numeroMayor = Math.max(4, 16, 25, 2, 45, 8); console.log(numeroMayor); // 45
Ahora sí podemos acceder al número más alto de la lista de argumentos. De todos modos podemos mejorar este código gracias al spread operator.
Veamos cómo hacerlo!
let numeros = [4, 16, 25, 2, 45, 8]; let numeroMayor = Math.max(...numeros); console.log(numeroMayor); // 45
Al anteponer los tres puntos que representan al spread operator transformamos la variable numeros (que en el ejemplo representa un array con números) en una lista de argumentos, y es por ello que podemos acceder al número mayor del array numeros. Es como si le quitáramos los corchetes ( “[]” ) al array.
let numeros = [10, 4, 7, 15, 3, 25]; console.log(numeros); // Imprime un array. console.log(...numeros); // Imprime una lista de argumentos.
Os dejo 2 videos excelentes sobre el concepto de programacion funcional y el uso de estas funciones :)
Sacha Lifsyc https://www.youtube.com/watch?v=tP8JiVUiyDo&t=634s
Hector de Leon , Intro a la programacion funcional
Para agregar un nuevo atributo sin mutar, también se puede hacer de esta otra forma. Es exactamente lo mismo pero a mi parecer un poco mas limpio
const rta3 = orders.map(item => ({ ...item, tax: 0.19 }))
Envolvemos los corchetes entre parentesis
item => ({
Utilizando
return { ...item, tax: 0.19, };
Podemos crear una copia del objeto original y modificar esa copia, agregando ese nuevo elemento, sin modificar al array original de objetos.
Tener en cuenta todos los parametros que puede usar la funcion map que pueden ser utiles para algun caso: 1. currentItem 2. currentIndex 3. originalArray
const objA = [{quantity:20, price:1}, {quantity:2, price:4}]; const objE = objA.map( (currentItem, currentIndex, originalArray) => { return { …currentItem, index: currentIndex, total: currentItem.quantity * currentItem.price }; });