Uso de Map para desduplicación

El objeto Map permite eliminar duplicados en arrays, siendo especialmente útil para arrays de objetos mediante el uso de claves únicas.

function desduplicarConMap(datos) {
    const mapa = new Map();
    datos.forEach(elemento => {
        if (!mapa.has(elemento)) {
            mapa.set(elemento, true);
        }
    });
    return Array.from(mapa.keys());
}

const conjunto = [1, 2, 2, 3, 4, 4, 5];
console.log(desduplicarConMap(conjunto)); // Resultado: [1, 2, 3, 4, 5]

Ventajas: Complejidad O(n), eficiente para grandes volúmenes. Desventajas: Puede ser innecesario para datos primitivos simples.

Empleo de Set para una solución concisa

Set es una estructura de datos nativa de JavaScript que descarta duplicados de manera automática.

const extraerUnicos = (arreglo) => Array.from(new Set(arreglo));

const ejemplos = [1, 2, 2, 3, 4, 4, 5];
console.log(extraerUnicos(ejemplos)); // Resultado: [1, 2, 3, 4, 5]

Beneficios: Código breve y óptimo rendimiento. Limitaciones: No maneja directamente objetos complejos sin adaptación.

Aplicación de filter e indexOf

Este método filtra elementos manteniendo solo su primera aparición, verificando el índice con indexOf.

const filtrarDuplicados = (lista) => lista.filter((item, pos) => lista.indexOf(item) === pos);

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

Adecuado para entornos que soporten ES5, aunque su complejidad O(n²) lo hace menos eficiente para arrays extensos.

Implementación con reduce para acumular únicos

Reduce construye un array acumulativo, incorporando elementos no previamente incluidos.

const reducirDuplicados = (coleccion) => coleccion.reduce((acumulador, valorActual) => {
    if (!acumulador.includes(valorActual)) {
        acumulador.push(valorActual);
    }
    return acumulador;
}, []);

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

Útil para arrays de objetos si se modifica la lógica de comparación, pero presenta complejidad O(n²).

Ordenamiento y filtrado para arrays secuenciales

Cuando el array ya está ordenado, se puede combinar ordenamiento y filtrado para mayor eficiencia.

const desduplicarSecuencial = (arreglo) => arreglo.sort((a, b) => a - b).filter((elem, idx, arr) => idx === 0 || elem !== arr[idx - 1]);

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

Requiere preordenamiento, lo que puede incrementar la carga computacional, pero es eficaz para datos ya estructurados.

Comparativa de técnicas

Para rendimiento superior con tipos simples, Set es óptimo. En casos con objetos complejos, Map ofrece flexibilidad mediante claves personalizadas.