Remove duplicates from javascript array_javascript skills

Generally speaking, I gained a lot from the interview process. The main thing is to understand how big my gap is and how narrow my knowledge is. It is still necessary to give a proper blow to my self-confidence. Here is a comprehensive summary about the issue of array deduplication in JavaScript.

It is relatively easy to accept a problem from simple to complex. First, assume that the array to be duplicated is relatively simple, for example:

Copy code The code is as follows:

var arr=[1,2,2,3,'5',6,5,'',' ']

This array only contains numbers and strings. We add the deduplication method distinct to the array prototype. We use the first method that is easy to think of to implement it. Of course, it is also very stupid and straightforward. Make a copy of this array and then loop through the two arrays to compare the current value with all subsequent values. Whether the value is equal, if not equal to all subsequent values, store the value in a new array, and finally return the new array. The method is as follows:

Copy the code The code is as follows:

//The first method
Array.prototype.distinct=function(){
var clone,newArr=[],n=0;
if(this.length<2)return;
clone=this;
for( var i=0,len=this.length;ifor(var j=i 1,len2=clone.length;jif(this[i ]!==clone[j]){
n ;
}
}
if(n==(len-i-1)){
newArr.push(this[i ])
}
n=0;
}
return newArr;
}
console.log([1,2,2,3,'5',6,5 ,'',' '].distinct());
/*Get the value of the checked radio*/
function GetRadioValue(RadioName){
var obj;
obj=document.getElementsByName (RadioName);
if(obj!=null){
var i;
for(i=0;iif(obj[i].checked ){
return obj[i].value;
}
}
}
return null;
}

/*Set the selected attribute*/
function SetRadioCheck(RadioName,i){
var obj;
obj=document.getElementsByName(RadioName);
obj[i].setAttribute("checked","checked");
}

It can basically meet our needs. It does not take much brainpower to compare such a simple type, but what if the array is very long? Traversing the array in this way, the length of the array is n, then the time complexity is n*n. Obviously the performance of this method needs to be improved. Next is the second method, which uses array sorting to remove duplicate values ​​during the sorting process.

Copy code The code is as follows:

//Second method
Array.prototype .distinct=function(){
var newArr=this.concat().sort(),self=this;
newArr.sort(function(a,b){
var n;
if(a===b){
n=self.indexOf(a);
self.splice(n,1);
}
});
return self;
}
console.log([1,2,2,3,'5',6,5,6,6,15,5,'5',5,'',' '].distinct( ));

This code seems to be much shorter, there is not even a for loop, but the sort efficiency is not much higher. Let’s take a look at the third implementation method. The principle of using object attributes that will not have duplicate names

Copy the code The code is as follows:

//The third method
Array.prototype.distinct=function(){
var newArr=[],obj={};
for(var i=0 ,len=this.length;iif(!obj[this[i]]){
newArr.push(this[i]);
obj[this[i ]]='new';
}
}
return newArr;
}
console.log([1,2,2,3,'5',6,5,6 ,6,15,5,'5',5,'',' '].distinct());

Run the third method and look at the results. You will find that it is the same as the above method. The results are inconsistent. If you look closely, it turns out that the number 5 and the string 5 are removed as duplicate values. It seems that the types must be saved and then judged whether they are equal, so there is a supplementary version of the third method below

Copy code The code is as follows:

//Supplementary version of the third method
Array.prototype.distinct=function(){
var newArr=[],obj={};
for(var i=0,len=this.length;iif(!obj[typeof(this[i]) this[i]]){
newArr.push( this[i]);
obj[typeof(this[i]) this[i]]='new';
}
}
return newArr;
}

The example above is a very simple type, let’s test it with a more complex type

Copy code The code is as follows:

console.log([1,null,2,{a:'vc'},{},'5',6,5,6,{a:'vv'},15,5, '5',5,'',' ',[1],[1],[1,2],,].distinct());

Found {a:'vc' },{},{a:'vv'}These different objects will still be eliminated. If there are objects in the array, you will continue to traverse the properties and values ​​​​in the objects, and continue to enhance the third method

Copy code The code is as follows:

//Enhanced version of the third method
Array.prototype.distinct= function(){
var sameObj=function(a,b){
var tag = true;
if(!a||!b)return false;
for(var x in a) {
if(!b[x])
return false;
if(typeof(a[x])==='object'){
tag=sameObj(a[x], b[x]);
}else{
if(a[x]!==b[x])
return false;
}
}
return tag;
}
var newArr=[],obj={};
for(var i=0,len=this.length;iif(!sameObj(obj[ typeof(this[i]) this[i]],this[i])){
newArr.push(this[i]);
obj[typeof(this[i]) this[i]] =this[i];
}
}
return newArr;
}

Using the above example, we found that there is basically no problem. Of course, the test can be more perverted. It’s even more confusing, so I won’t delve into it here. At present, this method is relatively complete on the Internet. If there is a better and more complete method, please feel free to enlighten me.