Javascript常用的数组方法之重构(二)

不影响原数组的方法.

1.concat

函数功能：数组1与数组2合并(原数组不做改变)

返回值：合并后的数组

function arrayConcat(array){
     if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array");
     var arr=[];
    for(var i=0;i<array.length;i++){
       if(arguments[i] && arguments[i].constructor===Array){
           for(var j=0;j<arguments.length;j++){
           if(j in arguments[i])arr[arr.length]=arguments[i][j];
            else arr.length++;
           }
       }else arr[arr.length]=arguments[i];
    }
    return arr;
}

2.join

函数功能：使用符号把数组链接合并为字符串

返回值：用符号连接而成的字符串

function arrayJoin(array,separator){
     if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array");
    if(separator===undefined) separator=","
    separator+="";
    var str="";
    for(var i=0;i<array.length;i++){
        str+=array[i]+(i===array.length-1 ? "" :separator);
}
    return str;  
}

3.slice

函数功能：从原数组中截取从开始位置到结束位置的所有元素，放在一个数组中，如果开始位置和结束位置省略，则从数组下标0到数组尾部，如果开始位置有值，结束位置省略，则到数组尾部，如果开始位置和结束位置都是负值，则从后向前数对应的位置。

返回值：被截取后所形成的新数组

function arraySlice(array,start,end){
     if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array");
    var arr=[];
    if(array.length===0) return arr;
    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)start=start+array.length<0?0:end+array.length;
    for(var i=start;i<end;i++){
        arr[arr.length]=array[i];
    }
    
    return arr;
}

4.indexof

函数功能：查某个指定的字符串在字符串中首次出现的位置(索引)(从前往后进行查找)

返回值：如果找到了返回这个元素所在的下标，如果没找到返回-1

与findIndex的区别 indexOf只能查找非引用地址的元素下标

findIndex用来查找引用地址的元素下标

function arrayIndexof(array,item){
    if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array");
    var index=-1;
    	for(var i=0;i<array.length;i++){
            if(i in array &&array[i]===item) return i;
        }
    return index;
}

5.lastIndexof

函数功能：是从右向左查某个指定的字符串在字符串中最后一次出现的位置（也就是从后往前查）

返回值：如果找到了返回这个元素所在的下标，如果没找到返回-1

function arrayLastIndexof(array,item){
    var index=-1;
    for(var i=array.length-1;i>=0;i--){
        if(i in array && array[i]===item) return i;
    }
    return index;
}

带有回调函数的方法.

1.forEach

函数功能：遍历数组

返回值：没有返回值

function arrayForEach(array,callback){
     if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array");
     if(typeof callback!=='function') throw new TypeError(callback+'不是函数');
    for(var i=0;i<array.length;i++){
        if(i in array) callback(array[i],i,array)
    }
}
//调用forEach
 arrayForEach(arr,function(item,index,arr) {
             console.log(item,index,arr)
}) 

2.map

函数功能：遍历数组

返回值：不改变原来的数组，相当于拷贝了原来的数组把原来数组的值做映射，返回拷贝过后的新数组

function arrayMap(array,callback){
    if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array");
    if(typeof callback!=='function') throw new TypeError(callback+'不是函数');
    var arr=[];
    for(var i=0;i<array.length;i++){
        if(i in array) arr[i]=callback(array[i],i,array)
    }
    return arr;
}
//调用
var arr1=arrayMap(arr,function(item,index,arr){
    return item
})      

3.filter

函数功能：筛选(过滤)

返回值：被条件筛选过后的数组

function arrayFilter(array,callback){
    if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array");
    if(typeof callback!=='function') throw new TypeError(callback+'不是函数');
    var arr=[];
    for(var i=0; i<array.length;i++){
        if(i in array && callback([i],i,array)) arr[arr.length]=array[i];
    }
    return arr;
}
var arr1=arrayFilter(arr,function(item){
    return item>5;
})        

4.every

函数功能：是不是每个元素都满足条件

function arrayEvery(array，callback){
    if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array"); 
     if(typeof callback!=='function') throw new TypeError(callback+'不是函数'); 
    for(var i=0; i<array.length;i++){
        if(!(i in array)) continue;
        if(！callback(array[i],i,array)) return false;
    }
    return true;
}
arraySome(arr,function(item,index,arr){
    return item>5;//（判断条件）
})

