JavaScript

JavaScript

Tutorial JavaScript: Transformación con map()

JavaScript map: uso y ejemplos. Aprende a usar el objeto Map en JavaScript con ejemplos prácticos y detallados.

Aprende JavaScript y certifícate

Fundamentos de map(): Transformación declarativa de colecciones elemento por elemento

El método map() es una de las herramientas fundamentales en la programación funcional de JavaScript que permite transformar cada elemento de un array en algo nuevo, devolviendo un nuevo array con los resultados. A diferencia de los enfoques imperativos tradicionales que utilizan bucles, map() ofrece una forma declarativa de expresar transformaciones de datos.

Concepto básico

En esencia, map() aplica una función transformadora a cada elemento de un array, creando un nuevo array con los valores resultantes. La característica más importante es que no modifica el array original, respetando así el principio de inmutabilidad tan valorado en la programación funcional.

La sintaxis básica es:

const nuevoArray = array.original.map(funcionTransformadora);

Donde funcionTransformadora recibe tres parámetros (aunque normalmente solo se usa el primero):

array.map((elemento, indice, arrayCompleto) => {
  // Transformación del elemento
  return nuevoResultado;
});

Transformaciones simples

El caso de uso más común es aplicar una operación matemática o transformación a cada elemento:

const numeros = [1, 2, 3, 4, 5];
const duplicados = numeros.map(numero => numero * 2);
// resultado: [2, 4, 6, 8, 10]

También podemos transformar tipos de datos:

const numeros = [1, 2, 3, 4, 5];
const comoTextos = numeros.map(numero => numero.toString());
// resultado: ["1", "2", "3", "4", "5"]

Transformación de objetos

Una aplicación poderosa de map() es extraer o transformar propiedades específicas de una colección de objetos:

const usuarios = [
  { id: 1, nombre: "Ana", edad: 28 },
  { id: 2, nombre: "Carlos", edad: 34 },
  { id: 3, nombre: "Elena", edad: 25 }
];

const nombres = usuarios.map(usuario => usuario.nombre);
// resultado: ["Ana", "Carlos", "Elena"]

También podemos crear nuevos objetos con propiedades modificadas:

const usuariosFormateados = usuarios.map(usuario => ({
  id: usuario.id,
  nombre: usuario.nombre.toUpperCase(),
  adulto: usuario.edad >= 18
}));

Uso del índice

El segundo parámetro de la función de transformación nos da acceso al índice del elemento, lo que resulta útil en ciertos escenarios:

const letras = ["a", "b", "c"];
const conPosicion = letras.map((letra, indice) => 
  `Letra ${indice + 1}: ${letra}`
);
// resultado: ["Letra 1: a", "Letra 2: b", "Letra 3: c"]

Transformaciones condicionales

Podemos combinar map() con operadores condicionales para aplicar diferentes transformaciones según el valor:

const numeros = [1, 2, 3, 4, 5];
const parImpar = numeros.map(n => 
  n % 2 === 0 ? "par" : "impar"
);
// resultado: ["impar", "par", "impar", "par", "impar"]

Manejo de valores nulos o indefinidos

Es importante considerar cómo manejar valores potencialmente nulos o indefinidos:

const datos = [1, null, 3, undefined, 5];
const procesados = datos.map(item => 
  item !== null && item !== undefined ? item * 2 : 0
);
// resultado: [2, 0, 6, 0, 10]

Encadenamiento con otros métodos

Una de las ventajas principales de map() es que se puede encadenar con otros métodos de array para crear transformaciones complejas de manera legible:

const numeros = [1, 2, 3, 4, 5, 6];
const sumaPares = numeros
  .filter(n => n % 2 === 0)    // Filtramos solo pares
  .map(n => n * n)             // Elevamos al cuadrado
  .reduce((sum, n) => sum + n, 0); // Sumamos todos
// resultado: 56 (4 + 16 + 36)

Implementación propia de map()

