javascript 中关于array的常用方法详解
javascript中关于array的常用方法
最近总结了一些关于array中的常用方法，
其中大部分的方法来自于《JavaScript框架设计》这本书，
如果有更好的方法，或者有关于string的别的常用的方法，希望大家不吝赐教。
第一部分
数组去重，总结了一些数组去重的方法，代码如下：
/**
*去重操作,有序状态
*@paramtarget
*@returns{Array}
*/
functionunique(target){
letresult=[];
loop:for(leti=0,n=target.length;i
第二部分
数组中获取值，包括最大值，最小值，随机值。
/**
*返回数组中的最小值，用于数字数组
*@paramtarget
*@returns{*}
*/
functionmin(target){
returnMath.min.apply(0,target);
}
/**
*返回数组中的最大值，用于数字数组
*@paramtarget
*@returns{*}
*/
functionmax(target){
returnMath.max.apply(0,target);
}
/**
*从数组中随机抽选一个元素出来
*@paramtarget
*@returns{*}
*/
functionrandom(target){
returntarget[Math.floor(Math.random()*target.length)];
}
第三部分
对数组本身的操作，包括移除值，重新洗牌，扁平化和过滤不存在的值
/**
*移除数组中指定位置的元素，返回布尔表示成功与否
*@paramtarget
*@paramindex
*@returns{boolean}
*/
functionremoveAt(target,index){
return!!target.splice(index,1).length;
}
/**
*移除数组中第一个匹配传参的那个元素，返回布尔表示成功与否
*@paramtarget
*@paramitem
*@returns{boolean}
*/
functionremove(target,item){
constindex=target.indexOf(item);
if(~index){
returnremoveAt(target,index);
}
returnfalse;
}
/**
*对数组进行洗牌
*@paramarray
*@returns{array}
*/
functionshuffle(array){
letm=array.length,t,i;
//Whilethereremainelementstoshuffle…
while(m){
//Pickaremainingelement…
i=Math.floor(Math.random()*m--);
//Andswapitwiththecurrentelement.
t=array[m];
array[m]=array[i];
array[i]=t;
}
returnarray;
}
/**
*对数组进行平坦化处理，返回一个一维的新数组
*@paramtarget
*@returns{Array}
*/
functionflatten(target){
letresult=[];
target.forEach(function(item){
if(Array.isArray(item)){
result=result.concat(flatten(item));
}else{
result.push(item);
}
});
returnresult;
}
/**
*过滤属性中的null和undefined,但不影响原数组
*@paramtarget
*@returns{Array.|*}
*/
functioncompat(target){
returntarget.filter(function(el){
returnel!=null;
})
}
第四部分
根据指定条件对数组进行操作。
/**
*根据指定条件（如回调或对象的某个属性）进行分组，构成对象返回。
*@paramtarget
*@paramval
*@returns{{}}
*/
functiongroupBy(target,val){
varresult={};
variterator=isFunction(val)?val:function(obj){
returnobj[val];
};
target.forEach(function(value,index){
varkey=iterator(value,index);
(result[key]||(result[key]=[])).push(value);
});
returnresult;
}
functionisFunction(obj){
returnObject.prototype.toString.call(obj)==='[objectFunction]';
}
//例子
functioniterator(value){
if(value>10){
return'a';
}elseif(value>5){
return'b';
}
return'c';
}
vartarget=[6,2,3,4,5,65,7,6,8,7,65,4,34,7,8];
console.log(groupBy(target,iterator));
/**
*获取对象数组的每个元素的指定属性，组成数组返回
*@paramtarget
*@paramname
*@returns{Array}
*/
functionpluck(target,name){
letresult=[],prop;
target.forEach(function(item){
prop=item[name];
if(prop!=null){
result.push(prop);
}
});
returnresult;
}
/**
*根据指定条件进行排序，通常用于对象数组
*@paramtarget
*@paramfn
*@paramscope
*@returns{Array}
*/
functionsortBy(target,fn,scope){
letarray=target.map(function(item,index){
return{
el:item,
re:fn.call(scope,item,index)
};
}).sort(function(left,right){
leta=left.re,b=right.re;
returnab?1:0;
});
returnpluck(array,'el');
}
第五部分
数组的并集，交集和差集。
/**
*对两个数组取并集
*@paramtarget
*@paramarray
*@returns{Array}
*/
functionunion(target,array){
returnunique(target.concat(array));
}
/**
*ES6的并集
*@paramtarget
*@paramarray
*@returns{Array}
*/
functionunion1(target,array){
returnArray.from(newSet([...target,...array]));
}
/**
*对两个数组取交集
*@paramtarget
*@paramarray
*@returns{Array.|*}
*/
functionintersect(target,array){
returntarget.filter(function(n){
return~array.indexOf(n);
})
}
/**
*ES6交集
*@paramtarget
*@paramarray
*@returns{Array}
*/
functionintersect1(target,array){
array=newSet(array);
returnArray.from(newSet([...target].filter(value=>array.has(value))));
}
/**
*差集
*@paramtarget
*@paramarray
*@returns{ArrayBuffer|Blob|Array.|string}
*/
functiondiff(target,array){
varresult=target.slice();
for(vari=0;i!array.has(value))));
}
第六部分
数组包含指定目标。
/**
*判定数组是否包含指定目标
*@paramtarget
*@paramitem
*@returns{boolean}
*/
functioncontains(target,item){
returntarget.indexOf(item)>-1;
}
最后模拟一下数组中的pop,oush,shift和unshift的实现原理
const_slice=Array.prototype.slice;
Array.prototype.pop=function(){
returnthis.splice(this.length-1,1)[0];
};
Array.prototype.push=function(){
this.splice.apply(this,[this.length,0].concat(_slice.call(arguments)));
returnthis.length;
};
Array.prototype.shift=function(){
returnthis.splice(0,1)[0];
};
Array.prototype.unshift=function(){
this.splice.apply(this,
[0,0].concat(_slice.call(arguments)));
returnthis.length;
};
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！