5.some

函数功能：判断数组中是不是有一个元素满足条件，返回true

返回值 ：布尔值

function arraySome(array，callback){
    if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array"); 
     if(typeof callback!=='function') throw new TypeError(callback+'不是函数'); 
    for(var i=0; i<array.length;i++){
        if(!(i in array)) continue;
        if(callback(array[i],i,array)) return true;
    }
    return false;
}
arraySome(arr,function(item,index,arr){
    return item>5;//（判断条件）
})

6.find家族

find

函数功能：找到第一个满足条件的

返回值：第一个满足条件的元素

function arrayFind(array,callback){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    if(typeof callback!==function) throw new TyepeError(callback+"不是函数");
    for(var i=0;i<array.length;i++){
        if(callback(array[i],i,array)) return array[i];
    }
    return null;
}
var obj=arrayFind(arr,function(item){
    return item.id===1004
})

findindex

函数作用：返回满足条件元素的下标

返回值：有下标 无-1

function arrayFind(array,callback){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    if(typeof callback!==function) throw new TyepeError(callback+"不是函数");
    for(var i=0;i<array.length;i++){
        if(callback(array[i],i,array)) return i;
    }
    return -1;
}
var obj=arrayFind(arr,function(item){
    return item.id===1004
})

findLast

与findindex不一样 从后向前查找对象

function arrayFindLast(array,callback){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    if(typeof callback!==function) throw new TyepeError(callback+"不是函数");
    for(var i=array.length-1;i>=0;i--){
        if(callback(array[i],i,array)) return array[i];
    }
    return null;
}
var obj=arrayFind(arr,function(item){
    return item.id===1004
})  

FindLastIndex

function arrayFindLastIndex(array,callback){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    if(typeof callback!==function) throw new TyepeError(callback+"不是函数");
    for(var i=array.length-1;i>=0;i--){
        if(callback(array[i],i,array)) return i;
    }
    return -1;
}
var obj=arrayFind(arr,function(item){
    return item.id===1004
})  

includes

函数作用：判断函数中是否有什么元素(es6)

返回值：布尔值

function arrayIncludes(array,item){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    for(var i=0;i<array.length;i++){
        if(i in array && array[i]===item) return true;
    }
    return false;
}

//

flatMap

函数作用：扁平化数组(只能扁平一层)

返回值：返回扁平化处理后的数组

function arrayflatMap(array,fn){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    if(typeof callback!==function) throw new TyepeError(callback+"不是函数");
    var arr=[];
    for(var i=0;i<array.length;i++){
        arr=arr.concat(fn(array[i],i,array))
    }
    return arr; 
}
var arr1=arrayflatMap(arr,function(item){
    return item;
})

flat

扁平化数组可以根据参数来扁平

//最大扁平化
function Flat(array,result){
    if(result===undefined) result=[];
    for(var i=0;i<array.length;i++){
     if(Array.isArray(array[i])) flat(array[i],result); 
     else result.push(array[i]);
      
    }
    return result;
}
Flat(arr)
//重构flat可以根据参数来控制扁平化
function arrayFlat(array,maxlv,currentLv,result){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    if(maxLV === undefined) maxLv=1;
    if(currentLv === undefined) currentLv=0;
    if(result === undefined) result=[];
    for(var i=0;i<array.length;i++){
        if(maxLv>currentLv && Array.isArray(array[i])) arrayFlat(array[i],maxLv,currentLv+1,result);
        else result.push(array[i]);
    }
    return result;
}

copywithin

函数作用：复制数组的一部分数据覆盖到数组的另一个位置，并且返回数组但是不会改变数组的长度。(es6)

function arrayCopyWithin(array,target,start,end){
    if(!array || array.constructor!==Array) throw new TypeError(array+"is not a Array");
    var arr=[];
    if(target===undefined) target=0;
    if(start===undefined) start=0;
    if(end===undefined) end=0;
    target=~~target;
    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;
    for(var i=0;i <array.length;i++){
        if(i>=target && i<target+(end-start)) arr[i]=array[i-target+start];
        else arr[i]=array[i];
    }
    array=arr;
    return array;   
}

