如果重复，则从数组中删除这两个值-JavaScript/jQuery

我这里有一个数组：

var myArr = [1, 1, 2, 5, 5, 7, 8, 9, 9];

现在，我想删除复制的两个外观。因此期望的结果是而不是：

var myArr = [1, 2, 5, 7, 8 ,9];

但是

基本上我知道如何删除重复项，但不是以那种特殊的方式。这就是为什么我们会非常感激任何帮助

---

请注意：我的数组中填充了字符串。此处的数字仅用作示例。

编辑后得到了更好的答案：

var myArr = [1, 1, 2, 5, 5, 7, 8, 9, 9];

function removeDuplicates(arr) {
    var i, tmp;
    for(i=0; i<arr.length; i++) {
        tmp = arr.lastIndexOf(arr[i]);
        if(tmp === i) {
            //Only one of this number
        } else {
            //More than one
            arr.splice(tmp, 1);
            arr.splice(i, 1);
        }
    }
}

---

var myArr=[1,1,2,5,5,7,8,9,9]；
功能移除副本（arr）{
var i，tmp；
对于（i=0；i对于该代码：

var myArr = [1, 1, 2, 5, 5, 7, 8, 9, 9];
var newArr = myArr;
var h,i,j;


for(h = 0; h < myArr.length; h++) {
    var curItem = myArr[h];
    var foundCount = 0;
    // search array for item
    for(i = 0; i < myArr.length; i++) {
        if (myArr[i] == myArr[h])
            foundCount++;
    }
    if(foundCount > 1) {
        // remove repeated item from new array
        for(j = 0; j < newArr.length; j++) {
            if(newArr[j] == curItem) {                
                newArr.splice(j, 1);
                j--;
            }
        }            
    }
}

var myArr=[1,1,2,5,5,7,8,9,9]；
var newArr=myArr；
var h，i，j；
对于（h=0；h1）{
//从新数组中删除重复项
对于（j=0；j
无论在何处删除重复项，都可以使用

JavaScript没有本机集实现，但对象的键也可以工作——在本例中，这些值有助于跟踪项在数组中出现的频率：

function removeDuplicates(arr) {
    var counts = arr.reduce(function(counts, item) {
        counts[item] = (counts[item]||0)+1;
        return counts;
    }, {});
    return Object.keys(counts).reduce(function(arr, item) {
        if(counts[item] === 1) {
            arr.push(item);
        }
        return arr;
    }, []);
}

var myArr = [1, 1, 2, 5, 5, 7, 8, 9, 9];
removeDuplicates(myArr);


或者，您不能使用对
reduce（）
的调用，而是将
用于
和
用于（计数中的项目）
循环：

function removeDuplicates(arr) {
    var counts = {};
    for(var i=0; i<arr.length; i++) {
        var item = arr[i];
        counts[item] = (counts[item]||0)+1;
    }
    var arr = [];
    for(item in counts) {
        if(counts[item] === 1) {
            arr.push(item);
        }
    }
    return arr;
}

功能移除副本（arr）{
变量计数={}；
对于（var i=0；i.
这是我的版本

var a = [1, 1, 2, 5, 5, 7, 8, 9, 9];

function removeIfduplicate( arr ) {
    var discarded = [];
    var good      = [];
    var test;
    while( test = arr.pop() ) {
        if( arr.indexOf( test ) > -1 ) {
            discarded.push( test );
            continue;
        } else if( discarded.indexOf( test ) == -1 ) {
            good.push( test );
        }
    }
    return good.reverse();
}

x = removeIfduplicate( a );
console.log( x ); //[2, 7, 8]

如果它只是字母数字，重复项区分大小写，并且任何元素不能超过两个，那么类似的东西可以工作：

var a = [2, 1, "a", 3, 2, "A", "b", 5, 6, 6, "B", "a"],

    clean_array = $.map(a.sort(), function (v,i) {
        a[i] === a[i+1] && (a[i] = a[i+1] = null);
        return a[i];
    });

// clean_array = [1,3,5,"A","B","b"]

编辑：这里是jspref


这是在不使用任何花式技巧和保持灵活性的情况下两次完成的最快方法。首先旋转一遍，找到每次发生的计数，并将其放入和键值对中。然后再次旋转一遍，过滤掉计数大于1的计数。这还有一个优点，即可以应用其他方法过滤器不仅仅是“大于1”；如果您需要，还可以对其他事件进行计数

这也适用于字符串而不是数字


var myArr=[1,1,2,5,5,7,8,9,9]；
var map=新对象（）；
对于（变量i=0；i1）
{
//无所事事
}
其他的
{
结果：push（myArr[i]）；
}
}
警报（结果）；
在本例中，我们将两个数组作为函数参数，因此我们将只打印两个数组的唯一值，从而删除两个数组中存在的值

首先，我将两个数组连接成一个。然后，我一次获取每个数组值，并在数组本身上循环搜索其出现次数。如果出现次数（即计数）等于1，则我们将该元素推入结果数组。然后，我们可以返回结果数组

function diffArray(arr1, arr2) {
  var newArr = [];
  var myArr=arr1.concat(arr2);
  var count=0;
  for(i=0;i<myArr.length;i++){
    for(j=0;j<myArr.length;j++){
      if(myArr[j]==myArr[i]){
        count++;
      }
    }
    if(count==1){
      newArr.push(myArr[i]);
    }
    count=0;
  }
  return newArr;
}

函数diffArray（arr1、arr2）{
var newArr=[]；
var myArr=arr1.concat（arr2）；
var计数=0；
对于（i=0；i您可以使用Set（在IE 11+中提供），如下所示

N.B.较旧的浏览器不支持箭头函数。请改用普通函数语法。但是，
Array.from
对于较旧的浏览器很容易使用

.
这里有一个使用
Array.filter（）
的简短版本。诀窍是首先查找所有非唯一的值，然后使用此数组拒绝原始数组中的所有唯一项

让myArr=[1,1,2,5,5,7,8,9,9]；
让duplicateValues=myArr.filter（（项，indx，s）=>s.indexOf（项）！==indx）；
myArr.filter（项=>！duplicateValues.includes（项））；
// => [2, 7, 8]







（如果您对解释感兴趣）
它总是有序的和/或数字的吗？一个值会出现两次以上吗？@jeschafe:为什么这很重要？你无论如何都不能在次线性时间内这样做……如果你是这样的话after@jeschafe它是用字符串填充的，不是有序的。j08691:不，任何值都不能出现两次以上。这只是因为它会影响代码的编写方式。有些是below在aray中不使用字符串。我打算使用此策略发布一个答案。下面是我编写的JSFIDLE帮助您：最后，myArr包含
[1,5,7,9]
。呃，我刚刚意识到，只有当数组中只有两个数字时，这才有效。如果这是最大值，有一种更简单的方法可以根据当前的I值检查lastIndexOf（）。如果它们匹配，就很好，如果不匹配，就可以根据每个数字的索引删除这两个。var myArr=[1，1，2，5，5，7，8，9]；function removedupplicates（arr）{var i，tmp；for（i=0；iI）喜欢这个答案……但我认为如果元素没有按顺序排列，它就不起作用了：尽管我很喜欢
。reduce
，我怀疑对
counts
对象进行简单的迭代会更有效率……@Alnitak-你是说计数中的项类似
{ /*...*/ }
？是的，这就是我的意思。使用
.reduce
为每次迭代调用函数的开销可能相当高。如果您在我的回答中查看jspref，您会发现这些函数的性能并不好。如果您追求的是性能和速度，则第二个循环的迭代次数比必须的要多。如@Alnitak所建议的，您应该这样做使用
for（key in map）{/*…*/}
循环请给出更多解释是否可以使用lodash
var myArr = [1, 1, 2, 5, 5, 7, 8, 9, 9];
var map = new Object();

for(var i = 0; i < myArr.length; i++)
{
    if(map[myArr[i]] === undefined)
    {
        map[myArr[i]] = 1;
    }
    else
    {
        map[myArr[i]]++;
    }
}

var result = new Array();

for(var i = 0; i < myArr.length; i++)
{   
    if(map[myArr[i]] > 1)
    {
        //do nothing
    }
    else
    {
        result.push(myArr[i]);
    }

}

alert(result);

function diffArray(arr1, arr2) {
  var newArr = [];
  var myArr=arr1.concat(arr2);
  var count=0;
  for(i=0;i<myArr.length;i++){
    for(j=0;j<myArr.length;j++){
      if(myArr[j]==myArr[i]){
        count++;
      }
    }
    if(count==1){
      newArr.push(myArr[i]);
    }
    count=0;
  }
  return newArr;
}

const sourceArray = [1, 2, 3, 4, 5, 5, 6, 6, 7, 7, 8];
const duplicatesRemoved = new Set();

sourceArray.forEach(element => {
    if (duplicatesRemoved.has(element)) {
        duplicatesRemoved.delete(element)
    } else {
        duplicatesRemoved.add(element)
    }
})

console.log(Array.from(duplicatesRemoved))

// this statement removes all dupicate values
myArr.filter((item, indx, s) => s.indexOf(item) === indx)

// by changing === to !== we do the "opposite", which means that we remove
// all items that are unique
myArr.filter((item, indx, s) => s.indexOf(item) !== indx)