JS重构数组方法（包括reduce重构数组方法）

//  push：向数组尾部添加一个或多个元素，并且返回数组长度，在原数组中操作

function arrayPush(array){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i = 1; i<arguments.length-1; i++ ){
        array[array.length] = arguments[i];
    }
    return array.length;
}

//  pop：删除数组尾部的最后一个元素，并且返回删除元素的值，在原数组中操组。

function arrayPop(array){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    if(array.length == 0)  return;
    var value = array[array.length-1];
    array.length--;
    return value;
}

//   shift：删除数组开头的第一个元素，并返回删除元素的值，在原数组中操作

function arrayShift(array){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    if(array.length === 0) return;
    var value = array[0];
    for(var i =0; i<array.length-1; i++){
        array[i] = array[i+1]；
    }
    array.length--;
    return value;
}

 //  unshift：在数组开头插入一个或多个元素，然后返回数组的长度，在原数组中操作

function arrayUnshift(array){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i = array.length-1 + arguments.length-1; i>=0; i++){
        if(i-(arguments.length-1) >=0 )  array[i] = array[i-(arguments.length-1)];
        else array[i] = arguments[i+1];
    }
    retrun array.length;
}

//  concat：连接两个新元素或者是数组，并返回一个数组，原数组不变

function  arrayConcat(array){
    if(!array || array.constrcutor !== Array) throw new TypeError("请输入一个正确的数组！");
    var arr = [];
    for(var i = 0; i<arguments.length; i++){
        if(arguments[i] && arguments[i].constructor === Array){
            for(var j = 0; j<arguments[i].length;j++){
                if( j in arguments[i])  arr[arr.length] = arguments[i][j];
                else  arr.length++;
            }
        }else arr[arr.length] = arguments[i];
    }
    return  arr;
}

 //  join：将数组的每个元素用一个字符连接，默认为","，原数组不变，直接返回字符串

function arrayJoin(array,separator){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    if(separator == undefinded)  separator = ",";
    if(array.length == 0) return;
    var str = "";
    for(var i =0; i<array.length; i++){
        str+=array[i]+separator;
    }
    return str + array[array.length-1];
}

 //  slice：获取从数组指定位置到结束位置的内容，返回元素构成新数组，原数组不变

function arraySlice(array,start,end){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    if(array.length == 0) return [];
    if(start === undefined) start = 0;
    if(end === undefined) end= array.length;
    start=~~(start);
    end=~~(end);
    if(start<0) start = (start + array.length < 0 ? 0 : start + array.length);
    if(end<0) end= (end+ array.length < 0 ? 0 : end+ array.length);
    if(end>array.length) end = array.length;
    var arr = []; 
    for(var i = start; i<end; i++){
        arr[arr.length] = array[i];
    }
    return arr;
}

//  splice：插入、删除、替换数组中的元素，并且返回被删除的元素组成的新数组，原数组发生改变 

function arraySplice(array, start, countDelete) {
    if (!array || array.constructor !== Array) throw new TypeError("请给入正确的数组");
    if (start === undefined) return [];
    start = ~~start;
    if (start < 0) start = (array.length + start < 0 ? 0 : array.length + start);
    if (countDelete === undefined) countDelete = array.length - start;
    countDelete = ~~countDelete;
    if (countDelete < 0) countDelete = 0;
    var delArr = [];
    var len = start + countDelete;
    if (start + countDelete > array.length) len = array.length;
    for (var i = start; i < array.length; i++) {
        if (i < len) delArr[delArr.length] = array[i];
            array[i] = array[i + countDelete];
    }
    array.length -= len - start;
    if (arguments.length <= 3) return delArr;
    en = arguments.length - 3;
    for (var i = array.length + len - 1; i >= start; i--) {
        if (i >= start + len) array[i] = array[i - len]
        else array[i] = arguments[arguments.length - len + (i - start)]
    }
    return delArr;
}

 //  every：如果比较比较的每一个元素都满足条件就返回ture，有一个不满足就返回-1

function arrayEvery(array,fn){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i =0; i<array.length; i++){
        if(i in array && fn(array[i],i,array)) return false;
    }
    return true;
}


var bool = arrayEvery(array, function(item,index,arr){
    return item > 2;
})

 使用reduce重构

 var bool = arr.reduce(function(v,t){
    if(t<2) v=false;
    return v;
},true)

//  some：循环数组判断数组中每一个是否满足条件，如果有一个满足条件的直接返回true

function arraySome(array){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i = 0; i<array.length; i++){
        if(i in array && fn(array[i],i,array) return true;
    }
    return false;
}

var bool = arraySome(arr,function(item,))

使用reduce重构

var bool = arr.reduce(function(v,t){
    if(t > 2) return v =true;
},false)

//  map：遍历数组,返回一个由回调函数返回值组成的新数组

function  arrayMap(array){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    var a = [];
    for(var i=0; i<=array.length; i++){
        if(i in array) arr[i] = fn(array[i], index, array)
    }
    return arr;
}

var arr = arrayMap(arr, function(item, index, arr){
    return item + 10;
})

使用reduce重构

var arr = array.reduce(function(v,t,i){
    v[i] = t + 10;
    return v'
},[])

//  forEach （桥接模式）

function arrayforEach(array,fn){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i = 0; i<=array.length; i++){
        if(i in array && fn(array[i]) 
    }
}


var arr = array.arrayforEach(array,function(item, index, arr){
    console.log(item,index,arr);
    return item;
})

// fill：使用固定值填充数组 