Para entender mejor cómo funciona map() internamente, podemos implementar nuestra propia versión simplificada:

function miMap(array, callback) {
  const resultado = [];
  for (let i = 0; i < array.length; i++) {
    resultado.push(callback(array[i], i, array));
  }
  return resultado;
}

// Uso:
const duplicados = miMap([1, 2, 3], x => x * 2);
// resultado: [2, 4, 6]

Esta implementación muestra claramente que map() es simplemente una abstracción sobre un bucle tradicional que acumula resultados en un nuevo array.

Consideraciones de rendimiento

Aunque map() es muy expresivo, hay que tener en cuenta algunas consideraciones:

  • El array resultante siempre tiene la misma longitud que el original
  • Se crea un nuevo array en memoria (a diferencia de métodos como forEach)
  • Para operaciones muy simples en arrays muy grandes, un bucle tradicional podría ser más eficiente

Sin embargo, en la mayoría de los casos, la claridad y expresividad que aporta map() compensa cualquier pequeña diferencia de rendimiento.

Implementación avanzada y optimización: Patrones y estrategias para transformaciones eficientes

Cuando dominamos los fundamentos de map(), podemos avanzar hacia técnicas más sofisticadas que mejoran tanto la legibilidad como el rendimiento de nuestras transformaciones. Esta sección explora patrones avanzados y estrategias de optimización que elevan el uso de map() a un nivel profesional.

Composición de funciones

Una técnica poderosa en programación funcional es la composición de funciones, que nos permite combinar múltiples transformaciones en una sola función reutilizable:

// Funciones de transformación individuales
const double = x => x * 2;
const addOne = x => x + 1;
const square = x => x * x;

// Función de composición
const compose = (...fns) => x => fns.reduceRight((val, fn) => fn(val), x);

// Crear transformación compuesta
const transform = compose(square, addOne, double);

// Aplicar en map()
const numbers = [1, 2, 3, 4];
const result = numbers.map(transform);
// resultado: [9, 25, 49, 81]

Esta técnica mejora la modularidad y facilita la creación de transformaciones complejas a partir de funciones simples.

Memoización para transformaciones costosas

Cuando las transformaciones son computacionalmente intensivas y se repiten para valores idénticos, la memoización puede mejorar significativamente el rendimiento:

function memoize(fn) {
  const cache = new Map();
  return function(arg) {
    if (cache.has(arg)) {
      return cache.get(arg);
    }
    const result = fn(arg);
    cache.set(arg, result);
    return result;
  };
}

// Transformación costosa (ejemplo: cálculo de Fibonacci)
const fibonacci = memoize(n => {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
});

const sequence = [5, 8, 5, 12, 8];
const fibResults = sequence.map(fibonacci);
// Calcula fibonacci(5) y fibonacci(8) solo una vez

Procesamiento por lotes con chunking

Para arrays extremadamente grandes, podemos implementar un procesamiento por lotes para evitar bloquear el hilo principal:

async function mapInChunks(array, callback, chunkSize = 1000) {
  const results = [];
  
  for (let i = 0; i < array.length; i += chunkSize) {
    const chunk = array.slice(i, i + chunkSize);
    
    // Procesar este lote y esperar al siguiente ciclo del event loop
    await new Promise(resolve => setTimeout(resolve, 0));
    
    const processedChunk = chunk.map(callback);
    results.push(...processedChunk);
  }
  
  return results;
}

// Uso con un array grande
const hugeArray = Array.from({ length: 100000 }, (_, i) => i);
mapInChunks(hugeArray, x => x * x).then(result => {
  console.log("Procesamiento completado");
});

Transformaciones parciales con currying

El currying permite crear transformadores parcialmente aplicados, lo que facilita la creación de funciones de transformación especializadas:

// Función currificada para formatear propiedades
const formatProperty = property => formatter => object => ({
  ...object,
  [property]: formatter(object[property])
});

// Formateadores específicos
const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1);
const formatDate = timestamp => new Date(timestamp).toLocaleDateString();

