const notas = [
{id: 1, title: 'Nota 1', content: 'Contenido de la nota 1'},
{id: 2, title: 'Nota 2', content: 'Contenido de la nota 2'},
{id: 3, title: 'Nota 3', content: 'Contenido de la nota 3'}
]
Cuando trabajas con datos reales en JavaScript, casi siempre vas a encontrar arreglos que contienen objetos. Y para manipular esa combinación de forma limpia, los métodos de orden superior como map y filter se vuelven tus mejores aliados: te permiten transformar y seleccionar información sin escribir bucles complicados.
¿Qué son los métodos de orden superior en JavaScript?
Son funciones que reciben otra función como argumento. La idea es que puedas trabajar con arreglos de forma declarativa, expresando qué quieres hacer en lugar de cómo hacerlo paso a paso.
¿Qué hace un método de orden superior? Recibe una función como parámetro y la aplica a cada elemento de un arreglo, devolviendo un resultado sin modificar el original.
Esto suena abstracto al principio, pero cuando lo ves en código todo encaja. La estructura más común que vas a manipular es un array con varios objetos dentro, donde cada objeto representa un ítem con propiedades como id, title o content.
¿Cómo usar map para transformar un arreglo?
El método map recorre cada elemento del arreglo, aplica la transformación que tú definas y te entrega un arreglo nuevo. Nunca toca el original.
Imagina que tienes un arreglo notas con varios objetos y solo quieres extraer los títulos:
javascript const titulos = notas.map((nota) => nota.title); console.log(titulos);
Aquí le pasas a map una arrow function que recibe cada nota y devuelve únicamente su propiedad title. El resultado es un arreglo limpio con nota uno, nota dos, nota tres.
¿Cómo agregar una nueva propiedad con map?
Si además quieres añadir información a cada objeto, puedes combinar map con el spread operator y devolver un objeto nuevo:
javascript const notasConFecha = notas.map((nota) => ({ ...nota, fechaCreacion: Date.now() })); console.log(notasConFecha);
El ...nota copia todas las propiedades originales y luego sumas fechaCreacion con el timestamp generado por Date.now(). Obtienes un arreglo nuevo, enriquecido, sin alterar notas.
¿Cómo usar filter para seleccionar elementos por condición?
Mientras map transforma, filter selecciona. Te devuelve un arreglo nuevo solo con los elementos que cumplan la condición que definas dentro de la función.
Si a tus objetos les agregas la propiedad esFavorita con valores true o false, puedes extraer solo las favoritas así:
javascript const favoritas = notas2.filter((nota) => nota.esFavorita); console.log(favoritas);
La función dentro de filter debe retornar un valor booleano. Si es true, ese elemento entra al nuevo arreglo. Si es false, se descarta.
¿Cuál es la diferencia entre map y filter?
maptransforma cada elemento y devuelve un arreglo del mismo tamaño.filterevalúa una condición y devuelve solo los elementos que la cumplen.
¿Cómo combinar filter con métodos de strings?
Aquí es donde se conecta todo lo que ya sabes: variables, funciones, manipulación de strings. Supón que quieres buscar una nota por su título sin que las mayúsculas o minúsculas afecten el resultado:
javascript const titulo = notas2.filter((nota) => nota.title.toLowerCase().includes("nota uno") ); console.log(titulo);
Lo que sucede paso a paso:
nota.title dentro de cada objeto.toLowerCase() para normalizar el texto a minúsculas.includes("nota uno") para verificar si el título contiene esa cadena.filter devuelve solo los elementos que cumplen esa condición.Esta es una buena práctica al construir buscadores: normalizar el texto antes de comparar evita resultados inconsistentes por capitalización.
¿Por qué nombrar bien el parámetro de la función importa?
Dentro de map o filter puedes nombrar al parámetro como quieras: n, item, elemento. Pero si tu arreglo se llama notas, llamar nota a cada elemento hace tu código autoexplicativo.
¿Qué nombre debo darle al parámetro en map o filter? Usa el singular del arreglo que estás recorriendo. Si tienes
productos, usaproducto. Esto facilita la lectura y el mantenimiento del código.
La lógica se vuelve clara: "por cada nota dentro de notas, haz esto". El código se lee casi como una frase.
¿Qué ganas al pensar de forma declarativa?
Cuando dominas map y filter, dejas de escribir bucles for con variables auxiliares y empiezas a expresar intenciones. En lugar de explicar cómo recorrer el arreglo, declaras qué resultado quieres.
Esto te da tres ventajas concretas:
filter().map() para filtrar y luego transformar en una sola línea.Ahora te toca a ti. Practica creando tus propios arreglos de objetos, aplica map para transformar propiedades y filter para seleccionar por condiciones. Comparte tus soluciones en los comentarios y muestra cómo resolviste los retos.
Cuando trabajas con datos reales en JavaScript, casi siempre vas a encontrar arreglos que contienen objetos. Y para manipular esa combinación de forma limpia, los métodos de orden superior como map y filter se vuelven tus mejores aliados: te permiten transformar y seleccionar información sin escribir bucles complicados.
Son funciones que reciben otra función como argumento. La idea es que puedas trabajar con arreglos de forma declarativa, expresando qué quieres hacer en lugar de cómo hacerlo paso a paso.
¿Qué hace un método de orden superior? Recibe una función como parámetro y la aplica a cada elemento de un arreglo, devolviendo un resultado sin modificar el original.
Esto suena abstracto al principio, pero cuando lo ves en código todo encaja. La estructura más común que vas a manipular es un array con varios objetos dentro, donde cada objeto representa un ítem con propiedades como id, title o content.
El método map recorre cada elemento del arreglo, aplica la transformación que tú definas y te entrega un arreglo nuevo. Nunca toca el original.
Imagina que tienes un arreglo notas con varios objetos y solo quieres extraer los títulos:
javascript const titulos = notas.map((nota) => nota.title); console.log(titulos);
Aquí le pasas a map una arrow function que recibe cada nota y devuelve únicamente su propiedad title. El resultado es un arreglo limpio con nota uno, nota dos, nota tres.
Si además quieres añadir información a cada objeto, puedes combinar map con el spread operator y devolver un objeto nuevo:
javascript const notasConFecha = notas.map((nota) => ({ ...nota, fechaCreacion: Date.now() })); console.log(notasConFecha);
El ...nota copia todas las propiedades originales y luego sumas fechaCreacion con el timestamp generado por Date.now(). Obtienes un arreglo nuevo, enriquecido, sin alterar notas.
Mientras map transforma, filter selecciona. Te devuelve un arreglo nuevo solo con los elementos que cumplan la condición que definas dentro de la función.
Si a tus objetos les agregas la propiedad esFavorita con valores true o false, puedes extraer solo las favoritas así:
javascript const favoritas = notas2.filter((nota) => nota.esFavorita); console.log(favoritas);
La función dentro de filter debe retornar un valor booleano. Si es true, ese elemento entra al nuevo arreglo. Si es false, se descarta.
¿Cuál es la diferencia entre map y filter?
maptransforma cada elemento y devuelve un arreglo del mismo tamaño.filterevalúa una condición y devuelve solo los elementos que la cumplen.
Aquí es donde se conecta todo lo que ya sabes: variables, funciones, manipulación de strings. Supón que quieres buscar una nota por su título sin que las mayúsculas o minúsculas afecten el resultado:
javascript const titulo = notas2.filter((nota) => nota.title.toLowerCase().includes("nota uno") ); console.log(titulo);
Lo que sucede paso a paso:
nota.title dentro de cada objeto.toLowerCase() para normalizar el texto a minúsculas.includes("nota uno") para verificar si el título contiene esa cadena.filter devuelve solo los elementos que cumplen esa condición.Esta es una buena práctica al construir buscadores: normalizar el texto antes de comparar evita resultados inconsistentes por capitalización.
Dentro de map o filter puedes nombrar al parámetro como quieras: n, item, elemento. Pero si tu arreglo se llama notas, llamar nota a cada elemento hace tu código autoexplicativo.
¿Qué nombre debo darle al parámetro en map o filter? Usa el singular del arreglo que estás recorriendo. Si tienes
productos, usaproducto. Esto facilita la lectura y el mantenimiento del código.
La lógica se vuelve clara: "por cada nota dentro de notas, haz esto". El código se lee casi como una frase.
Cuando dominas map y filter, dejas de escribir bucles for con variables auxiliares y empiezas a expresar intenciones. En lugar de explicar cómo recorrer el arreglo, declaras qué resultado quieres.
Esto te da tres ventajas concretas:
filter().map() para filtrar y luego transformar en una sola línea.Ahora te toca a ti. Practica creando tus propios arreglos de objetos, aplica map para transformar propiedades y filter para seleccionar por condiciones. Comparte tus soluciones en los comentarios y muestra cómo resolviste los retos.
const notas = [
{id: 1, title: 'Nota 1', content: 'Contenido de la nota 1'},
{id: 2, title: 'Nota 2', content: 'Contenido de la nota 2'},
{id: 3, title: 'Nota 3', content: 'Contenido de la nota 3'}
]
Aquí encontraran los retos de la clase:
/**
* Clase 19: Map y Filter - Manipula arreglos de objetos
*
* Los métodos de orden superior como map y filter permiten trabajar con
* arreglos de forma declarativa, sin mutar el array original.
*
* Conceptos clave:
* - map(): Transforma cada elemento y retorna un nuevo array
* - filter(): Selecciona elementos que cumplan una condición
* - Spread operator (...): Copia propiedades de objetos
* - Arrow functions: Sintaxis concisa para callbacks
*/
/**
* Ejercicio 1: Extraer títulos con map
*
* Dado un array de objetos con notas, usa map para extraer
* solo el título de cada nota.
*
* @param {Array} notas - Array de objetos con propiedad title
* @returns {Array} - Array con solo los títulos
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota uno', content: 'Contenido 1' },
* { id: 2, title: 'Nota dos', content: 'Contenido 2' }
* ];
* extraerTitulos(notas) // ['Nota uno', 'Nota dos']
*/
function extraerTitulos(notas) {
const titulos = notas.map(nota => nota.title);
return titulos;
};
/**
* Ejercicio 2: Agregar fecha de creación con map
*
* Usa map y spread operator para crear nuevos objetos que incluyan
* una propiedad fechaCreacion con el timestamp actual (Date.now()).
*
* @param {Array} notas - Array de objetos de notas
* @returns {Array} - Nuevo array con objetos que incluyen fechaCreacion
*
* Ejemplo:
* const notas = [{ id: 1, title: 'Nota' }];
* agregarFechaCreacion(notas)
* // [{ id: 1, title: 'Nota', fechaCreacion: 1700000000000 }]
*/
function agregarFechaCreacion(notas) {
const notasConFechaDeCreacion = notas.map(nota => ({
...nota,
fechaCreacion: Date.now()
}));
return notasConFechaDeCreacion;
}
/**
* Ejercicio 3: Filtrar notas favoritas
*
* Usa filter para obtener solo las notas que tengan
* la propiedad esFavorita igual a true.
*
* @param {Array} notas - Array de objetos con propiedad esFavorita
* @returns {Array} - Array con solo las notas favoritas
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Fav', esFavorita: true },
* { id: 2, title: 'Normal', esFavorita: false }
* ];
* filtrarFavoritas(notas) // [{ id: 1, title: 'Fav', esFavorita: true }]
*/
function filtrarFavoritas(notas) {
const favoritas = notas.filter(nota => nota.esFavorita);
return favoritas;
}
/**
* Ejercicio 4: Buscar notas por título (case insensitive)
*
* Usa filter, toLowerCase e includes para buscar notas cuyo
* título contenga el término de búsqueda, sin importar mayúsculas/minúsculas.
*
* @param {Array} notas - Array de objetos con propiedad title
* @param {string} busqueda - Término a buscar
* @returns {Array} - Array con notas que coinciden con la búsqueda
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota Importante' },
* { id: 2, title: 'Otra cosa' }
* ];
* buscarPorTitulo(notas, 'importante') // [{ id: 1, title: 'Nota Importante' }]
*/
function buscarPorTitulo(notas, busqueda) {
const importantes = notas.filter(nota => nota.title.toLowerCase().includes(busqueda.toLowerCase()));
return importantes;
}
/**
* Ejercicio 5: Transformar precios con descuento
*
* Usa map para aplicar un descuento a todos los productos.
* Cada producto debe mantener sus propiedades originales y
* agregar una propiedad precioFinal con el descuento aplicado.
*
* @param {Array} productos - Array de objetos con precio
* @param {number} porcentajeDescuento - Porcentaje de descuento (ej: 10 para 10%)
* @returns {Array} - Nuevo array con precioFinal calculado
*
* Ejemplo:
* const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
* aplicarDescuento(productos, 20)
* // [{ id: 1, nombre: 'Camisa', precio: 100, precioFinal: 80 }]
*/
function aplicarDescuento(productos, porcentajeDescuento) {
const productoConDescuento = productos.map(producto => ({
...producto,
precioFinal: producto.precio * ( 1 - porcentajeDescuento / 100)
}));
return productoConDescuento;
}
/**
* Ejercicio 6: Filtrar productos por rango de precio
*
* Usa filter para obtener productos cuyo precio esté dentro
* de un rango específico (inclusive).
*
* @param {Array} productos - Array de objetos con propiedad precio
* @param {number} min - Precio mínimo
* @param {number} max - Precio máximo
* @returns {Array} - Array con productos dentro del rango
*
* Ejemplo:
* const productos = [
* { nombre: 'A', precio: 50 },
* { nombre: 'B', precio: 150 },
* { nombre: 'C', precio: 250 }
* ];
* filtrarPorRango(productos, 100, 200) // [{ nombre: 'B', precio: 150 }]
*/
function filtrarPorRango(productos, min, max) {
const precioConFiltro = productos.filter(producto => producto.precio >= min && producto.precio <= max)
return precioConFiltro;
};
// Exportar todas las funciones para los tests
module.exports = {
extraerTitulos,
agregarFechaCreacion,
filtrarFavoritas,
buscarPorTitulo,
aplicarDescuento,
filtrarPorRango,
};
En el ejemplo de notaConFecha, en la función flecha que se le paso a map, se agrego un () en vez de solo un {} para crear el objeto.
Los paréntesis () se usan para indicar que la función flecha está retornando implícitamente un objeto.
Cuando se usa map y se quiere que cada elemento transformado sea un objeto, si se usa llaves {} directamente después de la flecha, JavaScript las interpreta como el cuerpo de la función, no como un objeto a retornar. Para que sepa que está creando un objeto, se necesita envolverlo en paréntesis ().
Por ejemplo:
const crearUsuario = (nombre, edad) => ({
nombre: nombre,
edad: edad
});
Comparto mi código para estos ejercicios
/**
* Clase 19: Map y Filter - Manipula arreglos de objetos
*
* Los métodos de orden superior como map y filter permiten trabajar con
* arreglos de forma declarativa, sin mutar el array original.
*
* Conceptos clave:
* - map(): Transforma cada elemento y retorna un nuevo array
* - filter(): Selecciona elementos que cumplan una condición
* - Spread operator (...): Copia propiedades de objetos
* - Arrow functions: Sintaxis concisa para callbacks
*/
/**
* Ejercicio 1: Extraer títulos con map
*
* Dado un array de objetos con notas, usa map para extraer
* solo el título de cada nota.
*
* @param {Array} notas - Array de objetos con propiedad title
* @returns {Array} - Array con solo los títulos
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota uno', content: 'Contenido 1' },
* { id: 2, title: 'Nota dos', content: 'Contenido 2' }
* ];
* extraerTitulos(notas) // ['Nota uno', 'Nota dos']
*/
function extraerTitulos(notas) {
// Tu código aquí
return notas.map((nota)=>nota.title);
}
const notas = [
{ id: 1, title: 'Nota uno', content: 'Contenido 1' },
{ id: 2, title: 'Nota dos', content: 'Contenido 2' }
];
console.log(extraerTitulos(notas));
/**
* Ejercicio 2: Agregar fecha de creación con map
*
* Usa map y spread operator para crear nuevos objetos que incluyan
* una propiedad fechaCreacion con el timestamp actual (Date.now()).
*
* @param {Array} notas - Array de objetos de notas
* @returns {Array} - Nuevo array con objetos que incluyen fechaCreacion
*
* Ejemplo:
* const notas = [{ id: 1, title: 'Nota' }];
* agregarFechaCreacion(notas)
* // [{ id: 1, title: 'Nota', fechaCreacion: 1700000000000 }]
*/
function agregarFechaCreacion(notas) {
// Tu código aquí
return notas.map((nota)=>({
...nota,
CreatedDate: Date.now()
}));
}
const notas2 = [
{ id: 1, title: 'Nota uno', content: 'Contenido 1' },
{ id: 2, title: 'Nota dos', content: 'Contenido 2' }
];
console.log(agregarFechaCreacion(notas2));
/**
* Ejercicio 3: Filtrar notas favoritas
*
* Usa filter para obtener solo las notas que tengan
* la propiedad esFavorita igual a true.
*
* @param {Array} notas - Array de objetos con propiedad esFavorita
* @returns {Array} - Array con solo las notas favoritas
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Fav', esFavorita: true },
* { id: 2, title: 'Normal', esFavorita: false }
* ];
* filtrarFavoritas(notas) // [{ id: 1, title: 'Fav', esFavorita: true }]
*/
function filtrarFavoritas(notas) {
// Tu código aquí
return notas.filter((nota)=>nota.esFavorita);
}
const notas3 = [
{ id: 1, title: 'Fav', esFavorita: true },
{ id: 2, title: 'Normal', esFavorita: false }
];
console.log(filtrarFavoritas(notas3));
/**
* Ejercicio 4: Buscar notas por título (case insensitive)
*
* Usa filter, toLowerCase e includes para buscar notas cuyo
* título contenga el término de búsqueda, sin importar mayúsculas/minúsculas.
*
* @param {Array} notas - Array de objetos con propiedad title
* @param {string} busqueda - Término a buscar
* @returns {Array} - Array con notas que coinciden con la búsqueda
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota Importante' },
* { id: 2, title: 'Otra cosa' }
* ];
* buscarPorTitulo(notas, 'importante') // [{ id: 1, title: 'Nota Importante' }]
*/
function buscarPorTitulo(notas, busqueda) {
// Tu código aquí
return notas.filter((nota)=>nota.title.toLowerCase().includes(busqueda));
}
const notas4 = [
{ id: 1, title: 'Nota Importante' },
{ id: 2, title: 'Otra cosa' }
];
console.log(buscarPorTitulo(notas4,'importante'));
/**
* Ejercicio 5: Transformar precios con descuento
*
* Usa map para aplicar un descuento a todos los productos.
* Cada producto debe mantener sus propiedades originales y
* agregar una propiedad precioFinal con el descuento aplicado.
*
* @param {Array} productos - Array de objetos con precio
* @param {number} porcentajeDescuento - Porcentaje de descuento (ej: 10 para 10%)
* @returns {Array} - Nuevo array con precioFinal calculado
*
* Ejemplo:
* const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
* aplicarDescuento(productos, 20)
* // [{ id: 1, nombre: 'Camisa', precio: 100, precioFinal: 80 }]
*/
function aplicarDescuento(productos, porcentajeDescuento) {
// Tu código aquí
return productos.map((producto)=>{
const descuento=producto.precio*porcentajeDescuento/100;
return{
...producto,
descuento,
precioFinal: producto.precio-descuento
}});
}
const productos = [{ id: 1, nombre: 'Camisa', precio: 100 },{ id: 2, nombre: 'pantalón', precio: 300 }];
console.log(aplicarDescuento(productos,20));
/**
* Ejercicio 6: Filtrar productos por rango de precio
*
* Usa filter para obtener productos cuyo precio esté dentro
* de un rango específico (inclusive).
*
* @param {Array} productos - Array de objetos con propiedad precio
* @param {number} min - Precio mínimo
* @param {number} max - Precio máximo
* @returns {Array} - Array con productos dentro del rango
*
* Ejemplo:
* const productos = [
* { nombre: 'A', precio: 50 },
* { nombre: 'B', precio: 150 },
* { nombre: 'C', precio: 250 }
* ];
* filtrarPorRango(productos, 100, 200) // [{ nombre: 'B', precio: 150 }]
*/
function filtrarPorRango(productos, min, max) {
// Tu código aquí
return productos.filter((producto)=>{
return producto.precio>=min && producto.precio<=max
});
}
const productos2 = [
{ nombre: 'A', precio: 50 },
{ nombre: 'B', precio: 150 },
{ nombre: 'C', precio: 250 }
];
console.log(filtrarPorRango(productos2,40,200));
// Exportar todas las funciones para los tests
module.exports = {
extraerTitulos,
agregarFechaCreacion,
filtrarFavoritas,
buscarPorTitulo,
aplicarDescuento,
filtrarPorRango,
};
Done!
function extraerTitulos(notas) {
return notas.map((nota) => nota.title);
}
/**
* Ejercicio 2: Agregar fecha de creación con map
*
* Usa map y spread operator para crear nuevos objetos que incluyan
* una propiedad fechaCreacion con el timestamp actual (Date.now()).
*
* @param {Array} notas - Array de objetos de notas
* @returns {Array} - Nuevo array con objetos que incluyen fechaCreacion
*
* Ejemplo:
* const notas = [{ id: 1, title: 'Nota' }];
* agregarFechaCreacion(notas)
* // [{ id: 1, title: 'Nota', fechaCreacion: 1700000000000 }]
*/
function agregarFechaCreacion(notas) {
return notas.map((nota) => ({ ...nota, fechaCreacion: Date.now() }));
}
/**
* Ejercicio 3: Filtrar notas favoritas
*
* Usa filter para obtener solo las notas que tengan
* la propiedad esFavorita igual a true.
*
* @param {Array} notas - Array de objetos con propiedad esFavorita
* @returns {Array} - Array con solo las notas favoritas
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Fav', esFavorita: true },
* { id: 2, title: 'Normal', esFavorita: false }
* ];
* filtrarFavoritas(notas) // [{ id: 1, title: 'Fav', esFavorita: true }]
*/
function filtrarFavoritas(notas) {
return notas.filter((nota) => nota.esFavorita);
}
/**
* Ejercicio 4: Buscar notas por título (case insensitive)
*
* Usa filter, toLowerCase e includes para buscar notas cuyo
* título contenga el término de búsqueda, sin importar mayúsculas/minúsculas.
*
* @param {Array} notas - Array de objetos con propiedad title
* @param {string} busqueda - Término a buscar
* @returns {Array} - Array con notas que coinciden con la búsqueda
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota Importante' },
* { id: 2, title: 'Otra cosa' }
* ];
* buscarPorTitulo(notas, 'importante') // [{ id: 1, title: 'Nota Importante' }]
*/
function buscarPorTitulo(notas, busqueda) {
return notas.filter((nota) =>
nota.title.toLowerCase().includes(busqueda.toLowerCase()),
);
}
/**
* Ejercicio 5: Transformar precios con descuento
*
* Usa map para aplicar un descuento a todos los productos.
* Cada producto debe mantener sus propiedades originales y
* agregar una propiedad precioFinal con el descuento aplicado.
*
* @param {Array} productos - Array de objetos con precio
* @param {number} porcentajeDescuento - Porcentaje de descuento (ej: 10 para 10%)
* @returns {Array} - Nuevo array con precioFinal calculado
*
* Ejemplo:
* const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
* aplicarDescuento(productos, 20)
* // [{ id: 1, nombre: 'Camisa', precio: 100, precioFinal: 80 }]
*/
function aplicarDescuento(productos, porcentajeDescuento) {
return productos.map((producto) => ({
...producto,
precioFinal:
producto.precio - (producto.precio * porcentajeDescuento) / 100,
}));
}
/**
* Ejercicio 6: Filtrar productos por rango de precio
*
* Usa filter para obtener productos cuyo precio esté dentro
* de un rango específico (inclusive).
*
* @param {Array} productos - Array de objetos con propiedad precio
* @param {number} min - Precio mínimo
* @param {number} max - Precio máximo
* @returns {Array} - Array con productos dentro del rango
*
* Ejemplo:
* const productos = [
* { nombre: 'A', precio: 50 },
* { nombre: 'B', precio: 150 },
* { nombre: 'C', precio: 250 }
* ];
* filtrarPorRango(productos, 100, 200) // [{ nombre: 'B', precio: 150 }]
*/
function filtrarPorRango(productos, min, max) {
return productos.filter(
(producto) => producto.precio >= min && producto.precio <= max,
);
}

