Sorting the array conveniently groups duplicates together, making them easily identifiable:

arr.sort();
let previous = arr[0];
for (let i=1; i<arr.length; i++) {
   if (arr[i] == previous) console.log('Duplicate found: '+previous);
   previous = arr[i];
}

This code can efficiently find duplicates in any array, making it versatile for general use. However, for specific cases where arrays contain only strings, there may be more optimized solutions available.

function hasDuplicate(arr) {
    var i = arr.length, j, val;

    while (i--) {
        val = arr[i];
        j = i;
        while (j--) {
            if (arr[j] === val) {
                return true;
            }
        }
    }
    return false;
}

Among the multitude of solutions provided, I feel compelled to add my own.

If you opt for utilizing lodash library:

function detectDuplicates(array) {
  return _.uniq(array).length !== array.length; 
}

In case ES6 Sets are accessible:

function detectDuplicates(array) {
  return array.length !== new Set(array).size
}

If sticking to vanilla JavaScript:

function detectDuplicates(array) {
  return array
    .sort()
    .some(function (item, i, items) {
      return item === items[i + 1]
    })
}

Sometimes, checking for duplicate items based on a specific field becomes necessary.

This is how such scenario could be handled:

detectDuplicates([{country: 'AU'}, {country: 'UK'}, {country: 'AU'}], 'country')

function detectDuplicates(array, attribute) {
  return array
    .map(function (item) { return item[attribute] })
    .sort()
    .some(function (item, i, items) {
      return item === items[i + 1]
    })
}

Stopping the loop once a duplicate is found:

function checkForDuplicates(array) {

    var checker = {}, length = array.length;
    for (var index = 0; index < length; index++) {
        if (checker[array[index]]) {
             return true;
        }
        checker[array[index]] = true;
    }
    return false;

}

Correction made to address 'toString' issue:

function checkForDuplicates(array) {

    var checker = {}, length = array.length;
    for (var index = 0; index < length; index++) {
        if (checker[array[index]] === true) {
             return true;
        }
        checker[array[index]] = true;
    }
    return false;

}

This adjustment accounts for scenarios like checkForDuplicates(['toString']); and so on.

When it comes to sorting, the complexity is O(n log n) rather than just O(n). On the other hand, constructing a hash map has a complexity of O(n), despite consuming more memory compared to an in-place sort. However, if speed is your priority, this approach would be considered the "fastest." (There may still be room for optimization, but at the moment, it is near optimal considering a constant factor.)

function detectDuplicates(arr) {
  var hashTable = {};
  var hasDuplicates = false;
   arr.forEach(function(value) {
     if (hashTable[value]) {
       hasDuplicates = true;
       return;
     }
     hashTable[value] = true;
  });
  return hasDuplicates;
}

    let position = myArray.indexOf(elementString);
    if (position < 0) {
        myArray.push(elementString);
        console.log("Element Added to Array: " + elementString);
    } else {
        console.log("Element Already Exists at Index: " + position);
    }

To determine if an array has duplicates, you can first convert it to a Set instance and then compare the lengths of the original array and the unique set.

const checkDuplicates = (arr) => {
  const newArray = ['one','two','one'];
  const uniqueSet = new Set(arr);
  
  return arr.length !== uniqueSet.size();
};

console.log(`Has duplicates : ${checkDuplicates(['one','two','one'])}`);
console.log(`Has duplicates : ${checkDuplicates(['one','two','three'])}`);

The efficiency of the solution depends on the size of the input array. Through performance tests using Node.js performance hooks, I have discovered that for smaller arrays (ranging from 1,000 to 10,000 entries), the Set solution may potentially be faster. However, for larger arrays (around 100,000 elements), the plain Object (hash) solution proves to be more efficient. Feel free to experiment with the code below:

const { performance } = require('perf_hooks');

function objectSolution(nums) {
  let testObj = {};
  for (var i = 0; i < nums.length; i++) {
    let aNum = nums[i];
    if (testObj[aNum]) {
      return true;
    } else {
      testObj[aNum] = true;
    }
  }

  return false;
}

function setSolution(nums) {
  let testSet = new Set(nums);
  return testSet.size !== nums.length;
}

function sortSomeSolution(nums) {
  return nums
    .sort()
    .some(function (item, i, items) {
      return item === items[i + 1]
    })
}

function runTest(testFunction, testArray) {
  console.log('   Running test:', testFunction.name);
  let start = performance.now();
  let result = testFunction(testArray);
  let end = performance.now();
  console.log('      Duration:', end - start, 'ms');
}

let arr = [];
let setSize = 100000;
for (var i = 0; i < setSize; i++) {
  arr.push(i);
}

console.log('Set size:', setSize);
runTest(objectSolution, arr);
runTest(setSolution, arr);
runTest(sortSomeSolution, arr);

When testing on my Lenovo IdeaPad with an i3-8130U processor running Node.js v. 16.6.2, I obtained the following results for an array of 1,000:

https://i.sstatic.net/FGSbD.png

results for the array of 100,000:

https://i.sstatic.net/ntCew.png