js数组方法

 		var arr=[1,3,5,0,7,2,4];
  
//push 方法表示向数组的尾部添加一个或者多个元素,并且返回数组的新长度
       var len=arr.push(1,2);   
        console.log(arr,len);//[1,3,5,0,7,2,4,1,2]    9
//unshift方法表示向数组的头部添加一个或者多个元素,并且返回数组的新长度
        var len=arr.unshift(1,2,3);
        console.log(arr);//[1,2,3,1,3,5,0,7,2,4,1,2]    12

//pop  删除数组尾部的一个元素,返回被删除的元素
        var item=arr.pop();
        console.log(item);// 2

        //将数组从尾部删除到最前面,并且打印每个删除的元素
        var item;
        while((item=arr.pop()) || item===0){
        //如果第一个条件item的值是0的话，就是false了，所有要第二个条件来防止数组中有0的情况
            console.log(item);
        }

//shift   删除数组头部的一个元素,返回被删除的元素
        arr.shift();//1

//splice  增删  给数组添加,删除或者替换元素,并且返回被删除的元素组成的新数组
        //arr.splice(从什么位置开始,删除几个元素,添加什么元素...可以有多个);

        //在第二位插入了一个10,原第二位向后挪动,因为没有删除元素,所以返回一个空数组
       var arr1=arr.splice(2,0,10);
       console.log(arr,arr1);//[2,3, 10,   1,3,5,0,7,2,4,1]   []
    //在第二位插入了一个10,11
       var arr1=arr.splice(2,0,10,11);//[2,3,10,11 10,   1,3,5,0,7,2,4,1] 
       console.log(arr,arr1);

            在尾部添加两个元素
            arr.splice(arr.length-1,0,10,11);
            如果插入位置超过了长度,就会插入在尾部
            arr.splice(arr.length+2,0,10,11);
            开始下标如果是负数,就是从后向前数
            arr.splice(-1,0,10,11);
            0就是在最头部插入内容
            arr.splice(0,0,10,11);
            console.log(arr);


        从倒数第1位向后删除,没有填写要删除的个数,意味删除到尾部
           var arr1=arr.splice(-1);
        从头删除到尾部,意味着将数组的元素挪到新数组中
           var arr1=arr.splice(0);
        从某个位置开始删除几个元素
        var arr1=arr.splice(2,1);
        var arr1=arr.splice(2,3);
        var arr1=arr.splice();//新建一个空数组
           console.log(arr1,arr);

            替换元素
        var arr1=arr.splice(1,1,-5);
        var arr1=arr.splice(1,2,-5,2);
        var arr1=arr.splice(1,1,-5,2);
        console.log(arr1,arr);

 var  arr=[1,2,3,4];
 //concat   将当前数组与多个元素或者多个数组连接形成新数组,原数组不变,返回新数组
        var arr1=arr.concat(5,6,7);
        var arr1=arr.concat([5,6,7]);
        var arr1=arr.concat([5,6,7],[8,9,10]);
        console.log(arr1,arr);

        //复制原数组称为新数组
        var arr1=arr.concat();
        
        
 //join   var arr=[1,2,3,4,5];
        var str=arr.join("#");//以某个符号连接数组的元素,形成字符串
        var str=arr.join();//默认使用逗号连接数组元素,形成字符串
        var str=arr.join("");//使用空字符连接将会形成元素紧密连接的字符串
        console.log(str);
        
        var arr=[1,2,3,4,5,6];
//slice  将数组从第一个参数开始到第二个参数结束之前的内容截取  形成一个新数组返回,返回的是截取的内容，原数组不变
        var arr1=arr.slice(1,3);
        var arr1=arr.slice();//如果没有任何参数就会从头截取到尾部
        var arr1=arr.slice(1);//如果第二个参数没有,就会从开始截取到尾部
        var arr1=arr.slice(-3,-1);//如果是负数就会从后向前数,然后再截取
        将参数转换为正向数值时,前面的必须小于后面
        var arr1=arr.slice(-3,5);
        console.log(arr1,arr);
        
        
 //reserve   倒序  修改原数组
 //delete 删除数组中的元素时,会造成数组不能紧密结构
 //forEach  和map  是桥接模式
 
