Javascript 检查数组是否包含重复的值

我想编写一个javascript函数来检查数组是否包含重复值

我已经写了下面的代码，但是它的答案总是“true”

谁能告诉我我错过了什么

function checkIfArrayIsUnique(myArray) 
    {
        for (var i = 0; i < myArray.length; i++) 
        {
            for (var j = 0; j < myArray.length; j++) 
            {
                if (i != j) 
                {
                    if (myArray[i] == myArray[j]) 
                    {
                        return true; // means there are duplicate values
                    }
                }
            }
        }
        return false; // means there are no duplicate values.
    }

函数检查阵列唯一（myArray）
{
对于（var i=0；i

返回值的方式不对：

• 一旦找到两个相等的值，就可以断定数组不是唯一的，并返回

  false

• 最后，在检查了所有对之后，可以返回

  true

---

如果您经常这样做，并且数组很大，那么您可能需要研究排序数组然后只比较相邻元素的可能性。这将比您当前的方法具有更好的渐进复杂性。

这应该只适用于一个循环：

function checkIfArrayIsUnique(arr) {
    var map = {}, i, size;

    for (i = 0, size = arr.length; i < size; i++){
        if (map[arr[i]]){
            return false;
        }

        map[arr[i]] = true;
    }

    return true;
}

功能检查ArrayisUnique（arr）{
var-map={}，i，size；
对于（i=0，size=arr.length；i

假设您的目标浏览器不是IE8

这也会起作用：

function checkIfArrayIsUnique(myArray) 
{
    for (var i = 0; i < myArray.length; i++) 
    {
        if (myArray.indexOf(myArray[i]) !== myArray.lastIndexOf(myArray[i])) { 
            return false; 
        } 
    } 
    return true;   // this means not unique
}

函数检查阵列唯一（myArray）
{
对于（var i=0；i

函数检查阵列唯一（myArray）
{
isUnique=true
对于（var i=0；i

这假设数组在开始时是唯一的

---

如果找到两个相等的值，则更改为false，这是有史以来最好的解决方案

 Array.prototype.checkIfArrayIsUnique = function() {
    this.sort();    
    for ( var i = 1; i < this.length; i++ ){
        if(this[i-1] == this[i])
            return false;
    }
    return true;
    }

Array.prototype.checkIfArrayIsUnique=function（）{
this.sort（）；
对于（var i=1；i

如果您有ES6，一个简单的解决方案使用：

函数检查阵列唯一（myArray）{
返回myArray.length==新集合（myArray.size）；
}
设uniqueArray=[1,2,3,4,5]；
log（${uniqueArray}是唯一的：${checkifarrayisinque（uniqueArray）}`）；
设ununiquearray=[1,1,2,3,4,5]；
log（${ununiquearray}是唯一的：${checkifarrayisinque（ununiquearray）}`）这里有一个O（n）解决方案：

function hasDupes(arr) {
  /* temporary object */
  var uniqOb = {};
  /* create object attribute with name=value in array, this will not keep dupes*/
  for (var i in arr)
    uniqOb[arr[i]] = "";
  /* if object's attributes match array, then no dupes! */
  if (arr.length == Object.keys(uniqOb).length)
    alert('NO dupes');
  else
    alert('HAS dupes');


}
var arr = ["1/1/2016", "1/1/2016", "2/1/2016"];
hasDupes(arr);

问题中给出的代码可以更好地编写如下

function checkIfArrayIsUnique(myArray) 
    {
        for (var i = 0; i < myArray.length; i++) 
        {
            for (var j = i+1; j < myArray.length; j++) 
            {                  
                    if (myArray[i] == myArray[j]) 
                    {
                        return true; // means there are duplicate values
                    }

            }
        }
        return false; // means there are no duplicate values.
    }

函数检查阵列唯一（myArray）
{
对于（var i=0；i

True->数组有重复项

False->uniqe数组

没有
for循环
，只有
使用Map（）

您还可以返回副本

(function(a){
  let map = new Map();

  a.forEach(e => {
    if(map.has(e)) {
      let count = map.get(e);
      console.log(count)
      map.set(e, count + 1);
    } else {
      map.set(e, 1);
    }
  });

  let hasDup = false;
  let dups = [];
  map.forEach((value, key) => {
    if(value > 1) {
      hasDup = true;
      dups.push(key);
    }
  });
   console.log(dups);
   return hasDup;
 })([2,4,6,2,1,4]);

返回数组中的重复项，并创建无重复项的新数组：

 var a = ["hello", "hi", "hi", "juice", "juice", "test"];
    var b = ["ding", "dong", "hi", "juice", "juice", "test"];
    var c = a.concat(b);
    var dupClearArr = [];

    function dupArray(arr) {

        for (i = 0; i < arr.length; i++) {
            if (arr.indexOf(arr[i]) != i && arr.indexOf(arr[i]) != -1) {
                console.log('duplicate item ' + arr[i]);
            } else {
                dupClearArr.push(arr[i])
            }

        }
        console.log('actual array \n' + arr + ' \nno duplicate items array \n' + dupClearArr)
    }

    dupArray(c);

var a=[“你好”、“你好”、“你好”、“果汁”、“果汁”、“测试”]；
变量b=[“丁”、“东”、“喜”、“汁”、“汁”、“测试”]；
var c=a.concat（b）；
var dupClearArr=[]；
函数阵列（arr）{
对于（i=0；i
编写此命令是为了初始化长度为uniqueIndexCount的新数组。这里给出的是不相关的逻辑

    public Vector3[] StandardizeVertices(Vector3[] dimensions, int standard)
    {
        //determine the number of unique dimension vectors
        int uniqueIndexCount = 0;
        for (int a=0; a < dimensions.Length; ++a)
        {
            int duplicateIndexCount = 0;
            for (int b = a; b < dimensions.Length; ++b)
            {
                if(a!=b && dimensions[a] == dimensions[b])
                {
                    duplicateIndexCount++;
                }
            }
            if (duplicateIndexCount == 0)
            {
                uniqueIndexCount++;
            }
        }
        Debug.Log("uniqueIndexCount: "+uniqueIndexCount);
        return dimensions;
    }

public Vector3[]标准化维度（Vector3[]维度，国际标准）
{
//确定唯一维度向量的数量
int uniqueIndexCount=0；
对于（int a=0；a
功能无重复（arr）{
返回arr.every（num=>arr.indexOf（num）==arr.lastIndexOf（num））；
}

hasnodupplicates
接受数组，如果没有重复值，则返回
true
。如果存在任何重复项，函数将返回
false
延迟回答，但可能会有所帮助

function areThereDuplicates(args) {

    let count = {};
    for(let i = 0; i < args.length; i++){
         count[args[i]] = 1 + (count[args[i]] || 0);
    }
    let found = Object.keys(count).filter(function(key) {
        return count[key] > 1;
    });
    return found.length ? true : false; 
}

areThereDuplicates([1,2,5]);

函数有重复项（args）{
让count={}；
for（设i=0；i    public Vector3[] StandardizeVertices(Vector3[] dimensions, int standard)
    {
        //determine the number of unique dimension vectors
        int uniqueIndexCount = 0;
        for (int a=0; a < dimensions.Length; ++a)
        {
            int duplicateIndexCount = 0;
            for (int b = a; b < dimensions.Length; ++b)
            {
                if(a!=b && dimensions[a] == dimensions[b])
                {
                    duplicateIndexCount++;
                }
            }
            if (duplicateIndexCount == 0)
            {
                uniqueIndexCount++;
            }
        }
        Debug.Log("uniqueIndexCount: "+uniqueIndexCount);
        return dimensions;
    }

function areThereDuplicates(args) {

    let count = {};
    for(let i = 0; i < args.length; i++){
         count[args[i]] = 1 + (count[args[i]] || 0);
    }
    let found = Object.keys(count).filter(function(key) {
        return count[key] > 1;
    });
    return found.length ? true : false; 
}

areThereDuplicates([1,2,5]);