7.reduce

归并：归纳一处合并起来

value 从第二次开始就是return的结果，第一次是数组的第0项元素

item从第一次开始就是数组的第一项元素向后遍历

第二个参数 是归并使用初始值，如果有这个参数，归并时，item从数组的下标0开始，而value就是这个初始值。

函数功能：归纳一处合并起来

返回值：返回计算结果

function arrayReduce(array,callback,initValue){
    if(!array||array.constructor!==Array)throw new TypeError(array+"is not a Array"); 
    if(typeof callback!=='function') throw new TypeError(callback+'不是函数');
    var bool=false;
    var index=0;
    if(initValue===undefined){
        bool=true; 
        //initValue=array[0];
        while(index<array.length){
            if(index in array){
                bool=false;
                initValue=array[index];
                index++;
                break;
            }
            index++;
        }
    }
    for(; index<array.length;index++){
    if(index in array){
     initValue=callback(initValue,array[index],index,array)
        bool=false;
       }
    }
    if(bool) throw new TypeError("Reduce of empty array with no initial")
    return initValue;
}
arrayReduce(arr,function(value,item){
    return value+item;
},100);

8.利用ruduce实现别的数组方法

//利用reduce实现map
      //map是遍历数组中所有元素，可以对原数组进行处理，返回一个新的数组
      var arr1 = arr.reduce(function (v, t, i) {
        v[i] = t + 10;
        return v;
      }, []);
      console.log(arr1);
      var arr3 = arrayReduce(
        arr,
        function (v, t, i, array) {
          v[i] = t + 10;
          return v;
        },
        []
      );
      console.log(arr3);
 //some
      //some主要是判断数组中是否一个元素满足条件，
      //有一个就返回为true，一个都没有就返回为false
      //会返回一个布尔值，所以需要一个变量接收
      var bool2 = arr.reduce(function (initValue, item, index, array) {
        if (item > 2) initValue = true;
        return initValue;
      }, false);
      console.log(bool2);
      var bool3 = arrayReduce(
        arr,
        function (initValue, item, index, array) {
          if (item > 2) initValue = true;
          return initValue;
        },
        false
      );
      console.log(bool3);
 //every
      //every是遍历数组中所有元素，确保数组中每个元素都满足某条件
      //有一个不满足，就会返回false，仍然会返回一个布尔值，所以使用一个变量进行接收
      var bool1 = arr.reduce(function (initvalue, item) {
        if (item < 0) initvalue = false;
        return initvalue;
      }, true);
      console.log(bool1);
      var bool3 = arrayReduce(
        arr,
        function (initvalue, item) {
          if (item < 0) initvalue = false;
          return initvalue;
        },
        true
      );
      console.log(bool3);
 //filter
      //筛选，将数组中所有满足条件的元素作为一个新数组返回，所以需要一个变量接收结果
      var arr2 = arr.reduce(function (initvalue, item) {
        if (item > 1) initvalue.push(item);
        return initvalue;
      }, []);
      console.log(arr2);
      var arr3 = arrayReduce(
        arr,
        function (initvalue, item) {
          if (item > 1) initvalue.push(item);
          return initvalue;
        },
        []
      );
      console.log(arr3);
 //indexOf
      //在数组中查找对应元素的下标，查找到返回对应下标，没查找到返回-1
      var s1 = arr.reduce(function (initValue, item, index) {
        if (item === 2) initValue = index;
        return initValue;
      }, -1);
      console.log("reduce=" + s1);
      var s2 = arrayReduce(
        arr,
        function (initValue, item, index) {
          if (item === 2) initValue = index;
          //   console.log(initValue);
          return initValue;
        },
        -1
      );
      console.log("arrayReduce=" + s2);
​
      //lastIndexOf
      //和indexOf的唯一区别就是从后向前遍历
      var s1 = arr.reduceRight(function (initValue, item, index) {
        if (item === 3) initValue = index;
        return initValue;
      }, -1);
      console.log(s1);
      var s2 = arrayReduce(
        arr,
        function (initValue, item, index) {
          if (item === 3) initValue = index;
          return initValue;
        },
        -1
      );
      console.log(s2);