/**
* Ejercicio 1: Extraer títulos con map
*
* Dado un array de objetos con notas, usa map para extraer
* solo el título de cada nota.
*
* @param {Array} notas - Array de objetos con propiedad title
* @returns {Array} - Array con solo los títulos
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota uno', content: 'Contenido 1' },
* { id: 2, title: 'Nota dos', content: 'Contenido 2' }
* ];
* extraerTitulos(notas) // ['Nota uno', 'Nota dos']
*/
function extraerTitulos() {
// Tu código aquí
const notas = [
{ id: 1, title: 'Nota uno', content: 'Contenido 1' },
{ id: 2, title: 'Nota dos', content: 'Contenido 2' }
];
const titulos = notas.map((n) => n ({
}));
return titulos;
}
console.log(extraerTitulos())
/**
* Ejercicio 2: Agregar fecha de creación con map
*
* Usa map y spread operator para crear nuevos objetos que incluyan
* una propiedad fechaCreacion con el timestamp actual (Date.now()).
*
* @param {Array} notas - Array de objetos de notas
* @returns {Array} - Nuevo array con objetos que incluyen fechaCreacion
*
* Ejemplo:
* const notas = [{ id: 1, title: 'Nota' }];
* agregarFechaCreacion(notas)
* // [{ id: 1, title: 'Nota', fechaCreacion: 1700000000000 }]
*/
function agregarFechaCreacion() {
// Tu código aquí
const notas = [{ id: 1, title: 'Nota' }];
const Resultado = notas.map((n) => ({
...n,
fecha: Date.now()
}))
return Resultado;
}
console.log(agregarFechaCreacion())
/**
* Ejercicio 3: Filtrar notas favoritas
*
* Usa filter para obtener solo las notas que tengan
* la propiedad esFavorita igual a true.
*
* @param {Array} notas - Array de objetos con propiedad esFavorita
* @returns {Array} - Array con solo las notas favoritas
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Fav', esFavorita: true },
* { id: 2, title: 'Normal', esFavorita: false }
* ];
* filtrarFavoritas(notas) // [{ id: 1, title: 'Fav', esFavorita: true }]
*/
function filtrarFavoritas() {
// Tu código aquí
const notas = [
{ id: 1, title: 'Fav', esFavorita: true },
{ id: 2, title: 'Normal', esFavorita: false }
];
const esFav = notas.filter((n) => n.esFavorita);
return esFav;
}
console.log(filtrarFavoritas())
/**
* Ejercicio 4: Buscar notas por título (case insensitive)
*
* Usa filter, toLowerCase e includes para buscar notas cuyo
* título contenga el término de búsqueda, sin importar mayúsculas/minúsculas.
*
* @param {Array} notas - Array de objetos con propiedad title
* @param {string} busqueda - Término a buscar
* @returns {Array} - Array con notas que coinciden con la búsqueda
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota Importante' },
* { id: 2, title: 'Otra cosa' }
* ];
* buscarPorTitulo(notas, 'importante') // [{ id: 1, title: 'Nota Importante' }]
*/
function buscarPorTitulo(notas, busqueda) {
// Tu código aquí
const notas = [
{ id: 1, title: 'Nota Importante' },
{ id: 2, title: 'Otra cosa' }
];
const busqueda = notas.filter((n) => n.title.toLocaleLowerCase.includes())
}
/**
* Ejercicio 5: Transformar precios con descuento
*
* Usa map para aplicar un descuento a todos los productos.
* Cada producto debe mantener sus propiedades originales y
* agregar una propiedad precioFinal con el descuento aplicado.
*
* @param {Array} productos - Array de objetos con precio
* @param {number} porcentajeDescuento - Porcentaje de descuento (ej: 10 para 10%)
* @returns {Array} - Nuevo array con precioFinal calculado
* const multiplicar = (a,b) => a * b;
* Ejemplo:
* const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
* aplicarDescuento(productos, 20)
* // [{ id: 1, nombre: 'Camisa', precio: 100, precioFinal: 80 }]
*/
function aplicarDescuento( porcentajeDescuento) {
// Tu código aquí
const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
const descuento = productos.map((p) => ({
...p,
precioFinal : p.precio * (1 - porcentajeDescuento / 100)
}) )
return descuento;
}
console.log(aplicarDescuento(10))
/**
* Ejercicio 6: Filtrar productos por rango de precio
*
* Usa filter para obtener productos cuyo precio esté dentro
* de un rango específico (inclusive).
*
* @param {Array} productos - Array de objetos con propiedad precio
* @param {number} min - Precio mínimo
* @param {number} max - Precio máximo
* @returns {Array} - Array con productos dentro del rango
*
* Ejemplo:
* const productos = [
* { nombre: 'A', precio: 50 },
* { nombre: 'B', precio: 150 },
* { nombre: 'C', precio: 250 }
* ];
* filtrarPorRango(productos, 100, 200) // [{ nombre: 'B', precio: 150 }]
*/
function filtrarPorRango(min, max) {
// Tu código aquí
const productos = [
{ nombre: 'A', precio: 50 },
{ nombre: 'B', precio: 150 },
{ nombre: 'C', precio: 250 }
];
const rangoPrecio = productos.filter(
(p) => p.precio >= min &&
p.precio <= max )
return rangoPrecio;
}
console.log(filtrarPorRango(100,200))
// Exportar todas las funciones para los tests
module.exports = {
extraerTitulos,
agregarFechaCreacion,
filtrarFavoritas,
buscarPorTitulo,
aplicarDescuento,
filtrarPorRango,
};
Mis soluciones al reto:
/**
* Clase 19: Map y Filter - Manipula arreglos de objetos
*
* Los métodos de orden superior como map y filter permiten trabajar con
* arreglos de forma declarativa, sin mutar el array original.
*
* Conceptos clave:
* - map(): Transforma cada elemento y retorna un nuevo array
* - filter(): Selecciona elementos que cumplan una condición
* - Spread operator (...): Copia propiedades de objetos
* - Arrow functions: Sintaxis concisa para callbacks
*/
/**
* Ejercicio 1: Extraer títulos con map
*
* Dado un array de objetos con notas, usa map para extraer
* solo el título de cada nota.
*
* @param {Array} notas - Array de objetos con propiedad title
* @returns {Array} - Array con solo los títulos
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota uno', content: 'Contenido 1' },
* { id: 2, title: 'Nota dos', content: 'Contenido 2' }
* ];
* extraerTitulos(notas) // ['Nota uno', 'Nota dos']
*/
function extraerTitulos(notas) {
// Tu código aquí
const titulos = notas.map((nota) => nota.title);
return titulos;
}
const notas = [
{ id: 1, title: 'Nota uno', content: 'Contenido 1' },
{ id: 2, title: 'Nota dos', content: 'Contenido 2' }
];
console.log(extraerTitulos(notas));
/**
* Ejercicio 2: Agregar fecha de creación con map
*
* Usa map y spread operator para crear nuevos objetos que incluyan
* una propiedad fechaCreacion con el timestamp actual (Date.now()).
*
* @param {Array} notas - Array de objetos de notas
* @returns {Array} - Nuevo array con objetos que incluyen fechaCreacion
*
* Ejemplo:
* const notas = [{ id: 1, title: 'Nota' }];
* agregarFechaCreacion(notas)
* // [{ id: 1, title: 'Nota', fechaCreacion: 1700000000000 }]
*/
function agregarFechaCreacion(notas) {
// Tu código aquí
const notasFechadas = notas.map((nota) => ({
...nota,
fechaCreacion: Date.now()
}));
return notasFechadas;
}
const notas0 = [
{ id: 1, title: 'Nota uno', content: 'Contenido 1' },
{ id: 2, title: 'Nota dos', content: 'Contenido 2' }
];
console.log(agregarFechaCreacion(notas0));
/**
* Ejercicio 3: Filtrar notas favoritas
*
* Usa filter para obtener solo las notas que tengan
* la propiedad esFavorita igual a true.
*
* @param {Array} notas - Array de objetos con propiedad esFavorita
* @returns {Array} - Array con solo las notas favoritas
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Fav', esFavorita: true },
* { id: 2, title: 'Normal', esFavorita: false }
* ];
* filtrarFavoritas(notas) // [{ id: 1, title: 'Fav', esFavorita: true }]
*/
function filtrarFavoritas(notas) {
// Tu código aquí
const favoritas = notas.filter((nota) => nota.esFavorita);
return favoritas;
}
const notas1 = [
{ id: 1, title: 'Fav', esFavorita: true },
{ id: 2, title: 'Normal', esFavorita: false }
];
console.log(filtrarFavoritas(notas1));
/**
* Ejercicio 4: Buscar notas por título (case insensitive)
*
* Usa filter, toLowerCase e includes para buscar notas cuyo
* título contenga el término de búsqueda, sin importar mayúsculas/minúsculas.
*
* @param {Array} notas - Array de objetos con propiedad title
* @param {string} busqueda - Término a buscar
* @returns {Array} - Array con notas que coinciden con la búsqueda
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota Importante' },
* { id: 2, title: 'Otra cosa' }
* ];
* buscarPorTitulo(notas, 'importante') // [{ id: 1, title: 'Nota Importante' }]
*/
function buscarPorTitulo(notas, busqueda) {
// Tu código aquí
const importantes = notas.filter((nota) => nota.title.toLowerCase().includes(busqueda));
return importantes;
}
const notas2 = [{ id: 1, title: 'Nota Importante' },
{ id: 2, title: 'Otra cosa' },
{ id: 3, title: 'Otra Importante' },
{ id: 4, title: 'Más Importante' },
{ id: 5, title: 'Una nota más' },
{ id: 5, title: 'Otra nota más' }];
console.log(buscarPorTitulo(notas2, 'importante'));
/**
* Ejercicio 5: Transformar precios con descuento
*
* Usa map para aplicar un descuento a todos los productos.
* Cada producto debe mantener sus propiedades originales y
* agregar una propiedad precioFinal con el descuento aplicado.
*
* @param {Array} productos - Array de objetos con precio
* @param {number} porcentajeDescuento - Porcentaje de descuento (ej: 10 para 10%)
* @returns {Array} - Nuevo array con precioFinal calculado
*
* Ejemplo:
* const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
* aplicarDescuento(productos, 20)
* // [{ id: 1, nombre: 'Camisa', precio: 100, precioFinal: 80 }]
*/
function aplicarDescuento(productos, porcentajeDescuento) {
// Tu código aquí
const productosDescontados = productos.map((producto) => ({
...producto,
precioFinal: (producto.precio - (producto.precio * (porcentajeDescuento/100)))
}))
return productosDescontados;
}
const productos1 = [{ id: 1, nombre: 'Camisa', precio: 100 },
{ id: 2, nombre: 'pantalón', precio: 200 },
{ id: 3, nombre: 'sombrero', precio: 50 },
{ id: 4, nombre: 'bufanda', precio: 30 },
{ id: 5, nombre: 'zapatos', precio: 350 }
];
console.log(aplicarDescuento(productos1, 30));
/**
* Ejercicio 6: Filtrar productos por rango de precio
*
* Usa filter para obtener productos cuyo precio esté dentro
* de un rango específico (inclusive).
*
* @param {Array} productos - Array de objetos con propiedad precio
* @param {number} min - Precio mínimo
* @param {number} max - Precio máximo
* @returns {Array} - Array con productos dentro del rango
*
* Ejemplo:
* const productos = [
* { nombre: 'A', precio: 50 },
* { nombre: 'B', precio: 150 },
* { nombre: 'C', precio: 250 }
* ];
* filtrarPorRango(productos, 100, 200) // [{ nombre: 'B', precio: 150 }]
*/
function filtrarPorRango(productos, min, max) {
// Tu código aquí
const enrango = productos.filter((producto) => (producto.precio >= min && producto.precio <= max))
return enrango;
}
const productos = [{ nombre: 'A', precio: 50 },
{ nombre: 'B', precio: 150 },
{ nombre: 'C', precio: 250 }];
console.log(filtrarPorRango(productos, 150, 250));
// Exportar todas las funciones para los tests
module.exports = {
extraerTitulos,
agregarFechaCreacion,
filtrarFavoritas,
buscarPorTitulo,
aplicarDescuento,
filtrarPorRango,
};
/**
* Clase 19: Map y Filter - Manipula arreglos de objetos
*
* Los métodos de orden superior como map y filter permiten trabajar con
* arreglos de forma declarativa, sin mutar el array original.
*
* Conceptos clave:
* - map(): Transforma cada elemento y retorna un nuevo array
* - filter(): Selecciona elementos que cumplan una condición
* - Spread operator (...): Copia propiedades de objetos
* - Arrow functions: Sintaxis concisa para callbacks
*/
/**
* Ejercicio 1: Extraer títulos con map
*
* Dado un array de objetos con notas, usa map para extraer
* solo el título de cada nota.
*
* @param {Array} notas - Array de objetos con propiedad title
* @returns {Array} - Array con solo los títulos
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota uno', content: 'Contenido 1' },
* { id: 2, title: 'Nota dos', content: 'Contenido 2' }
* ];
* extraerTitulos(notas) // ['Nota uno', 'Nota dos']
*/
function extraerTitulos(notas) {
const titulos = notas.map((nota) => nota.title);
return titulos;
}
/**
* Ejercicio 2: Agregar fecha de creación con map
*
* Usa map y spread operator para crear nuevos objetos que incluyan
* una propiedad fechaCreacion con el timestamp actual (Date.now()).
*
* @param {Array} notas - Array de objetos de notas
* @returns {Array} - Nuevo array con objetos que incluyen fechaCreacion
*
* Ejemplo:
* const notas = [{ id: 1, title: 'Nota' }];
* agregarFechaCreacion(notas)
* // [{ id: 1, title: 'Nota', fechaCreacion: 1700000000000 }]
*/
function agregarFechaCreacion(notas) {
const notasConFecha = notas.map((nota) => ({
...nota,
fechaCreacion: Date.now(),
}));
return notasConFecha;
}
/**
* Ejercicio 3: Filtrar notas favoritas
*
* Usa filter para obtener solo las notas que tengan
* la propiedad esFavorita igual a true.
*
* @param {Array} notas - Array de objetos con propiedad esFavorita
* @returns {Array} - Array con solo las notas favoritas
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Fav', esFavorita: true },
* { id: 2, title: 'Normal', esFavorita: false }
* ];
* filtrarFavoritas(notas) // [{ id: 1, title: 'Fav', esFavorita: true }]
*/
function filtrarFavoritas(notas) {
const favoritas = notas.filter((nota) => nota.esFavorita);
return favoritas;
}
/**
* Ejercicio 4: Buscar notas por título (case insensitive)
*
* Usa filter, toLowerCase e includes para buscar notas cuyo
* título contenga el término de búsqueda, sin importar mayúsculas/minúsculas.
*
* @param {Array} notas - Array de objetos con propiedad title
* @param {string} busqueda - Término a buscar
* @returns {Array} - Array con notas que coinciden con la búsqueda
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota Importante' },
* { id: 2, title: 'Otra cosa' }
* ];
* buscarPorTitulo(notas, 'importante') // [{ id: 1, title: 'Nota Importante' }]
*/
function buscarPorTitulo(notas, busqueda) {
const resultado = notas.filter((nota) =>
nota.title.toLowerCase().includes(busqueda.toLowerCase()),
);
return resultado;
}
/**
* Ejercicio 5: Transformar precios con descuento
*
* Usa map para aplicar un descuento a todos los productos.
* Cada producto debe mantener sus propiedades originales y
* agregar una propiedad precioFinal con el descuento aplicado.
*
* @param {Array} productos - Array de objetos con precio
* @param {number} porcentajeDescuento - Porcentaje de descuento (ej: 10 para 10%)
* @returns {Array} - Nuevo array con precioFinal calculado
*
* Ejemplo:
* const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
* aplicarDescuento(productos, 20)
* // [{ id: 1, nombre: 'Camisa', precio: 100, precioFinal: 80 }]
*/
function aplicarDescuento(productos, porcentajeDescuento) {
const productosConDescuento = productos.map((producto) => ({
...producto,
precioFinal: producto.precio * (1 - porcentajeDescuento / 100),
}));
return productosConDescuento;
}
/**
* Ejercicio 6: Filtrar productos por rango de precio
*
* Usa filter para obtener productos cuyo precio esté dentro
* de un rango específico (inclusive).
*
* @param {Array} productos - Array de objetos con propiedad precio
* @param {number} min - Precio mínimo
* @param {number} max - Precio máximo
* @returns {Array} - Array con productos dentro del rango
*
* Ejemplo:
* const productos = [
* { nombre: 'A', precio: 50 },
* { nombre: 'B', precio: 150 },
* { nombre: 'C', precio: 250 }
* ];
* filtrarPorRango(productos, 100, 200) // [{ nombre: 'B', precio: 150 }]
*/
function filtrarPorRango(productos, min, max) {
const productosEnRango = productos.filter((producto) => producto.precio >= min && producto.precio <= max);
return productosEnRango;
}
// Exportar todas las funciones para los tests
export {
extraerTitulos,
agregarFechaCreacion,
filtrarFavoritas,
buscarPorTitulo,
aplicarDescuento,
filtrarPorRango,
};
Mi solución:
// Map y Filter: Manipula arreglos de objetos
// Reto de la clase 19 del Curso de Fundamentos de JavaScript.
// Conceptos clave
// Métodos de orden superior: Funciones que reciben otra función como argumento
// map(): Transforma cada elemento, retorna nuevo array sin mutar original
// filter(): Selecciona elementos que cumplan condición, retorna nuevo array
// Spread operator (...): Copia propiedades de objetos
// Arrow functions: Sintaxis concisa para callbacks
// toLowerCase() + includes(): Búsquedas insensibles a mayúsculas/minúsculas
/**
* Clase 19: Map y Filter - Manipula arreglos de objetos
*
* Los métodos de orden superior como map y filter permiten trabajar con
* arreglos de forma declarativa, sin mutar el array original.
*
* Conceptos clave:
* - map(): Transforma cada elemento y retorna un nuevo array
* - filter(): Selecciona elementos que cumplan una condición
* - Spread operator (...): Copia propiedades de objetos
* - Arrow functions: Sintaxis concisa para callbacks
*/
/**
* Ejercicio 1: Extraer títulos con map
*
* Dado un array de objetos con notas, usa map para extraer
* solo el título de cada nota.
*
* @param {Array} notas - Array de objetos con propiedad title
* @returns {Array} - Array con solo los títulos
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota uno', content: 'Contenido 1' },
* { id: 2, title: 'Nota dos', content: 'Contenido 2' }
* ];
* extraerTitulos(notas) // ['Nota uno', 'Nota dos']
*/
function extraerTitulos(notas) {
// Tu código aquí
return notas.map((nota) => nota.title);
}
const notas = [
{ id: 1, title: 'Nota uno', content: 'Contenido 1' },
{ id: 2, title: 'Nota dos', content: 'Contenido 2' }
];
console.log(extraerTitulos(notas))
/**
* Ejercicio 2: Agregar fecha de creación con map
*
* Usa map y spread operator para crear nuevos objetos que incluyan
* una propiedad fechaCreacion con el timestamp actual (Date.now()).
*
* @param {Array} notas - Array de objetos de notas
* @returns {Array} - Nuevo array con objetos que incluyen fechaCreacion
*
* Ejemplo:
* const notas = [{ id: 1, title: 'Nota' }];
* agregarFechaCreacion(notas)
* // [{ id: 1, title: 'Nota', fechaCreacion: 1700000000000 }]
*/
function agregarFechaCreacion(notas) {
// Tu código aquí
return notas.map((nota)=> ({
...nota,
fechaCreacion: Date.now()
}))
}
/**
* Ejercicio 3: Filtrar notas favoritas
*
* Usa filter para obtener solo las notas que tengan
* la propiedad esFavorita igual a true.
*
* @param {Array} notas - Array de objetos con propiedad esFavorita
* @returns {Array} - Array con solo las notas favoritas
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Fav', esFavorita: true },
* { id: 2, title: 'Normal', esFavorita: false }
* ];
* filtrarFavoritas(notas) // [{ id: 1, title: 'Fav', esFavorita: true }]
*/
function filtrarFavoritas(notas) {
// Tu código aquí
return notas.filter((nota) => nota.esFavorita);
}
/**
* Ejercicio 4: Buscar notas por título (case insensitive)
*
* Usa filter, toLowerCase e includes para buscar notas cuyo
* título contenga el término de búsqueda, sin importar mayúsculas/minúsculas.
*
* @param {Array} notas - Array de objetos con propiedad title
* @param {string} busqueda - Término a buscar
* @returns {Array} - Array con notas que coinciden con la búsqueda
*
* Ejemplo:
* const notas = [
* { id: 1, title: 'Nota Importante' },
* { id: 2, title: 'Otra cosa' }
* ];
* buscarPorTitulo(notas, 'importante') // [{ id: 1, title: 'Nota Importante' }]
*/
function buscarPorTitulo(notas, busqueda) {
// Tu código aquí
return notas.filter((nota) => nota.title.toLowerCase().includes(busqueda.toLowerCase()))
}
// const notas = [
// { id: 1, title: 'IMPORTANTE' },
// { id: 2, title: 'Otra cosa' }
// ];
// console.log(buscarPorTitulo(notas, 'IMPORTANTE'))
/**
* Ejercicio 5: Transformar precios con descuento
*
* Usa map para aplicar un descuento a todos los productos.
* Cada producto debe mantener sus propiedades originales y
* agregar una propiedad precioFinal con el descuento aplicado.
*
* @param {Array} productos - Array de objetos con precio
* @param {number} porcentajeDescuento - Porcentaje de descuento (ej: 10 para 10%)
* @returns {Array} - Nuevo array con precioFinal calculado
*
* Ejemplo:
* const productos = [{ id: 1, nombre: 'Camisa', precio: 100 }];
* aplicarDescuento(productos, 20)
* // [{ id: 1, nombre: 'Camisa', precio: 100, precioFinal: 80 }]
*/
function aplicarDescuento(productos, porcentajeDescuento) {
// Tu código aquí
return productos.map((producto) => ({
...producto,
precioFinal: producto.precio - (producto.precio * porcentajeDescuento / 100)
}))
}
/**
* Ejercicio 6: Filtrar productos por rango de precio
*
* Usa filter para obtener productos cuyo precio esté dentro
* de un rango específico (inclusive).
*
* @param {Array} productos - Array de objetos con propiedad precio
* @param {number} min - Precio mínimo
* @param {number} max - Precio máximo
* @returns {Array} - Array con productos dentro del rango
*
* Ejemplo:
* const productos = [
* { nombre: 'A', precio: 50 },
* { nombre: 'B', precio: 150 },
* { nombre: 'C', precio: 250 }
* ];
* filtrarPorRango(productos, 100, 200) // [{ nombre: 'B', precio: 150 }]
*/
function filtrarPorRango(productos, min, max) {
// Tu código aquí
return productos.filter((producto) => producto.precio >= min && producto.precio <= max)
}
const productos = [
{ nombre: 'A', precio: 50 },
{ nombre: 'B', precio: 150 },
{ nombre: 'C', precio: 250 }
];
console.log(filtrarPorRango(productos, 100, 200))
// Exportar todas las funciones para los tests
module.exports = {
extraerTitulos,
agregarFechaCreacion,
filtrarFavoritas,
buscarPorTitulo,
aplicarDescuento,
filtrarPorRango,
};
Todos los test pasaron en verde 💚:

tenías un error y no sé cómo JS lo dejó pasar... En la linea de {id:3,...}, pusiste una coma (,) al final como si fueras a continuar con {id:4,...}
Regularmente la sintaxis no debe de permitir esto porque la coma es signo de que se continúa con otro dato.
Verifiquen el la linea 8 a ver si estoy loc* jeje