// Crear transformadores específicos
const formatName = formatProperty('name')(capitalize);
const formatCreatedAt = formatProperty('createdAt')(formatDate);

// Aplicar transformaciones en cadena
const users = [
  { id: 1, name: 'john', createdAt: 1617293982000 },
  { id: 2, name: 'mary', createdAt: 1617293982000 }
];

const formattedUsers = users
  .map(formatName)
  .map(formatCreatedAt);
// resultado: [
//   { id: 1, name: 'John', createdAt: '1/4/2021' },
//   { id: 2, name: 'Mary', createdAt: '1/4/2021' }
// ]

Optimización con TypedArrays

Para operaciones numéricas intensivas, las TypedArrays pueden ofrecer mejor rendimiento que los arrays normales:

// Crear un array tipado
const floatArray = new Float64Array(1000000);

// Llenar con valores
for (let i = 0; i < floatArray.length; i++) {
  floatArray[i] = Math.random();
}

// Transformar usando map (creando un nuevo TypedArray)
const transformed = Float64Array.from(floatArray, x => x * Math.PI);

Transformaciones paralelas con Web Workers

Para cálculos realmente intensivos, podemos distribuir el trabajo entre múltiples hilos usando Web Workers:

// En el script principal
function mapWithWorkers(array, processingFn, numWorkers = navigator.hardwareConcurrency) {
  return new Promise(resolve => {
    const chunkSize = Math.ceil(array.length / numWorkers);
    const results = new Array(array.length);
    let completedWorkers = 0;
    
    for (let i = 0; i < numWorkers; i++) {
      const start = i * chunkSize;
      const end = Math.min(start + chunkSize, array.length);
      
      const worker = new Worker('map-worker.js');
      
      worker.postMessage({
        array: array.slice(start, end),
        processingFn: processingFn.toString(),
        startIndex: start
      });
      
      worker.onmessage = e => {
        // Copiar resultados a la posición correcta
        const { processedChunk, startIndex } = e.data;
        for (let j = 0; j < processedChunk.length; j++) {
          results[startIndex + j] = processedChunk[j];
        }
        
        worker.terminate();
        completedWorkers++;
        
        if (completedWorkers === numWorkers) {
          resolve(results);
        }
      };
    }
  });
}

// En map-worker.js
self.onmessage = function(e) {
  const { array, processingFn, startIndex } = e.data;
  const fn = eval('(' + processingFn + ')');
  const processedChunk = array.map(fn);
  
  self.postMessage({ processedChunk, startIndex });
};

Optimización de transformaciones encadenadas

Cuando encadenamos múltiples operaciones map(), podemos optimizar combinándolas en una sola pasada:

// Enfoque ineficiente: crea arrays intermedios
const resultado1 = datos
  .map(x => x * 2)
  .map(x => x + 1)
  .map(x => x.toString());

// Enfoque optimizado: una sola pasada
const resultado2 = datos.map(x => {
  const paso1 = x * 2;
  const paso2 = paso1 + 1;
  return paso2.toString();
});

Transformaciones condicionales avanzadas

Podemos implementar transformaciones selectivas que solo modifican ciertos elementos:

const transformarSelectivamente = (array, condicion, transformacion) => {
  return array.map(item => 
    condicion(item) ? transformacion(item) : item
  );
};

// Ejemplo: duplicar solo números pares
const numeros = [1, 2, 3, 4, 5, 6];
const resultado = transformarSelectivamente(
  numeros,
  n => n % 2 === 0,
  n => n * 2
);
// resultado: [1, 4, 3, 8, 5, 12]

Manejo eficiente de estructuras anidadas

Para transformar estructuras de datos complejas, podemos crear funciones especializadas:

// Transformar arrays anidados a cualquier profundidad
function deepMap(array, callback, depth = Infinity, level = 0) {
  return array.map(item => {
    if (Array.isArray(item) && level < depth) {
      return deepMap(item, callback, depth, level + 1);
    }
    return callback(item);
  });
}

