数组的API和部分API的重构
1、push: //可以在数组的尾部添加若干个元素,返回值为新数组的长度
var arr=[1];
var len=arr.push(5,6,7,8);
console.log(len);
//循环给尾部添加若干个元素
while(arr.push({})<10);
arr[0].a=10;
console.log(arr);
//重构!
function push(arr){
for(var i=1;i<arguments.length;i++){
arr[arr.length]=arguments[i];
}
return arr.length;
}
var arr=[];
var len=push(arr,1,2,3);
console.log(len,arr);
2、pop: //删除数组尾部的最后一个元素,并且将删除的元素返回
var element=arr.pop();
console.log(element,arr);
while(arr.pop()!==3);//删除到某元素为止
console.log(arr);
//如果数组中存储的是对象,我们必须将所有的对象引用全部设为null(引用关系)
while(arr.length>0){
arr[arr.length-1]=null;
arr.pop();
}
有种效率更高的方法
for(var i=0;i<arr.length;i++){
arr[i]=null;
}
arr.length=0;
//重构!
function pop(arr){
var elem=arr[arr.length-1];
if(arr.length>0)arr.length--;
return elem;
}
3、unshift //在数组的头部添加若干个元素,并且返回这个数组的新长度
var len=arr.unshift(5,6)
//重构!方案1
function unshift(arr){
var len=arguments.length-1;
for(var i=arr.length-1;i>=0;i--){
arr[i+len]=arr[i];
arr[i]=null;
}
for(var j=1;j<arguments.length;j++){
arr[j-1]=arguments[j];
}
return arr.length;
}
//方案2
function unshift(arr){
var arr1=[];
for(var i=0;i<arr.length;i++){
arr1[i]=arr[i];
}
arr.length=0;
for(var j=1;j<arguments.length;j++){
arr[j-1]=arguments[j];
}
for(var k=0;k<arr1.length;k++){
arr[arr.length]=arr1[k];
}
return arr.length;
}
4、shift //将数组的头部一个元素删除,并且返回这个元素
var elem=arr.shift();
//重构!
function shift(arr){
var elem=arr[0];
for(var i=1;i<arr.length;i++){
arr[i-1]=arr[i];
}
if(arr.length>0)arr.length--;
return elem;
}
//unshift和shift两个方法很少使用,因为从头增加删除元素会导致整个数组向前或向后,时间复杂度较高
//这四种方法,操作后原数组的引用关系不变
5、join //使用某个字符作为连接符,将所有数组的元素链接成为一个字符串并且返回这个字符串,如果没有连接符,则默认逗号链接
var str=arr.join("*");
console.log(str);
//重构!
function join(arr.separator){
if(separator==undefined) separator=",";
separator=String(separator);
var str="";
for(var i=0;i<arr.length;i++){
if(i!==arr.length-1) str+=arr[i]+separator;
else str+=arr[i];
}
return str;
}
6、concat //连接数组
//数组连接若干个数组或者元素,返回一个新的连接完成的数组,与原数组无引用关系
var arr=[1,2,3,4];
arr.concat([5,6,7],[8,9]);
//重构!
function concat(arr){
var arr1=[];
for(var i=0;i<arr.length;i++){
arr1[i]=arr[i];
}
if(arguments.length===1) return arr1;
for(var j=1;j<arguments.length;j++){
if(arguments[j]!==null && arguments[j].constructor===Array){
for(var k=0;k<arguments[j].length;k++){
arr1[arr1.length]=arguments[j][k];
}
}else{
arr1[arr1.length]=arguments[j];
}
}
return arr1;
}
var arr=[3,4,5];
var arr1=concat(arr,"");
console.log(arr1);
7、splice //将数组中从第几位(下标)开始删除的多少元素,并且返回被删除的元素组成的新数组
//将数组中从第几个位开始删除多少个元素后,并在该位置插入新的若干元素,返回删除元素组成的新数组
//在数组的第几位开始插入若干个元素,并且返回控的新数组
var arr=[1,2,3,4]
var arr1=arr.splice(1,2);//arr为[1,4],arr1为[2,3];
var arr1=arr.splice(1);//删除到尾部
var arr1=arr.splice(-1);//如果第一个参数是负数,则从后向前开始删除;(删除了一个)
var arr1=arr.splice(0);//将一个数组的所有元素转移到另一个数组
var arr1=arr.splice();//没有删除返回新数组
var arr1=arr.splice(-3,2);//从倒数第3个元素向后删除2个元素
var arr1=arr.splice(1,2,-2,-3);//从第1位开始向后删除两个元素,并且在该位置添加-2,-3,返回被删除两个元素组成的数组。
var arr1=arr.splice(1,arr.length,0,-1,-2);//从第1个元素开始删除到数组尾部,并且添加0,-1,-2
var arr1=arr.splice(1,0,0);//在第1位插入一个元素0,不删除,返回空数组
//splice这个方法实现需要耗费大量时间
var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];
var len=arr.length;
for(var i=0;i<len;){
if(arr[i]===3) arr.splice(i,1);
else i++;
}
//去重
var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];
var arr1=[];
for(var i=0;i<arr.length;i++){
var bool=false;
for(var j=0;j<arr1.length;j++){
if(arr[i]===arr1[j]){
bool=true;
break;
}
}
if(!bool) arr1.push(arr[i]);
}
arr.length=0;
for(var k=0;k<arr1.length;k++){
arr[k]=arr1[k];
}
arr1.length=0;
arr1=null;
console.log(arr);
8、slice //从第几项开始到第几项结束复制这些元素到新数组中,原数组不变
var arr=[1,2,3,4];
var arr1=arr.slice();//复制原数组到新数组,没有引用关系
//将列表转换为数组的3个方法,要记住!!
var divs=document.getElementsByTagName("div");//获取body里所有的div
第一种: var arr=Array.prototype.slice.call(divs);
var arr=[].slice.call(divs);
第二种: var arr=Array.from(divs);//ES6
第三种: var arr=Array.prototype.concat.apply([],divs);
var arr=[].concat.apply([],divs);
var arr1=arr.slice(2);//从第2(下标)开始复制
var arr1=arr.slice(0);//复制数组
var arr1=arr.slice();//复制数组
var arr1=arr.slice(-2);//从后向前数第2个元素到尾部的所有元素复制
var arr1=arr.slice(1,2);//从第一项复制到第二项,不包括结束这一项
//重构!(有BUG)
function slice(arr,start,end){
if(start===undefined) start=0;
if(end===undefined) end=arr.length;
start=Number(start);
end=Number(end);
if(!isNaN(end) && isNaN(start)) start=0;
if(isNaN(start)) return [];
if(start<0) start=arr.length+start;
if(end<0) end=arr.length+end;
var arr1=[];
for(var i=start;i<end;i++){
arr1[i-start]=arr[i];
}
return arr1;
}
9、reverse //当前数组按照倒装顺序将原数组颠倒,并且返回原数组
var arr=[2,3,4,5];
var arr1=arr.reverse();
//重构!方案1
function reverse(arr){
var len=parseInt(arr.length/2);
for(var i=0;i<len;i++){
var temp=arr[i];
arr[i]=arr[arr.length-i-1];
arr[arr.length-i-1]=temp;
}
return arr;
}
//方案2
function reverse(arr){
var arr1=[];
for(var i=0;i<arr.length;i++){
if(i in arr){
arr1[i]=arr[i];
}
}
arr.length=0;
for(var j=arr1.length-1;j>=0;j--){
if(j in arr1){
arr[arr1.length-j-1]=arr1[j];
}
}
return arr;
}