数组部分方法重构（push，pop，shift，unshift等）

重构数组简单方法

数组方法我们平时用的非常多，这里我们来重构一下几种简单的方法，直接上代码

**1、push()

给数组尾部添加一个或多个元素，返回数组新长度，改变原数组**

var  arr=[1,2,3,4];
function push(arr){
	for(var i=1;i<arguments.length;i++){
		//将传进来的参数集挨个添加至数组尾部
		arr[arr.length]=arguments[i];
	}
	return arr.length;
}
var len=push(arr,5,6);
console.log(arr,len);//[1,2,3,4,5,6]    长度6

**2、pop()

删除数组最后一个元素，返回被删除的元素，改变原数组**

var arr=[1,2,3,4];
function pop(arr){
	//将尾部元素存起来
	var item=arr[arr.length-1];
	//让数组长度-1
	arr.length--;
	return item;
}
console.log(arr,pop(arr));//[1,2,3]   元素4

**3、unshift()

给数组最前面添加一个或多个元素，返回数组新长度，改变原数组**

var arr=[3,4,5,6];
function unshift(arr){
	//给个变量确定传进来多少个需要添加的元素
	var len=arguments.length-1;
	//循环数组，需要添加多少个元素，就将数组向后移几位
	for(var i=arr.length-1;i>=0;i--){
		arr[i+len]=arr[i];
	}
	for(var j=1;j<arguments.length;j++){
			//循环参数集，从数组第0项开始将每个元素添加
			arr[j-1]=arguments[j];
		}
	return arr.length;
}
console.log(unshift(arr,1,2),arr);//长度6  [1,2,3,4,5,6]

**4、shift()

删除数组的第一个元素，返回被删除的元素，改变原数组**

var arr=[1,2,3,4];
function shift(arr){
	//将第一个元素存起来
	var item=arr[0];
	//循环将元素都向前移一位
	for(var i=0;i<arr.length;i++){
		arr[i]=arr[i+1];
	}
	//数组长度-1
	arr.length--;
	return item;
}
console.log(shift(arr),arr);//元素1  [2,3,4]

**5、concat()

连接两个或多个数组，或者连接数组与元素，返回连接后的数组，不改变原数组**

var arr=[1,2,3,4];
function concat(arr){
	//给个新数组，将连接的数据挨个添加至数组
	var arr1=[];
	var index=0;
	for(var i=0;i<arr.length;i++,index++){
		//首先将给进来的数组添加至新数组
		arr1[index]=arr[i];
	}
	//连接传进来的数组或者元素
	for(var j=1;j<arguments.length;j++,index++){
		//判断传进来的是不是数组，如果是，继续循环将每一项添加
		if(arguments[j].constructor===Array){
			for(var k=0;k<arguments[j].length;k++,index++){
				arr1[index]=arguments[j][k];
			}
			index--;
		}else{
			arr1[index]=arguments[j];
		}
	}
	return arr1;
}
console.log(concat(arr,[5,6],7,[8,9]),arr);//[1,2,3,4,5,6,7,8,9]  [1,2,3,4]

这里使用push方法会简单点

var arr=[1,2,3,4];
function concat(arr){
	var arr1=[];
	for(var i=0;i<arr.length;i++){
		arr1.push(arr[i]);
	}
	for(var j=1;j<arguments.length;j++){
		if(arguments[j].constructor===Array){
			for(var k=0;k<arguments[j].length;k++){
				arr1.push(arguments[j][k]);
			}
		}else{
			arr1.push(arguments[j]);
		}
	}
	return arr1;
}
console.log(concat(arr,[5,6],7,[8,9]),arr);//[1,2,3,4,5,6,7,8,9]  [1,2,3,4]

**6、join()

数组转字符串，把数组的所有元素放入一个字符串，通过指定的分隔符进行分隔，默认使用逗号作为分隔符**