//forEach   遍历数组,回调函数中有三个参数,每个元素,下标,原数组
        遍历一个元素,就执行该函数一次   如果元素是undefined   跳过
        forEach只能遍历数组,不能返回
        arr.forEach(function(item,index,array){
            console.log(item,index,array);
        })
        
         console.log(arr); //[3, 4, empty, 5, 6, 7]
//map   遍历数组,并且使用return返回新元素到新数组中
      //新数组的长度与原数组的长度相同,如果没有使用return,就会返回默认的undefined
       var arr1=arr.map(function(item,index,array){
            // console.log(item,index,array);
            return item+1;
        });

        console.log(arr1);//[4, 5, empty, 6, 7, 8]

//indexOf   ES6方法
        var arr=[1,2,3,4,5,6];
        查找某个元素的下标
        var index=arr.indexOf(4);//3
        var index=arr.indexOf(7);//-1
        console.log(index);//如果是-1就是没有找到,正数就是下标
         
         //indexOf(要查找的元素,从哪个下标开始向后查找包括该下标)  两个参数
         //可以找出数组中元素的所有位置
         var arr=[1,2,3,4,2,1,3,4,2,1,5,7,8,2,3,4,5,1];
        var index=arr.indexOf(2);
        while(index>-1){
            console.log(index);
            index=arr.indexOf(2,index+1)
        }
        
        //利用indexOf  数组去重
        var arr=[1,2,3,4,2,1,3,4,2,1,5,7,8,2,3,4,5,1];
        var arr1=[];
        for(var i=0;i<arr.length;i++){
            if(arr1.indexOf(arr[i])<0) arr1.push(arr[i]);
        }
        console.log(arr1);

//some 返回布尔值,判断元素中是否有满足回调函数中的条件,如果有就返回true,否则返回false
        var bool=arr.some(function(item,index,arr){
            return item>2;
        });
        console.log(bool)
        
        
//every 如果遍历数组后有一个不满足回调函数的条件,就跳出返回false,否则返回ture;
    var bool=arr.every(function(item,index,arr){
        return item>2;
    })
    
// 如果使用forEach,map这类方法时,里面的this将会被重定向为window

      var arr = [1, 2, 3, 4, 5, 6, 7];
//filter  筛选
        var arr1=arr.filter(function(item,index,arr){
            return item%2===0;
        });
        console.log(arr1);
        
        
       // 重构：
       functon filter1(array, fn) {
            var arr = [];
            for (var i = 0; i < array.length; i++) {
                if (array[i] === undefined) continue;
                if(fn(array[i], i, array))arr.push(array[i]);
            }
            return arr;
        }

// 归并
        var arr = [2,6,1,7,3,5,9];
        //arr.reduce(回调函数(归并值,数组元素,索引值,数组),归并初始值), 如果没有给归并初始值,value归并值就是数组的第0项,然后从第一项开始遍历, 如果给了归并初始值,value就是这个归并初始值,然后从第0项开始遍历
        var s=arr.reduce(function(value,item,index,arr){
            console.log(value,item);
            return value+item;
        });
        console.log(s);
        
// 用于对象型数组求条件的对象的和值
        var sum=arr.reduce(function(value,item){
            if(item.selected) return value+item.price*item.num;
            return value;
        },0);
        console.log(sum);

        console.log(0.1+0.2===0.3);
        
 // 用于筛选
        var item=arr.reduce(function(value,item){
            if(item.id===10003) return item;
            return value;
        },null);
        console.log(item);


// 扁平化数组  flatMap
        var arr = [2,[6,1,7],17,[3,5,9],[11,12,[15,16]]];
     //ES7
       var arr1=arr.flatMap(function(item,index){
            return item;
        });
        console.log(arr1);