数组的方法及重构

续 数组的方法

array.splice(start[, deleteCount[, item1[, item2[, …]]]]) 返回删除的元素构成的新数组，无引用关系

start指定修改的开始位置(从0开始)。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负数，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。

      var arr1=arr.splice(2,2,0,-1);
      var arr1=arr.splice();//返回一个空数组
      var arr1=arr.splice(0);//把数组中所有的元素删除，放在新数组中，清空原数组
      var arr1=arr.splice(1);//从下标为1清除到数组的尾部
      var arr1=arr.splice(-2);//从倒数第二项删除到尾部
      var arr1=arr.splice(1,2);//从第一位删除两个元素
      var arr1=arr.splice(-2,1);//从倒数第二项删除1个元素
      var arr1=arr.splice(-1,0,1);//在倒数第一位前插入一个1
      var arr1=arr.splice(0,0,-1);//在最前面插入一个-1
      console.log(arr1,arr);


splice()重构
function array_splice(arr,start,deleteCount){
    var arr1 = [];
      if(arr == undefined || arr.constructor !== Array) throw new Error("参数错误");
      if(start == undefined) return arr1;
      start = Number(start);
      if (isNaN(start)) start = 0;
      if(start<0) start+=arr.length<0 ? 0 ：start+arr.length;
      if(start>arr.length) start = arr.length;
      if (deleteCount === undefined) deleteCount = arr.length - start;
      deleteCount = Number(deleteCount);
      if (isNaN(deleteCount)) deleteCount = 0;
        if (deleteCount < 0) return arr1;
        if (deleteCount + start > arr.length) deleteCount = arr.length - start;
        for (var i = start; i < arr.length; i++) {
            if (i < deleteCount + start) arr1[arr1.length] = arr[i];
            arr[i] = arr[i + deleteCount];
        }
        arr.length -= deleteCount;
        var len = arguments.length - 3;
        var l = (arr.length += len);
        while (l > start) {
            if (l > start + len) arr[l - 1] = arr[l - len - 1];
            else arr[l - 1] = arguments[3 + (l - 1 - start)];
            l--;
        }
            return arr1;

        }
        var arr1 = array_splice(arr, 7, 0, -1, -2, -3);
        console.log(arr, arr1);
        var arr1 = array_splice(arr, 7, 0, -1, -2, -3);
        console.log(arr, arr1);

slice([start][end]) 方法将指定的起始位置到结束位置前的元素放在一个新数组中返回，这一对象是一个由 start 和 end 决定的原数组的浅拷贝（包括 start，不包括end）。原始数组不会被改变。

start 如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
如果省略 start，则 slice 从索引 0 开始。
如果 start 超出原数组的索引范围，则会返回空数组。

end 如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。
如果 end 被省略，则 slice 会一直提取到原数组末尾。
如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。

function array_slice(arr,start,end){
            var arr1=[];
            if(start===undefined || isNaN(start)) start=0;
            if(end===undefined || isNaN(end)) end=arr.length;
            start=parseInt(start);
            end=parseInt(end);
            if(start<0) start=(start+arr.length)<0 ? 0 : start+arr.length;
            if(end<0) end=(end+arr.length)<0 ? 0 : end+arr.length;
            for(var i=start;i<end;i++){
                arr1[arr1.length]=arr[i];
            }
            return arr1;
        }

        var arr=[1,2,3,4,5];

        var arr1= array_slice(arr,1,-7);
        var arr2=arr.slice(1,-7);
        console.log(arr1,arr2);

forEach和map

forEach() 方法对数组的每个元素执行一次给定的函数，返回值为undefined，需要注意的是forEach会自动跳过未初始化的值

    重构
    function array_forEach(arr,fn){
        for(var i=0;i<arr.length;i++){
            if(i in arr) fn(arr[i],i,arr);
        }
    }
    var arr=[2,4,6,8,10];
    array_forEach(arr,function(item,index,arr){
    console.log(item,index,arr);
    })

map() 方法创建一个新数组，其结果是个由原数组每个元素执行回调函数的结果组成的新数组

案例：   var arr=[
        {id:1001,name:"外星人电脑",info:"配置超高的PC电脑",price:35999,num:5},
        {id:1002,name:"苹果笔记本",info:"配置超高的笔记本",price:16990,num:3},
        {id:1003,name:"电竞椅",info:"人体工学电竞椅",price:26000,num:6},
        {id:1004,name:"电竞桌",info:"带超大显示器的桌子",price:13000,num:6},
    ]

    var arr1=arr.map(function(item){
        return {id:item.id,name:item.name,total:item.price*item.num};
    })
    console.log(arr1);

重构：function array_map(arr,fn){
        var arr1=[];
        for(var i=0;i<arr.length;i++){
            if(i in arr) arr1[i]=fn(arr[i],i,arr);
        }
        return arr1;
    }
    function fn1(item,index,arr){
        return item+10;
    }
    var arr=[2,4,6,8,10];
    var arr1=array_map(arr,fn1)
    console.log(arr1);

some 当元素中有一个满足回调函数中的条件，则返回true，并且不再继续遍历判断，否则返回false

every 当元素中有一个不满足回调函数的条件，则返回false，否则返回true

some 重构

function array_some(arr,fn){
    for(var i =0;i<arr.length;i++){
        if(i in arr && Boolean(fn(arr[i],i,arr))) return true;
    }
    return false;
}

every重构

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

reduce方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

          function array_reduce(arr,fn,initValue){
              if(arr.length===0) return;
              if(arr.length===1) return arr[0];
              var index=1;//后续判断从第几个开始循环，如果有初始值则从第0个开始循环，如果没有初始值从第一个开始循环
              var value=arr[0];
              if(initValue!==undefined){
                  index=0;
                  value=initValue;
                  // 如果初始值存在value就是初始值，如果不存在，初始值就是数组的第0项
              }
              for(;index<arr.length;index++){
                 value=fn(value,arr[index],index,arr);
              }
              return value;
          }

         var val=array_reduce(arr,function(value,item){
              console.log(value,item);
              return value+item;
          })
          console.log(val);
     var val=array_reduce(arr,function(value,item){
              console.log(value,item);
              return value+item;
          })
          console.log(val);