// Ejemplo: elevar al cuadrado todos los números en una estructura anidada
const datos = [1, [2, 3], [[4], 5]];
const resultado = deepMap(datos, x => x * x);
// resultado: [1, [4, 9], [[16], 25]]

Transducers para operaciones compuestas

Los transducers son una técnica avanzada que permite componer transformaciones de manera eficiente:

// Implementación básica de transducers
const map = fn => reducer => (acc, value) => 
  reducer(acc, fn(value));

const filter = predicate => reducer => (acc, value) => 
  predicate(value) ? reducer(acc, value) : acc;

// Función para aplicar transducers
const transduce = (transducer, reducer, initial, array) => {
  const xReducer = transducer(reducer);
  return array.reduce(xReducer, initial);
};

// Ejemplo: filtrar números pares y duplicarlos
const numeros = [1, 2, 3, 4, 5, 6];
const xform = compose(
  filter(x => x % 2 === 0),
  map(x => x * 2)
);

const resultado = transduce(
  xform,
  (acc, x) => [...acc, x],
  [],
  numeros
);
// resultado: [4, 8, 12]

Estas técnicas avanzadas permiten llevar el uso de map() más allá de las transformaciones básicas, creando código más eficiente, modular y mantenible. La clave está en seleccionar la estrategia adecuada según las características específicas del problema y los requisitos de rendimiento.

Integración con el ecosistema funcional: Combinación de map() con otros métodos de alto orden

El método map() alcanza su máximo potencial cuando se integra con otros métodos funcionales de JavaScript. Esta sinergia permite crear flujos de procesamiento de datos elegantes y expresivos que resuelven problemas complejos con código conciso y declarativo.

Combinación con filter()

Una de las combinaciones más comunes y potentes es usar map() junto con filter(). Mientras que filter() selecciona elementos, map() los transforma:

const transactions = [
  { id: 1, amount: 100, type: "deposit" },
  { id: 2, amount: 50, type: "withdrawal" },
  { id: 3, amount: 200, type: "deposit" },
  { id: 4, amount: 25, type: "withdrawal" }
];

const formattedDeposits = transactions
  .filter(tx => tx.type === "deposit")
  .map(tx => `Transaction #${tx.id}: $${tx.amount}`);
// resultado: ["Transaction #1: $100", "Transaction #3: $200"]

Esta combinación permite primero filtrar los datos relevantes y luego transformarlos al formato deseado.

Encadenamiento con reduce()

La combinación de map() con reduce() es extremadamente versátil para transformar datos y luego agregarlos:

const products = [
  { name: "Laptop", price: 1200, stock: 4 },
  { name: "Phone", price: 800, stock: 6 },
  { name: "Tablet", price: 500, stock: 2 }
];

const totalInventoryValue = products
  .map(product => product.price * product.stock)
  .reduce((total, value) => total + value, 0);
// resultado: 9600

También podemos usar reduce() para transformaciones más complejas que map() por sí solo no podría manejar:

const groupByCategory = items => {
  return items.reduce((groups, item) => {
    const category = item.category;
    if (!groups[category]) {
      groups[category] = [];
    }
    groups[category].push(item.name);
    return groups;
  }, {});
};

const inventory = [
  { name: "Laptop", category: "Electronics", price: 1200 },
  { name: "Shirt", category: "Clothing", price: 25 },
  { name: "Headphones", category: "Electronics", price: 80 }
];

const categorized = groupByCategory(inventory);
// resultado: { Electronics: ["Laptop", "Headphones"], Clothing: ["Shirt"] }

Integración con flatMap()

El método flatMap() combina map() y flat() en una sola operación, lo que resulta ideal para transformaciones que generan arrays anidados:

const sentences = ["Hello world", "JavaScript is fun"];

const words = sentences.flatMap(sentence => sentence.split(" "));
// resultado: ["Hello", "world", "JavaScript", "is", "fun"]