var arr=[1,2,3,4];
function join(arr,type){
	//判断type是否为undefined，是就默认为","
	var type=type ? type : ",";
	var str="";
	for(var i=0;i<arr.length-1;i++){
		//将数组转字符串已指定分隔符连接至倒数第二项
		//如果连接至最后一项会多出一个分隔符
		str+=arr[i]+type;
	}
	//加上最后一项元素
	str+=arr[arr.length-1];
	return str;
}
console.log(join(arr));//1,2,3,4
console.log(join(arr,"."));//1.2.3.4

**7、slice()

截取数组，并返回截取的新数组，不会改变原数组**

var arr=[1,2,3,4];
function slice(arr,start,end){
	//将参数转换为数值
	var start=Number(start);
	var end=Number(end);
	//判断参数是够为数值类型
	if(isNaN(start)) start=0;
	if(isNaN(end)) end=arr.length;
	//判断是否为负数，是就转换成正数
	if(start<0) start=start+arr.length;
	if(end<0) end=end+arr.length;
	var arr1=[];
	for(var i=start,j=0;i<end;i++,j++){
		arr1[j]=arr[i];
	}
	return arr1;
}
console.log(slice(arr,1,3),arr)//[2,3]  [1,2,3,4]

8、splice()

给数组中插入，删除，替换一个或多个元素，返回删除的元素组成的数组，改变原数组。

var arr=[1,2,3,4];
function splice(arr,start,count){
            var a=[];
            start=Number(start);
            count=Number(count);
            if(isNaN(start)) return a;
            if(start<0) start+=arr.length;
            if(isNaN(count)) count=arr.length-start;
            for(var i=start,j=0;i<arr.length;i++,j++){
                if(j<count)a.push(arr[i]);
                arr[i]=arr[i+count];
            }
            for(var l=0;l<arguments.length-3;l++){
                for(var m=arr.length-1;m>=start+l;m--){
                    arr[m+1]=arr[m];
                }
            }
            for(var n=3;n<arguments.length;n++){
                arr[start+n-3]=arguments[n];
            }
            for(var k=0;k<count;k++){
                arr.length--;
            }
            return a;
        }
console.log(splice(arr,1,2,5,6),arr);//[2,3]  [1,5,6,4]        

**9、forEach()

遍历数组，没有返回结果，无法阻止在循环中跳出**

var arr=[1,2,3,4];
function forEach(arr,fn){
	for(var i=0;i<arr.length;i++){
		//forEach不遍历空元素
		if(arr[i]===undefined) continue;
		fn(arr[i],i,arr);
	}
}
var res=forEach(arr,function(item,index,arr){
	console.log(item,index,arr);
})
console.log(res);//undefined  没有返回结果

**10、map()

遍历数组，返回与遍历数组相同长度的新数组，回调函数中return决定新数组的元素内容**

var arr=[1,2,3,4];
function map(arr,fn){
	var arr1=[];
	for(var i=0;i<arr.length;i++){
		//forEach不遍历空元素
		if(arr[i]===undefined) continue;
		arr1[i]=fn(arr[i],i,arr);
	}
	return arr1;
}
var arr1=map(arr,function(item,index,arr){
	return item+100;
})
console.log(arr1);//[101,102,103,104]

**11、some()

遍历数组，判断是否满足条件，有一个满足条件则返回true，直接跳出遍历，否则返回false**

var arr=[1,2,3,4,11]
function some(arr,fn){
     for(var i=0;i<arr.length;i++){
         if(arr[i]===undefined) continue;
         if(fn(arr[i],i,arr)) return true;
     }
     return false;
}
var bool=some(arr,function(item){
     return item>10;
})
console.log(bool);//true

**12、every()

遍历数组，判断是否满足条件，全部满足条件则返回true，有一个不满足返回false，直接跳出遍历**

var arr=[1,2,3,4,11]
function every(arr,fn){
     for(var i=0;i<arr.length;i++){
         if(arr[i]===undefined) continue;
         if(!fn(arr[i],i,arr)) return false;
     }
     return true;
}
var bool=every(arr,function(item){
     return item>10;
})
console.log(bool);//false