数组的各种方法

数组的创建方法

//数组创建方法 js弱语言arr里可以任意类型导致效率下降

    var arr=[1,2,2,3,4,5,null,"0",6];
    console.log(arr["0"]);
    console.log(arr["1"]);
    //从0开始的数据顺序，下标，相当于object当中的key，object{key:value}
    //arr["0"]  下标变量  对应的1为值 也称为元素
    var obj={0:1};
    console.log(obj);    
    //数组与对象区别，数组key隐式转换为数值作为下标变量，对象为字符串
    //空打印为empty,undefined为Undefined
    var arr1=[1,2,2,3,,5,6],
    arr2=[1,2,2,3,null,5,6],
    arr3=[1,2,2,3,undefined,5,6];
    console.log(arr1,arr2,arr3);
    var arr=[];
    var  arr2=new Array(1,2,3);//构造函数创建实例化对象
    var  arr1=Array(1,2,3);//构造函数返回实例化对象
    //使用构造函数创建实例化数组时如果构造函数中有且仅有一个参数并且为正整数时，
    //该数值表示数组长度并根据这个长度开辟数组空间且每个元素都为空；
    var arr3=new Array(3);//参数为小数和负数会报错，参数为非数值型会作为第零个元素添加；
    x=arr3.push(4);
    console.log(arr3);
    //
    var arr=new Object([1,2,3,4]);//通过对象创建数组一般不用
    //length 数组的长度，数组元素的个数；数组的length是一个可读可写属性，只能赋值正整数
    //当给数组中添加或删除元素时，length会自动改变；

数组的添加删除

数组的添加删除有许多方法，如push,pop,shift,unshift等 下面介绍这些方法及部分方法重构实现：
//数组的添加删除，push,pop,shift unshift

    var  arr=[1,2,3,4,56,7]
    arr.push(7);//在数组末添加一个或多个元素并且返回这个数组的新长度并返回新的length
    a=arr.push(1,2,3);
    arr.push();
    a=arr.push;//添加元素为空时不添加返回数组长度
    console.log(arr);
    //重构push:
    function push(arr){
        if(arguments.length===1) return arguments.length;
        for(var i=1;i<arguments.length;i++){
            arr[arr.length]=arguments[i]
        }
        return arr.length;
    }
    var len=push(arr,1,2,3);
    console.log(arr,len)
    //pop删除数组尾部的元素并返回被删除的元素,重构pop
    arr.pop()
    //unshift添加元素在数组前面 效率很低,重构unshift
    //shift 删除数组的头部一个元素，并且返回被删除的元素,重构shift

splice方法实现

splice方法通过确定元素，下标等参数完成删除元素并返回新数组操作，同时原数组不变

// var arr=[1,2,3,4,5,6];
// var arr1=arr.splice();//创建一个新数组，从下标是多少开始，删除几个元素？，添加多个元素？ 返回被删除元素组成的新数组
// var arr1=arr.splice(3);//从下标为三开始删除到数组尾部并将删除元素放在新数组中返回、
// var arr1=arr.splice(-1);//负数表示从倒数第一位删除到尾部；
// var arr1=arr.splice(3,1);//从下标3开始删除一位元素并返回被删除的元素组成新数组
// var arr1=arr.splice(-3,1);//从后往前数第三位开始删除一位元素并返回被删除的元素组成新数组
// var arr1=arr.splice(0,0,0);//在数组头部添加一个数值0，返回一个空数组；
// var arr1=arr.splice(2,1,10);//从下标为2的位置删除1个元素 并且替换为10，返回被删除的
// splice(2,0,10,11)//从下标为2开始插入数值10，11并且返回一个空数组

every,some,fliter,reduce方法实现

every方法像逻辑与一样每一次循环return返回值为真才会返回ture,否则为false,some方法为逻辑或，reduce实现了value值的累加同时也可作为高阶函数处理其他问题，而fliter则将满足条件的元素全部取出放置在一个新数组中；
// every some filter reduce flapMap
// every 判断回调函数返回的布尔值，如果是false，返回为false
// 判断数组中每个元素是否都满足条件

    // some 判断数组中是否有元素满足条件
    // var arr=[2,4,6,8,10];
//    var bool=arr.every(function(item,index,arr){
//         return item>3;
//     });
    // var bool=arr.some(function(item,index,arr){
    //     return item>3;
    // });
    // console.log(bool);



//     function every(arr,fn){
//         for(var i=0;i<arr.length;i++){
//             if(!(i in arr))continue;
//             // var b=fn(arr[i],i,arr);
//             // if(!b) return false;
//             if(!fn(arr[i],i,arr)) return false;
//         }
//         return true;
//     }

//    var bool=every(arr,function(item,index,arr){
//         return item>3;
//     })


    // function some(arr,fn){
    //     for(var i=0;i<arr.length;i++){
    //         if(!(i in arr))continue;
    //         if(fn(arr[i],i,arr)) return true;
    //     }
    //     return false;
    // }
    


    // var arr=[2,4,6,8,10];

    // var  arr1=arr.filter(function(item,index,arr){
    //     return item>3;
    // })
    // console.log(arr1);


//     function filter(arr,fn){
//         var arr1=[];
//         for(var i=0;i<arr.length;i++){
//             if(!(i in arr))continue;
//             if(fn(arr[i],i,arr)) arr1[arr1.length]=arr[i];
//         }
//         return arr1;
//     }


//    var arr1=filter(arr,function(item,index,arr){
//         return item>3;
//     });
//     console.log(arr1);



var arr=[2,4,6,8,10];
// 如果没有初始值
// 第一次遍历时，value是数组的第0项，item从下标为1开始遍历
// 从第二次遍历开始value就是上一次使用return返回的值


    // 如果有初始值时
    // 第一次遍历 value就是初始值，item从下标为0开始遍历

// 归并
//   var item=arr.reduce(function(value,item,index,arr){
//       console.log(value,item,index);
//     //    return value+=item;
//        return value+item;
//   },100);
//   console.log(item);

// function reduce(arr,fn,initValue){
// if(arr.length=0) return;
// var i=0;
// if(initValue=undefined){
// initValue=arr[0];
// i=1;
// }
// for(;i<arr.length;i++){
// if(!(i in arr))continue;
// initValue=fn(initValue,arr[i],i,arr);
// }
// return initValue;
// }

// var value=reduce(arr,function(value,item,index){
// console.log(value,item);
// return value+item;
// },100);
// console.log(value);

//flatmap进行扁平化数组，限制二维数组
//   var arr=[[1,2,[0,3]],[4,5,6],[7,8,9]];
//   扁平化数组
//   var arr1=arr.flatMap(function(item,index,arr){
//          return item;
//   });
//   console.log(arr1);