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:
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:
//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.
//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
//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
//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
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
//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.
What are the definitions of arrays?
js string to array
Array initialization method
c array initialization method
How to find the maximum and minimum value of array elements in Java
How to remove the first few elements of an array in php
Summary of java basic knowledge
Zero-based Java self-study tutorial
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