function arrayFill(array,fn){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i = 0; i<array.length; i++){
        if(i in array && fn(array[i])) array[i] = array[i];
    }
    return array;
}

arrayFill(array,function(item){
    retrun item = 1;
})

// filter：筛选 将数组中每个元素判断是否满足条件，如果满足则筛选出来在新数组中返回

function  arrayFilter(array,fn){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    var arr =[];
    for(var i=0; i<array.length; i++){
        if(i in array && fn(array[i])) arr[arr.length] = array[i];
    }
    return arr;
}

var arr1 = arrayFilter(arr, function(item){
    return item > 判断条件;
})

使用reduce重构 

var arr = array.reduce(function(v,t){
    if(t满足给定判断条件)  v.push(t);
    return v;
},[])

 //  find：获取数组中大于给定数值的第一个元素

function  arrayFind(find){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i = 0; i<array.length; i++){
        if(i in array && fn(array[i])) return array[i];
    }
}

var value = arrayFind(array,function(item){
    return item > 判断条件;
})

使用reduce重构

var arr = array.reduce(function(v,t){
    if(t满足给定判断条件) v= t;
    return v;
},null)

//  findIndex：返回查找到的这个元素的第一个下标

function  arrayfindIndex(array){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    for(var i=0; i<array.length; i++){
        if(i in array && fn(array[i])) return i;
    }
}

var index = arrayfindIndex(array, function(item){
    return item == 1;
})

 使用reduce重构

var item = arr.reduce(function(v, t, i) {
    if (v === null && t === 3) v = i;
    return v;
}, null);

//  findLastIndex：从后往前找，返回找到的索引值，否则返回-1

function arrayfindLastIndex(array){
    
}

 使用reduce重构

var item = array.reduce(function(v,t,i){
    if(t === 3) v=i;
    else
        v=-1;
    return v;
},null)

 //  indexOf：从数组中给定位置开始查找，将查找到的元素所在下标返回，否则返回-1

function arrayindexOf(array,searchElement,start){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    if(start == undefinded) start = 0;
    start = ~~start;
    for(var i = start; i<array.length;i++){
        if(array[i] == searchElement) return i;
    }
    return -1;
}

//  lastindexOf：从数组尾部开始查找，这里可以设置从尾部的第几位开始查找，将查找到的元素所在下标返回，如果没有找到返回-1

function arraylastIndexOf(array,searchElement,start){
    if(!array || array.constructor !== Array) throw new TypeError("请输入一个正确的数组！");
    if(start == undefinded) start = array.length - 1;
    for(var i = start; i>=0; i--){
        if(array[i] == searchElement) return i;
    }
    return -1;
}

//  falt：数组扁平化

使用reduce重构 

var arr1 = arr.reduce(function(v, t) {
    v = v.concat(t);
    return v;
}, []);

//  copyWithin：复制数组的前面两个元素到后面两个元素上

function arrayCopyWithin(array, target, start, end) {
    if (!array || array.constructor !== Array) throw new TypeError("这不是一个正确的数组！");
    if (start === undefined) start = 0;
    if (end === undefined) end = array.length;
    start = ~~start;
    end = ~~end;
    if (target < 0) target = (target + array.length < 0 ? 0 : target + array.length);
    if (start < 0) start = (start + array.length < 0 ? 0 : start + array.length);
    if (end < 0) end = (end + array.length < 0 ? 0 : end + array.length);
     var arr = [];
    for (var i = start; i < end; i++) {
        arr[i] = array[i];
    }
    for (var j = target; j < array.length; j++, start++) {
        if (start < end) array[j] = arr[start];
        else return
    }
    return array;
}

 //  includes：判断数组中是否存在该元素

function arrayIncludes(array, seachElement) {
    if (!array || array.constructor !== Array) throw new TypeError("这不是一个正确的数组！");
    for (var i = 0; i < array.length; i++) {
        if (array[i] === seachElement) return true;
    }
    return false;
}

 //  reverse：颠倒数组中元素的顺序

function arrayReverse(array) {
    if (!array || array.constructor !== Array) throw new TypeError("这不是一个正确的数组！");
    if (array.length < 2) return array;
    for (var i = 0; i < ~~(array.length / 2); i++) {
        var temp = array[i];
        array[i] = array[array.length - i - 1];
        array[array.length - i - 1] = temp;
    }
    return array;
}

//  sort：数组排序

使用reduce重构 

var arr1 = arr.reduce(function(v, t, i, arr) {
    var minIndex = i;
    for (var j = i + 1; j < arr.length; j++) {
        if (arr[minIndex] > arr[j]) {
            minIndex = j;
        }
    }
    v.push(arr[minIndex]);
    arr[minIndex] = t;
    return v;
}, []);

//  reduce 重构

function arrayReduce(array, fn, initValue) {
    if (!array || array.constructor !== Array) throw new TypeError("请给入正确的数组");
    var i = 0;
    //数组是非空数组。但是里面都是空元素，会报错
    if (Object.values(array).length === 0) throw new TypeError(" Reduce of empty array with no initial value")
    //数组是空数组，并且initValue没有赋初值，会报错
    if (initValue === undefined && array.length !== 0) throw new TypeError("Reduce of empty array with no initial value")

    if (initValue === undefined) {
        for (; i < array.length; i++) {
        if (i in array) {
            initValue = array[i];
            i++;
            break;
        }
    }
}

//如果initValue有了初值，空数组是可以进入的
for (; i < array.length; i++) {
    if (i in array) initValue = fn(initValue, array[i], i, array);
}
return initValue;