Javascript 获取数组中没有双精度值的元素

我有个问题。如何检索数组中没有双精度值的元素？？例如：[1,1,2,2,3,4,4,5]，然后仅检索[3,5]。 提前谢谢

for (var j = 0; j < newArr.length; j++) {
  if ((arr1.indexOf(newArr[j]) === 0) && (arr2.indexOf(newArr[j]) === 0)) {
    index = newArr.indexOf(j); newArr.splice(index, 1);
  }
}

for（var j=0；j

如果数组中的项是唯一的，则从开头找到的索引应等于从结尾找到的索引，换句话说：

var xs=[1,1,2,2,3,4,4,5]； var result=xs.filter（函数（x）{ 返回xs.indexOf（x）==xs.lastIndexOf（x）； });

---

console.log（结果）；//=>[3,5]创建新数组

tmp

，并通过

索引检查已经存在的值。如果存在，则通过
拼接
功能删除

var arr = [1,1,2,2,3,4,4,5];
var tmp = [];
var dup = [];
    for(var i = 0; i < arr.length; i++){
        var ind = tmp.indexOf(arr[i]);
        if(ind == -1){
         if(dup.indexOf(arr[i]) == -1){
               tmp.push(arr[i]);
           }
        }
        else{
        tmp.splice(ind,1);
        dup.push(arr[i]);
        }
    }
    console.log(tmp);

var-arr=[1,1,2,2,3,4,4,5]；
var tmp=[]；
var-dup=[]；
对于（变量i=0；i
一种针对未排序数组的解决方案，其中包含项的哈希表。复杂性O（2n）


var数组=[1,1,2,2,3,4,4,5,1]，
hash=Object.create（null），
单一的；
forEach（函数（a，i）{
散列[a]=散列中的a？-1:i；
});
single=array.filter（函数（a，i）{
返回散列[a]==i；
});
控制台日志（单个）很抱歉，这是我的第一篇文章！
您必须将数组中的每个元素与其他元素进行比较，以获得每个元素的出现次数

    var tab = [1,1,2,2,3,4,4,5] //The array to analyze
    tab = tab.sort(); // we sort the array
    show(tab); // we display the array to the console (F12 to open it)

    var uniqueElementTab = []; // this array will contain all single occurence

    var sameElementCounter = 0;
    for(x=0;x<tab.length;x++){ // for all element in the array
        sameElementCounter = 0;
        for(y=0;y<tab.length;y++){ // we compare it to the others
            if((tab[x]==tab[y])){
                sameElementCounter+=1; // +1 each time we meet the element elsewhere 
            }
        }
        if(sameElementCounter<=1){
            uniqueElementTab.push(tab[x]); //if the element is unique we add it to a new array
        }
    }
    show(uniqueElementTab); // display result

    function show(tab) { // Simple function to display the content of an array
        var st="";
        for(i=0;i<tab.length;i++){
            st += tab[i]+" ";
        }
        console.log(st+"\n");
    }

var tab=[1,1,2,2,3,4,4,5]//要分析的数组
tab=tab.sort（）；//我们对数组进行排序
显示（选项卡）；//我们向控制台显示阵列（F12打开它）
var uniquelementtab=[]；//此数组将包含所有单个事件
var sameElementCounter=0；
对于（x=0；x这里有一个简单的“棘手”解决方案，使用
Array.sort
，
Array.join
，
Array.map
，
String.replace
和
String.split
函数：

var arr = [1, 1, 2, 2, 3, 4, 4, 5];
arr.sort();
var unique = arr.join("").replace(/(\d)\1+/g, "").split("").map(Number);

console.log(unique);  // [3, 5]

这将是我做这项工作的方式


var arr=[1,1,2,2,3,4,4,5]，
uniques=Object.keys（arr.reduce（（p，c）=>（p中的c）Object.defineProperty（p，c，{可枚举：false，
可写：对，
可配置：true}）
：p[c]=c，
p） ，{}）；
console.log（uniques）；
如果数组已排序，则可以在O（n）中解决此问题（请参阅下面的“pushUniqueSinglePass”）：


函数pushUniqueSinglePass（数组，唯一）{
var prev；//最后看到的元素
var run=0；//已看到它的次数
对于（var i=0；i}
好的，这是一个公平的尝试，检查我的答案。对于（var i=0；ilastIndexOf
；（可能是我做的开发已经够多了！…+1
filter
callback的第二个参数已经是当前元素的索引了。所以这里不需要
xs.indexOf（x）
。@Tresdin，那不一样，
indexOf
返回第一个参数index@elclanrs非常感谢！如果输入是
[1,1,1,2,2,3,4,4,5]
@Rayon我发现它不能用于超过两倍的值！如果
[1,1,2,2,3,4,4,5,1]，感谢可能会失败
很酷，但为了确保操作的安全性，您必须首先对数组进行排序。然后，在排序时，我很确定您可以想出更好的方法，而无需进行排序。例如使用对象哈希表的
forEach
循环（通过
this
参数提供）