¿Cómo puedo comprobar si hay un duplicado en mi lista de arrays en TypeScript?

Hola, actualmente tengo un arreglo así en mi código de TypeScript. ¿Cómo puedo comprobar si hay un elemento en mi arreglo que aparezca dos veces? Me gustaría crear una función que devuelva verdadero o falso si el arreglo pasado contiene un elemento duplicado.

  let tagonTypes: Array<string> = [];
  tagonTypes.push("NTM");
  tagonTypes.push("MCD");

en la matriz anterior no hay duplicados, por lo que la función debería devolver falso.

  let tagonTypes: Array<string> = [];
  tagonTypes.push("NTM");
  tagonTypes.push("NTM");

En el arreglo anterior mi función debería devolver verdadero porque "NTM" se repite.

¿Alguna idea de cómo se ve mi función?

gracias

Respuesta #1

Puedes usar el tamaño del set si todo lo que necesitas es verificar si se han agregado duplicados:

function hasDuplicates<T>(arr: T[]): boolean {
  return new Set(arr).size < arr.length;
}

hasDuplicates(["A", "A"]) // true
hasDuplicates(["A", "B"]) // false

También puedes usar el objeto proxy para saber cuándo se agrega un duplicado a medida que se agregan al arreglo:

const myArray1 = ["a", "b"];

const myArrayProxy1 = new Proxy(myArray1, {
  set: (target, property, value) => {
    const exits = target.includes(value);
    if (exits) {
      console.log(`Duplicate index ${property.toString()}, value: ${value}`);
    }
    return true;
  }
});

myArrayProxy1.push("a", "a", "b", "c");
// Prints:
// Duplicate index 2, value: a
// Duplicate index 3, value: a
// Duplicate index 4, value: b

Si quieres ser proactivo y simplemente trabajar con tu arreglo sin que tenga duplicados, puedes anular la lógica de configuración:

const myArray2 = ["a", "b"];

const myArrayProxy2 = new Proxy(myArray2, {
  get: (target, property) => {
    return Reflect.get(target.filter(Boolean), property);
  },
  set: (target, property, value) => {
    const exits = target.includes(value);
    return exits ? true : Reflect.set(target, property, value);
  }
});

myArrayProxy2.push("a", "a", "b", "c");
console.log([...myArrayProxy2]); // - Prints: ["a", "b", "c"]

Respuesta #2

Aquí hay un método para comprobar si hay duplicados en un arreglo indexado simple.

const hasDuplicates = (set, items = []) => {
    return set.reduce((duplicates, item) => {
        return (duplicates || items.includes(item))
            || items.push(item) && false
    }, false)
}

https://jsfiddle.net/cotpgkyd/1/

Aquí hay otro método que puede reducir una lista a solo sus elementos no duplicados.

const unique = (set, item) => {
    return (set.includes(item) || set.push(item)) && set
}

Llamado ya sea como una coalescencia o reducción:

var myList = []

myList = unique(myList, 'a')
myList = unique(myList, 'b')
myList = unique(myList, 'c')
myList = unique(myList, 'b')
myList = unique(myList, 'c')
myList = unique(myList, 'c')

console.log(myList)                           // ["a", "b", "c"]

var myOtherList = ['a','b','c','b',];

console.log(myOtherList.reduce(unique, []))   // ["a", "b", "c"]

https://jsfiddle.net/pnt9gaq6/