Este enfoque es más eficiente que encadenar map() y flat() por separado, ya que evita la creación de un array intermedio.

Combinación con sort()

Podemos usar map() para transformar datos antes de ordenarlos con sort():

const people = [
  { firstName: "John", lastName: "Doe", age: 28 },
  { firstName: "Jane", lastName: "Smith", age: 32 },
  { firstName: "Tom", lastName: "Wilson", age: 24 }
];

// Extraer nombres completos y ordenarlos alfabéticamente
const sortedNames = people
  .map(person => `${person.firstName} ${person.lastName}`)
  .sort();
// resultado: ["Jane Smith", "John Doe", "Tom Wilson"]

También podemos usar map() después de sort() para formatear los resultados ordenados:

const sortedByAge = [...people]
  .sort((a, b) => a.age - b.age)
  .map(person => `${person.firstName} (${person.age})`);
// resultado: ["Tom (24)", "John (28)", "Jane (32)"]

Integración con every() y some()

Los métodos every() y some() se pueden combinar con map() para verificaciones complejas:

const users = [
  { id: 1, name: "Alice", permissions: ["read", "write"] },
  { id: 2, name: "Bob", permissions: ["read"] },
  { id: 3, name: "Charlie", permissions: ["read", "write", "admin"] }
];

// Verificar si todos los usuarios tienen permiso de lectura
const allCanRead = users
  .map(user => user.permissions)
  .every(perms => perms.includes("read"));
// resultado: true

// Verificar si algún usuario tiene permiso de administrador
const hasAdmin = users
  .map(user => user.permissions)
  .some(perms => perms.includes("admin"));
// resultado: true

Patrones de pipeline funcional

Podemos crear pipelines funcionales que encadenan múltiples operaciones para transformar datos de manera progresiva:

const pipeline = (...fns) => initialValue => 
  fns.reduce((value, fn) => fn(value), initialValue);

// Funciones individuales para el pipeline
const getActiveUsers = users => users.filter(user => user.active);
const extractEmails = users => users.map(user => user.email);
const formatForDisplay = emails => emails.map(email => `<${email}>`);

// Crear y ejecutar el pipeline
const processUsers = pipeline(
  getActiveUsers,
  extractEmails,
  formatForDisplay
);

const users = [
  { id: 1, email: "alice@example.com", active: true },
  { id: 2, email: "bob@example.com", active: false },
  { id: 3, email: "charlie@example.com", active: true }
];

const result = processUsers(users);
// resultado: ["<alice@example.com>", "<charlie@example.com>"]

Integración con métodos de iteración asíncrona

Podemos combinar map() con Promise.all() para operaciones asíncronas paralelas:

const fetchUserData = async (userIds) => {
  const promises = userIds.map(id => 
    fetch(`https://api.example.com/users/${id}`)
      .then(response => response.json())
  );
  
  return Promise.all(promises);
};

// Uso
fetchUserData([1, 2, 3])
  .then(users => {
    const usernames = users.map(user => user.username);
    console.log(usernames);
  });

Para operaciones asíncronas secuenciales, podemos usar reduce() con async/await:

const processSequentially = async (items) => {
  const results = await items.reduce(async (promiseAcc, item) => {
    // Esperar los resultados acumulados hasta ahora
    const acc = await promiseAcc;
    
    // Procesar el elemento actual (simulando una operación asíncrona)
    const result = await someAsyncOperation(item);
    
    // Añadir al acumulador
    return [...acc, result];
  }, Promise.resolve([]));
  
  return results;
};

Integración con bibliotecas funcionales

Las bibliotecas funcionales como Ramda o Lodash/FP amplían las capacidades de map() y otros métodos funcionales:

// Usando Ramda para transformaciones más avanzadas
import * as R from 'ramda';

const users = [
  { name: "Alice", age: 25, roles: ["user"] },
  { name: "Bob", age: 32, roles: ["user", "admin"] }
];

