Transformación
map()
Crea un nuevo array aplicando una función a cada elemento del array original.
Parámetros: callback(elemento, índice, array)
const números = [1, 2, 3, 4];
const duplicados = números.map(x => x * 2);
console.log(duplicados);
// Ejemplo más complejo
const productos = [
{ nombre: 'Laptop', precio: 1000 },
{ nombre: 'Mouse', precio: 20 }
];
const precios = productos.map(producto => ({
...producto,
precioConIVA: producto.precio * 1.21
}));
// Resultado: [2, 4, 6, 8]
Filtrado
filter()
Crea un nuevo array con los elementos que cumplen una condición específica.
Parámetros: callback(elemento, índice, array)
const puntuaciones = [85, 92, 60, 75, 95];
const aprobados = puntuaciones.filter(nota => nota >= 70);
// Ejemplo más complejo
const tareas = [
{ id: 1, completada: true, prioridad: 'alta' },
{ id: 2, completada: false, prioridad: 'alta' },
{ id: 3, completada: true, prioridad: 'baja' }
];
const tareasUrgentes = tareas.filter(
tarea => !tarea.completada && tarea.prioridad === 'alta'
);
// Resultado: [85, 92, 75, 95]
Reducción
reduce()
Reduce un array a un único valor (acumulando de izquierda a derecha).
Parámetros: callback(acumulador, elemento, índice, array), valorInicial
const carrito = [
{ producto: 'Camisa', precio: 25 },
{ producto: 'Pantalón', precio: 50 },
{ producto: 'Zapatos', precio: 80 }
];
const total = carrito.reduce(
(acum, item) => acum + item.precio,
0
);
// Ejemplo más complejo: agrupar por categoría
const productos = [
{ nombre: 'Manzana', categoria: 'Frutas' },
{ nombre: 'Zanahoria', categoria: 'Verduras' },
{ nombre: 'Pera', categoria: 'Frutas' }
];
const porCategoria = productos.reduce((acum, prod) => {
acum[prod.categoria] = acum[prod.categoria] || [];
acum[prod.categoria].push(prod.nombre);
return acum;
}, {});
// Resultado total: 155
// Resultado agrupación: {
// Frutas: ['Manzana', 'Pera'],
// Verduras: ['Zanahoria']
// }
Búsqueda
find()
Devuelve el primer elemento que cumple con la condición especificada.
Parámetros: callback(elemento, índice, array)
const números = [5, 12, 8, 130, 44];
const encontrado = números.find(n => n > 10);
// Ejemplo más complejo
const usuarios = [
{ id: 1, nombre: 'Ana', edad: 25 },
{ id: 2, nombre: 'Juan', edad: 30 },
{ id: 3, nombre: 'María', edad: 20 }
];
const usuario = usuarios.find(u => u.nombre === 'Juan');
// encontrado: 12
// usuario: { id: 2, nombre: 'Juan', edad: 30 }
Búsqueda
findIndex()
Devuelve el índice del primer elemento que cumple con la condición especificada.
Parámetros: callback(elemento, índice, array)
const array = [5, 12, 8, 130, 44];
const índice = array.findIndex(elemento => elemento > 13);
const productos = [
{ nombre: 'Laptop', precio: 1000 },
{ nombre: 'Mouse', precio: 20 },
{ nombre: 'Teclado', precio: 80 }
];
const índiceCaros = productos.findIndex(p => p.precio > 500);
// índice: 3 (elemento 130)
// índiceCaros: 0 (Laptop)
Modificación
splice()
Modifica el array eliminando, reemplazando o agregando elementos en el lugar.
Parámetros: inicio, eliminarCantidad, ...elementosAAgregar
// Eliminar elementos
const frutas = ['manzana', 'banana', 'naranja', 'uva'];
const eliminadas = frutas.splice(1, 2); // Elimina desde índice 1, 2 elementos
console.log('Eliminadas:', eliminadas);
console.log('Array modificado:', frutas);
// Agregar elementos
const colores = ['rojo', 'azul'];
colores.splice(1, 0, 'verde', 'amarillo'); // Agregar en índice 1
// Reemplazar elementos
const números = [1, 2, 3, 4, 5];
números.splice(2, 2, 'nuevo1', 'nuevo2'); // Reemplazar desde índice 2
// Eliminadas: ['banana', 'naranja']
// Array modificado: ['manzana', 'uva']
// colores: ['rojo', 'verde', 'amarillo', 'azul']
// números: [1, 2, 'nuevo1', 'nuevo2', 5]
Verificación
some()
Verifica si al menos un elemento cumple con la condición especificada.
Parámetros: callback(elemento, índice, array)
const edades = [18, 15, 22, 17];
const hayMayorEdad = edades.some(edad => edad >= 18);
const tareas = [
{ nombre: 'Tarea 1', completada: false },
{ nombre: 'Tarea 2', completada: true },
{ nombre: 'Tarea 3', completada: false }
];
const hayCompletada = tareas.some(t => t.completada);
// hayMayorEdad: true
// hayCompletada: true
Verificación
every()
Verifica si todos los elementos cumplen con la condición especificada.
Parámetros: callback(elemento, índice, array)
const números = [2, 4, 6, 8];
const todosPares = números.every(n => n % 2 === 0);
const usuarios = [
{ nombre: 'Ana', activo: true },
{ nombre: 'Juan', activo: true },
{ nombre: 'María', activo: false }
];
const todosActivos = usuarios.every(u => u.activo);
// todosPares: true
// todosActivos: false
Búsqueda
includes()
Verifica si el array contiene un elemento específico.
Parámetros: valorBuscado, índiceInicio (opcional)
const frutas = ['manzana', 'banana', 'naranja'];
const tieneBanana = frutas.includes('banana');
const tieneUva = frutas.includes('uva');
// Con índice de inicio
const números = [1, 2, 3, 2, 1];
const tiene2DespuesDelTercero = números.includes(2, 3);
// tieneBanana: true
// tieneUva: false
// tiene2DespuesDelTercero: true
Búsqueda
indexOf()
Devuelve el primer índice donde se encuentra el elemento especificado.
Parámetros: valorBuscado, índiceInicio (opcional)
const animales = ['gato', 'perro', 'pájaro', 'perro'];
const índicePerro = animales.indexOf('perro');
const índiceNoExiste = animales.indexOf('pez');
// Buscar desde un índice específico
const segundoPerro = animales.indexOf('perro', 2);
// índicePerro: 1
// índiceNoExiste: -1
// segundoPerro: 3
Búsqueda
lastIndexOf()
Devuelve el último índice donde se encuentra el elemento especificado.
Parámetros: valorBuscado, índiceInicio (opcional)
const números = [2, 5, 9, 2];
const últimoÍndice2 = números.lastIndexOf(2);
const últimoÍndice7 = números.lastIndexOf(7);
// Buscar hacia atrás desde un índice específico
const buscarHacia = números.lastIndexOf(2, 2);
// últimoÍndice2: 3
// últimoÍndice7: -1
// buscarHacia: 0
Iteración
forEach()
Ejecuta una función para cada elemento del array.
Parámetros: callback(elemento, índice, array)
const frutas = ['manzana', 'banana', 'naranja'];
// Imprimir cada fruta
frutas.forEach((fruta, índice) => {
console.log(`${índice + 1}: ${fruta}`);
});
// Ejemplo más complejo
const productos = [
{ nombre: 'Laptop', precio: 1000 },
{ nombre: 'Mouse', precio: 20 }
];
productos.forEach(producto => {
producto.precioConDescuento = producto.precio * 0.9;
});
// 1: manzana
// 2: banana
// 3: naranja
Nuevo
at()
Devuelve el elemento en el índice especificado, permitiendo índices negativos.
Parámetros: índice (número)
const frutas = ['manzana', 'banana', 'naranja'];
console.log(frutas.at(-1)); // último elemento
console.log(frutas.at(-2)); // penúltimo elemento
console.log(frutas.at(0)); // primer elemento
// 'naranja'
// 'banana'
// 'manzana'
Búsqueda
findLast()
Devuelve el último elemento que cumple con la condición especificada.
Parámetros: callback(elemento, índice, array)
const números = [1, 3, 5, 6, 8, 9, 11];
const últimoPar = números.findLast(n => n % 2 === 0);
const usuarios = [
{ id: 1, nombre: 'Ana', activo: true },
{ id: 2, nombre: 'Juan', activo: false },
{ id: 3, nombre: 'María', activo: true }
];
const últimoActivo = usuarios.findLast(u => u.activo);
// últimoPar: 8
// últimoActivo: { id: 3, nombre: 'María', activo: true }
Nuevo
toSorted()
Devuelve un nuevo array con los elementos ordenados (versión no mutante de sort()).
Parámetros: compareFn (opcional)
const puntos = [40, 100, 1, 5, 25, 10];
const ordenados = puntos.toSorted((a, b) => a - b);
// El array original permanece sin cambios
console.log(puntos);
console.log(ordenados);
// Ordenar objetos
const personas = [
{ nombre: 'Ana', edad: 25 },
{ nombre: 'Juan', edad: 30 },
{ nombre: 'María', edad: 20 }
];
const porEdad = personas.toSorted((a, b) => a.edad - b.edad);
// puntos: [40, 100, 1, 5, 25, 10]
// ordenados: [1, 5, 10, 25, 40, 100]
Nuevo
toReversed()
Devuelve un nuevo array con los elementos en orden inverso (versión no mutante de reverse()).
Parámetros: Ninguno
const original = ['uno', 'dos', 'tres'];
const invertido = original.toReversed();
// El array original permanece sin cambios
console.log(original);
console.log(invertido);
// original: ['uno', 'dos', 'tres']
// invertido: ['tres', 'dos', 'uno']
Búsqueda
group() [Stage 3]
Agrupa los elementos del array según una función de clasificación.
Parámetros: callback(elemento, índice, array)
const inventario = [
{ nombre: 'manzanas', tipo: 'fruta' },
{ nombre: 'zanahorias', tipo: 'verdura' },
{ nombre: 'plátanos', tipo: 'fruta' }
];
const porTipo = inventario.group(item => item.tipo);
// Ejemplo más complejo
const números = [1, 2, 3, 4, 5, 6];
const porParidad = números.group(num =>
num % 2 === 0 ? 'pares' : 'impares'
);
// porTipo: {
// fruta: [
// { nombre: 'manzanas', tipo: 'fruta' },
// { nombre: 'plátanos', tipo: 'fruta' }
// ],
// verdura: [
// { nombre: 'zanahorias', tipo: 'verdura' }
// ]
// }