How can i check if there is a duplicate in my array list in typescript?

You can use set size if all you need is to check if there has been duplicates added:

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

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

You can also use the proxy object to know when duplicate is added as they get added to the array:

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

If you do want to want to be proactive and just work with your array without it having duplicates you can override the setting logic:

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"]

Here is a method to check if there are duplicates in a simple indexed array.

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

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

Here's another method that can reduce a list to just it's non-duplicates.

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

Called as either a coalesce or reduction:

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/

Insert the elements into a Set, and use the Set.has method to test if each value is already present before you insert it:

function hasDuplicates<T>(array: Array<T>): boolean {
    const asSet: Set<T> = new Set();
    for(let x of array) {
        if(asSet.has(x)) { return true; }
        asSet.add(x);
    }
    return false;
}

This runs in O(n) time because testing if the set contains x is O(1). The loop stops looking at more elements from the array as soon as a duplicate value is detected.

Based on the solution here: https://stackoverflow.com/a/49215411/8676371

The method: duplicate will tell you if your array has duplicate elements.

let strArray = ["q", "w", "w", "e", "i", "u", "r"];

// Add this:
Array.prototype.duplicate = function () {
    return this.some((item, index) => this.indexOf(item) != index);
}

// Use it like this:
var dup = strArray.duplicate();

console.log(dup); // Outputs: true.

Any problem just going vanilla? Of course adding typescript stuff to the below but I don't get the relevance of TS to the question. Not sure the benefit of using more constructs like a Set when this is trivial. I'd be interested to know if I'm missing something but I'd just use an object to efficiently track elements as you loop and check for duplicates - as soon as you find one, return true.

One idea I was thinking of was if in some cases sorting the array first may help performance for large arrays and find duplicates faster but that would have its own overhead...

EDIT: If anyone is interested I tested this against using a Set and going plain vanilla is consistently 2X faster. http://jsben.ch/IWaDL

var array = ['NOM', 'NOM', 'NO', 'YES', 'DUP', 'DUP'];
var arrayTwo = ['NOM', 'NO', 'YES', 'DUP'];

var hasDuplicates = function (arr) {
  var obj = {};
  for (var i = 0; i < arr.length; i++) {
    if (obj[arr[i]])
      return true;
    obj[arr[i]] = 1;
  }
  return false;
};

console.log(hasDuplicates(array));
console.log(hasDuplicates(arrayTwo));

Create a Set ( a unique collection) out of all elements of the array and compare the lengths of the original array and the unique set that you created. if the number of elements in the array and the newly created set is not equals, that means you have duplicates.

function hasDuplicateElements(elements:any[] ):boolean {
   // check the length of array with size of the Set created with array
   return elements.length != new Set(elements).size;
 
}

let arrayDup=[5,7,8,"Any",7]

let arrayUnique=[5,7,8,"A","Some",1]

// this returns true as arrayDup contains duplicate entities
hasDuplicateElements(arrayDup);

// this returns false as arrayUnique has uniqe entities.
hasDuplicateElements(arrayUnique);

Hi all there are 3 solutions. 1. Using Set.

copy the array to a typescript set. On comparing the length of the set and array if they differ it means duplicate is there .

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

  let tagonTypesSet = new Set(tagonTypes)

tagonTypes.length!= tagonTypesSet.length // duplicates were present in the tagonTypes array and eliminated from the set.

2. use a filter .

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

     tagonTypes.filter( (item,index ) => {
       return tagonTypes.indexOf(item) === index
      });
   

   this will filter out the duplicates . the duplicates are where the index doesnt match the indexOf . so in those cases, the condition will be false and wont be included in the filtered array.

the filter array size then we compare with real one . if size difference is there it means duplicates are present.

3) Using reduce

The reduce method is used to reduce the elements of the array and combine them into a final array based on some reducer function that you pass. In this case, our reducer function is checking if our final array contains the item. If it doesn’t, push that item into our final array. Otherwise, skip that element and return just our final array as is (essentially skipping over that element). Reduce is always a bit more tricky to understand, so let’s also step into each case and see the output:

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

tagonTypes.reduce( (unique,item ) => {
return unique.includes(item) ? unique : [...unique,item]
},[]);

again compare the length of the array return by the reduce function and compare with length of the original array.