// Transformación con lentes para modificar propiedades anidadas
const uppercaseNames = R.map(
  R.over(R.lensProp('name'), R.toUpper)
);

// Transformación condicional basada en una propiedad
const addSeniorLabel = R.map(user => 
  user.age > 30 
    ? R.assoc('label', 'senior', user) 
    : user
);

// Componer transformaciones
const processUsers = R.pipe(
  uppercaseNames,
  addSeniorLabel,
  R.sortBy(R.prop('age'))
);

const result = processUsers(users);

Patrones de diseño funcional con map()

El método map() es fundamental en varios patrones de diseño funcional:

  • Patrón Functor: Un contenedor que implementa map() para transformar su contenido:
class Maybe {
  constructor(value) {
    this._value = value;
  }
  
  static of(value) {
    return new Maybe(value);
  }
  
  map(fn) {
    if (this._value === null || this._value === undefined) {
      return Maybe.of(null);
    }
    return Maybe.of(fn(this._value));
  }
  
  getOrElse(defaultValue) {
    return this._value !== null && this._value !== undefined
      ? this._value
      : defaultValue;
  }
}

// Uso seguro con valores potencialmente nulos
const user = { name: "Alice" };
const city = Maybe.of(user.address)
  .map(address => address.city)
  .getOrElse("Unknown");
// Si user.address es undefined, devuelve "Unknown"
  • Patrón Monada: Extiende el concepto de functor para manejar operaciones encadenadas:
class TaskMonad {
  constructor(executor) {
    this.executor = executor;
  }
  
  static of(value) {
    return new TaskMonad(resolve => resolve(value));
  }
  
  map(fn) {
    return new TaskMonad(resolve => {
      this.executor(value => resolve(fn(value)));
    });
  }
  
  flatMap(fn) {
    return new TaskMonad(resolve => {
      this.executor(value => {
        fn(value).executor(resolve);
      });
    });
  }
  
  run(callback) {
    this.executor(callback);
  }
}

// Uso para operaciones asíncronas encadenadas
const fetchUser = id => new TaskMonad(resolve => {
  setTimeout(() => resolve({ id, name: "User " + id }), 100);
});

TaskMonad.of(5)
  .map(id => id + 1)
  .flatMap(fetchUser)
  .map(user => user.name.toUpperCase())
  .run(console.log); // Imprime "USER 6" después de 100ms

La integración de map() con otros métodos funcionales crea un ecosistema coherente para el procesamiento de datos, permitiendo escribir código más declarativo, mantenible y expresivo. Dominar estas combinaciones es esencial para aprovechar al máximo el paradigma de programación funcional en JavaScript.

Aprende JavaScript online

Otros ejercicios de programación de JavaScript

Evalúa tus conocimientos de esta lección Transformación con map() con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.

Clases y objetos

JavaScript
Código

Uso de operadores

JavaScript
Puzzle

Uso de operadores

JavaScript
Test

Estructuras de control

JavaScript
Test

Proyecto Manipulación DOM

JavaScript
Proyecto

Excepciones

JavaScript
Test

Transformación con map()

JavaScript
Código

Arrays y Métodos

JavaScript
Código

Reto Métodos de Strings

JavaScript
Código

Transformación con map()

JavaScript
Puzzle

Funciones flecha

JavaScript
Test

Async / Await

JavaScript
Código

Selección de elementos DOM

JavaScript
Puzzle

API Fetch

JavaScript
Código

Encapsulación

JavaScript
Test

Mapas con Map

JavaScript
Código

Creación y uso de variables

JavaScript
Puzzle

Polimorfismo

JavaScript
Puzzle

Reto Funciones flecha

JavaScript
Código

Tipos de datos

JavaScript
Puzzle

Reto Operadores avanzados

JavaScript
Código

Promises

JavaScript
Código

Reto Estructuras de control

JavaScript
Código

Estructuras de control

