数组方法

数组的方法

1.push(); 方法：在数组的最后面添加内容，返回值是添加后数组的长度

var arr=[1,2,3];
console.log(arr.push(5));

2.pop() 方法：删除数组的尾部元素，并且返回这个被删除的元素

3.unshift() 方法：将一个或者多个新元素添加在数组的最前面，返回数组的新长度

4.shift() 方法：删除数组的第一个元素，并且返回该元素

5.concat() 方法：复制，复制后给新数组添加新元素，多个数组连接形成数组；拼接数组

封装concat

function concat(arr){
            var array=[];
            var index=0;
            for(var i=0;i<arr.length;i++,index++){
                array[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++){
                        array[index]=arguments[j][k];
                    }
                    index--;
                }else{
                    array[index]=arguments[j];
                }
            }
            return array;
        }

6.join() 方法：
1.转换为字符串，使用参数进行分隔。
2.把数组中的每一项用特定的字符串连接起来

7.slice(a,b) 方法： 从索引a开始截取（包括a），一直截取到b（不包括b），如果里面只有一个参数，，那么就直接截取到末尾，不会改变原来的数组
例子：

 	var arr = [1,2,3,4,5];    
 	var a = arr.slice(-8,3);  =>等同于：arr.slice(0,3)   //如果第一个参数是负数，就用数组的长度跟这个负数相加，如果相加后的数字小于等于0，就表示从索引0开始截取，如果大于0，就表示从相加之后的那个数字索引开始截取   
 	console.log(a);   //[1,2,3]   从索引0开始截取  
 
 	var b = slice(-4,3);   =>等同于：arr.slice(1,3)         
 	console.log(b);  //[2,3]     从索引1开始截取    
 
 	var c = arr.slice(1,-2);  =>等同于：arr.slice(1,3)   //如果第二个参数是负数的话，就用数组的长度跟第二个参数相加，表示截取到相加之后的那个数字索引    
 	console.log(c);   //[2,3]  
    
 	var d = arr.slice(-4,-2);  =>等同于：arr.slice(1,3)  //如果两个参数都是负数的话，就结合上面两种情况   
 	console.log(d);   //[2,3]

封装slice

function slice(arr,start,end){
            start=Number(start);
            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 a=[];
            for(var i=start,j=0;i<end;i++,j++){
                a[j]=arr[i];
            }
            return a;
        }
        var arr1=slice(arr,2,-1);
        console.log(arr1,arr); 

8.splice(a,b,c); 方法：从索引a开始截取b个元素，并用c替换截取的元素，并改变原来的数组，如果只有一个参数，表示从这个索引开始截取到末尾

splice(a,b) 方法里面如果第一个参数为负数的话，使用方法跟slice() 方法一样，如果第二个参数为负数的话，表示截取的是一个空数组
例子：

arr.splice(从什么位置开始,删除多少个元素,添加的元素...(可以有多个));

var arr1=arr.splice();//创建一个空数组

var arr1=arr.splice(0);//将数组的所有元素传递给新数组

// 负数指从后向前数
 var arr1=arr.splice(-2);//从数组的倒数第二位开始截取到尾部

var arr1=arr.splice(2,2);//从第二位开始删除2个元素

 var arr1=arr.splice(2,0,12,14);//插入元素13，14，插入在第二位

var arr1=arr.splice(2,2,12,14);//替换元素，删除两位并且插入12，14
 console.log(arr1,arr);

封装splice

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;
        }
       var arr1=splice(arr,-2,2,10,11,12);
       console.log(arr1,arr);

9.sort(function (a,b){return a-b}); 数组排序方法

10.reverse(); 方法：倒序，不排序，原数组改变，返回原数组；是数组翻转方法

封装reverse

	function reverse(arr){
            var len=parseInt(arr.length/2);
            for(var i=0;i<len;i++){
                // arr[arr.length-1-i]=arr[i];
                var temp=arr[arr.length-1-i];
                arr[arr.length-1-i]=arr[i];
                arr[i]=temp;
            }
            return arr;
        }
        reverse(arr);
        console.log(arr);

11.forEach(function (ele,index){console.log(ele,index)}); 方法：遍历数组，传入一个回调函数，里面有三个参数，第一个是元素值，第二个是索引，第三个是数组
例子：

	var arr=[2,4,6,8,10,12,14,16,18,20];
     function forEach(arr,fn){
            for(var i=0;i<arr.length;i++){
                if(arr[i]===undefined) continue;
                fn(arr[i],i,arr);
            }
        }
        // 桥接模式
        forEach(arr,function(item,index,a){
            console.log(item,index,a);
        })

12.every(function (ele){return ele > 20}); 传入一个回调函数，返回值是boolean类型值
例子：

var arr = [1,2,3,4,5]; 
var a = arr.every(function (ele){ return ele > 3});  
console.log(a);   //false     数组里只要有一个数字小于3就返回false

13.map(function (ele){return ele + 10}); 或 map(Math.sprt); 让数组中的每一个元素按照函数的方法去执行，返回一个新的数组

14.filter(functoon (ele){return ele < 50}); 起到过滤作用， 让数组中的每一个元素按照函数的方法去执行，把符合条件的元素放到一个新的数组中返回
例子：

 		var arr=[1,2,3,4,5,6,7];
        function filter(arr,fn){
            var a=[];
            for(var i=0;i<arr.length;i++){
                if(fn(arr[i],i,arr)) a[a.length]=arr[i];
            }
            return a;
        }
    
       var arr1=filter(arr,function(item){
            return item>4
        });
        console.log(arr1);

//结果为：[5, 6, 7]

15.eval(arr.join(’+’)); 如果数组中的每一项都是数字的话，用这个方法可以求数组中的数字之和
例子：

var arr = [1,2,3,4,5];    
var a = eval(arr.join('+'));    
console.log(a);    //15