Summary of problems with js array deduplication_javascript skills

1.According to the principle of non-duplication of keys in js objects, a method for deduplication of arrays is conceived. According to the most conventional thinking, the following is the following:

Copy code The code is as follows:

function distinctArray(arr){
var obj={},temp=[];
for(var i=0;iif(!obj[arr[i]]){
temp.push(arr[i]);
obj[arr[i]] =true;
}
}
return temp;
}
var testarr=[1,2,3,2];
console.log (distinctArray(testarr));//[1,2,3]

It looks pretty good, but if it becomes the following situation:
var testarr1=[1,2 ,3,"2"];
console.log(distinctArray(testarr));// [1,2,3]
Still the same result, this is not what we want, we need The result should be [1,2,3,"2"]. That is, the integrity of the type needs to be ensured during the deduplication process.

In view of the above situation, we have improved the above method:

Copy the code The code is as follows:

function distinctArrayImprove(arr){
var obj={},temp=[];
for(var i=0;iif(!obj[typeof (arr[i]) arr[i]]){
temp.push(arr[i]);
obj[typeof (arr[i]) arr[i]] =true;
}
}
return temp;
}

The above method adds the typeof prefix when putting the key into the object, so let's see the effect.
var testarr1=[1,2,3,"2"];
console.log(distinctArray(testarr));// [1,2,3,"2"]
Oops, Not bad! So is this function completely ok? Let us look at another situation!
var testarr1=[1,2,3,"2",{a:1},{b:1}];
console.log(distinctArray(testarr));// [1,2, 3. "2",{a:1}]
This result appeared. Why was {b:1} deleted inexplicably? It would be very serious if useful data is accidentally deleted during the deduplication process. problem, so the above method is not a perfect one, so let us continue to look down.

2.In 1, our main idea is to use the concept of non-repetition of keys in js objects to guide our thinking, but in the end we did not solve all the problems, so then We can consider changing our thinking mode to achieve the functions we want.

Use slice and splice methods to achieve deduplication of arrays, as follows:

Copy code The code is as follows:

function distinctArray2(arr){
var temp=arr.slice(0);//Copy the array to temp
for(var i=0;ifor(j=i 1;jif(temp[j]==temp[i]){
temp.splice(j,1 );//Delete the element
j--;
}
}
}
return temp;
}

Test:
var testarr1=[1,2,3,"2"];
console.log(distinctArray(testarr));//[1,2,3]
var testarr2=[1,2,2, {a:1},{a:1},{a:1,b:2},function(){alert("b");},function(){alert("b");}];
//[1,2,{a:1},{a:1},{a:1,b:2},function(){alert("b");},function(){alert( "b");}]

The test results still cannot meet our needs, what should we do? After our team's research on the above methods, we found that the main problem lies in the operation of comparing two objects for equality. The use of "==" in distinctArray2 for comparison cannot distinguish whether the contents of large objects are equal. In view of this situation, we Another method was written:

Copy code The code is as follows:

function distinctArrayAll(arr){
var isEqual=function(obj1,obj2){
//The addresses of two objects are equal and must be equal
if(obj1===obj2){
return true;
}
if(typeof(obj1)==typeof(obj2)){
if(typeof(obj1)=="object"&&typeof(obj2)=="object"){
var pcount=0;
for(var p in obj1){
pcount ;
if(!isEqual(obj1[p],obj2[p])){
return false;
}
}
for(var p in obj2){
pcount--;
}
return pcount==0;
}else if(typeof(obj1)=="function"&&typeof(obj2)= ="function"){
if(obj1.toString()!=obj2.toString()){
return false;
}
}else {
if(obj1!=obj2 ){
return false;
}
}
}else{
return false;
}
return true;
}
var temp=arr. slice(0);//Copy the array to temp
for(var i=0;ifor(j=i 1;jif(isEqual(temp[j],temp[i])){
temp.splice(j,1);//Delete the element
j--;
}
}
}
return temp;
}

Test:
var testArr3=[1,2,2,{a:1},{a:1},{a:1,b:2},function(){alert("b") ;},function(){alert("b");}];
console.log(distinctArrayAll(testArr3));
//Results[1,2,{a:1},{a: 1,b:2},function(){alert("b");}]

Oh, we finally completed the task of removing duplicates successfully. As for the performance issues of each method, we will leave it to the next discussion! We can see that the last method is a universal deduplication method, which can deduplicate complex arrays, but the corresponding execution overhead is also quite large. In actual project development, sometimes what we need may only be pure numbers or pure characters. String deduplication requires us to flexibly select the corresponding algorithm according to our needs. We don’t seek to be too perfect, but only seek to make the program more efficient on the basis of meeting the needs!