JavaScript
Puzzle

Pruebas unitarias

JavaScript
Proyecto

Inmutabilidad y programación funcional pura

JavaScript
Código

Funciones flecha

JavaScript
Puzzle

Polimorfismo

JavaScript
Test

Reto Polimorfismo

JavaScript
Código

Array

JavaScript
Código

Transformación con map()

JavaScript
Test

Reto Variables

JavaScript
Código

Gestor de tareas con JavaScript

JavaScript
Proyecto

Proyecto Modificación de elementos DOM

JavaScript
Proyecto

Manipulación DOM

JavaScript
Test

Funciones

JavaScript
Test

Conjuntos con Set

JavaScript
Código

Reto Prototipos y cadena de prototipos

JavaScript
Código

Reto Encapsulación

JavaScript
Código

Funciones flecha

JavaScript
Código

Async / Await

JavaScript
Código

Reto Excepciones

JavaScript
Código

Reto Filtrado con filter() y find()

JavaScript
Código

Creación y uso de variables

JavaScript
Test

Excepciones

JavaScript
Puzzle

Promises

JavaScript
Código

Funciones cierre (closure)

JavaScript
Test

Reto Herencia

JavaScript
Código

Herencia

JavaScript
Puzzle

Proyecto Eventos del DOM

JavaScript
Proyecto

Herencia

JavaScript
Test

Selección de elementos DOM

JavaScript
Test

Modificación de elementos DOM

JavaScript
Test

Reto Clases y objetos

JavaScript
Código

Filtrado con filter() y find()

JavaScript
Test

Funciones cierre (closure)

JavaScript
Puzzle

Reto Destructuring de objetos y arrays

JavaScript
Código

Callbacks

JavaScript
Código

Funciones

JavaScript
Puzzle

Mapas con Map

JavaScript
Test

Reducción con reduce()

JavaScript
Test

Callbacks

JavaScript
Puzzle

Manipulación DOM

JavaScript
Puzzle

Introducción al DOM

JavaScript
Proyecto

Reto Funciones

JavaScript
Código

Reto Funciones cierre (closure)

JavaScript
Código

Promises

JavaScript
Test

Reto Reducción con reduce()

JavaScript
Código

Async / Await

JavaScript
Test

Reto Estructuras de control

JavaScript
Código

Eventos del DOM

JavaScript
Puzzle

Introducción a JavaScript

JavaScript
Puzzle

Async / Await

JavaScript
Puzzle

Promises

JavaScript
Puzzle

Selección de elementos DOM

JavaScript
Proyecto

Filtrado con filter() y find()

JavaScript
Código

Callbacks

JavaScript
Test

Creación de clases y objetos Restaurante

JavaScript
Código

Reducción con reduce()

JavaScript
Código

Filtrado con filter() y find()

JavaScript
Puzzle

Reducción con reduce()

JavaScript
Puzzle

Conjuntos con Set

JavaScript
Puzzle

Herencia de clases

JavaScript
Código

Eventos del DOM

JavaScript
Test

Clases y objetos

JavaScript
Puzzle

Modificación de elementos DOM

JavaScript
Puzzle

Mapas con Map

JavaScript
Puzzle

Proyecto carrito compra agoodshop

JavaScript
Proyecto

Introducción a JavaScript

JavaScript
Test

Reto Mapas con Map

JavaScript
Código

Funciones

JavaScript
Código

Proyecto administrador de contactos

JavaScript
Proyecto

Reto Expresiones regulares

JavaScript
Código

Tipos de datos

JavaScript
Test

Clases y objetos

JavaScript
Test

Array

JavaScript
Test

Conjuntos con Set

JavaScript
Test

Array

JavaScript
Puzzle

Encapsulación

JavaScript
Puzzle

Todas las lecciones de JavaScript

Accede a todas las lecciones de JavaScript y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.

Introducción A Javascript

JavaScript

Introducción Y Entorno

Tipos De Datos

JavaScript

Sintaxis

Variables

JavaScript

Sintaxis

Operadores

JavaScript

Sintaxis

Estructuras De Control

JavaScript

Sintaxis

Funciones

JavaScript

Sintaxis

Funciones Cierre (Closure)

JavaScript

Sintaxis

Métodos De Strings

JavaScript

Sintaxis

Funciones Cierre (Closure)

JavaScript

Sintaxis

Operadores Avanzados

JavaScript

Sintaxis

Funciones

JavaScript

Sintaxis

Expresiones Regulares

JavaScript

Sintaxis

Estructuras De Control

JavaScript

Sintaxis

Arrays Y Métodos

JavaScript

Estructuras De Datos

Conjuntos Con Set

JavaScript

Estructuras De Datos

Mapas Con Map

JavaScript

Estructuras De Datos

Conjuntos Con Set

JavaScript

Estructuras De Datos

Funciones Flecha

JavaScript

Programación Funcional

Filtrado Con Filter() Y Find()

JavaScript

Programación Funcional

Transformación Con Map()

JavaScript

Programación Funcional

Reducción Con Reduce()

JavaScript

Programación Funcional

Funciones Flecha

JavaScript

Programación Funcional

Transformación Con Map()

JavaScript

Programación Funcional

Inmutabilidad Y Programación Funcional Pura

JavaScript

Programación Funcional

Clases Y Objetos

JavaScript

Programación Orientada A Objetos

Excepciones

JavaScript

Programación Orientada A Objetos

Encapsulación

JavaScript

Programación Orientada A Objetos

Herencia

JavaScript

Programación Orientada A Objetos

Polimorfismo

JavaScript

Programación Orientada A Objetos

This Y Contexto

JavaScript

Programación Orientada A Objetos

Patrón De Módulos Y Namespace

JavaScript

Programación Orientada A Objetos

Prototipos Y Cadena De Prototipos

JavaScript

Programación Orientada A Objetos

Destructuring De Objetos Y Arrays

JavaScript

Programación Orientada A Objetos

Manipulación Dom

JavaScript

Dom

Selección De Elementos Dom

JavaScript

Dom

Modificación De Elementos Dom

JavaScript

Dom

Eventos Del Dom

JavaScript

Dom

Localstorage Y Sessionstorage

JavaScript

Dom

Bom (Browser Object Model)

JavaScript

Dom

Callbacks

JavaScript

Programación Asíncrona

Promises

JavaScript

Programación Asíncrona

Async / Await

JavaScript

Programación Asíncrona

Promises

JavaScript

Programación Asíncrona

Api Fetch

JavaScript

Programación Asíncrona

Async / Await

JavaScript

Programación Asíncrona

Naturaleza De Js Y Event Loop

JavaScript

Programación Asíncrona

Callbacks

JavaScript

Programación Asíncrona

Websockets

JavaScript

Programación Asíncrona

Módulos En Es6

JavaScript

Construcción

Configuración De Bundlers Como Vite

JavaScript

Construcción

Eslint Y Calidad De Código

JavaScript

Construcción

Npm Y Dependencias

JavaScript

Construcción

Introducción A Pruebas En Js

JavaScript

Testing

Pruebas Unitarias

JavaScript

Testing

Accede GRATIS a JavaScript y certifícate

En esta lección

Objetivos de aprendizaje de esta lección

  1. Entender el propósito y uso de la función map() en JavaScript.
  2. Conocer la sintaxis general de map() y cómo se aplica a un array.
  3. Aprender a definir funciones de llamada (callbacks) para map() que operen sobre los elementos del array.
  4. Familiarizarse con el uso de funciones flecha en la función map() para hacer el código más conciso.
  5. Saber cómo utilizar map() para modificar los elementos de un array o extraer datos específicos para generar un nuevo array.
  6. Comprender cómo map() puede ser utilizado en diferentes escenarios, como con arrays de números o arrays de objetos, para realizar diferentes tareas.