数组常用方法重构与应用

数组常用方法
实现重构
常用方法的应用

数组方法：

splice
arr.splice(起始的位置，删除的个数，添加的元素（可以是多个）)
返回删除的元素构成的新数组，无引用关系
替换
arr.splice()//返回一个空数组
arr.splice(0)//把数组中所有元素删除，放在新数组中，清空原数组
arr.splice(1)//从下标为1清除到数组尾部
arr.splice(-2)//从倒数第二项删除到尾部
arr.splice(1,2)//从第一位删除两个元素
arr.splice(-2,1)//从倒数第二项删除一个元素
arr.splice(-1,0,1)//在倒数第一位前插入一个1
arr.splice(0,0,-1)//在最前面插入一个-1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
var arr = [1, 2, 3, 4, 5, 6];
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 = 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);

slice不会改变原数组，将指定的起始位置到结束位置的元素放在一个新数组中返回
arr.slice()复制数组，无引用关系
arr.slice(3)从下标3开始到数组尾部
arr.slice(-2)//从倒数第二个开始到数组尾部
arr.slice(2,-1)从第二位到数组的倒数第一位

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
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不返回新数组
遍历数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var arr=[
    {a:1},
    {a:2},
    {a:3},
    {a:4},
    {a:5},
]
var arr1=arr.forEach(function(item,index,arr){
    // item.a=10;
    item={a:10}
})
console.log(arr)

function array_forEach(arr,fn){
    for(var i=0;i<arr.length;i++){
        if(i in arr) fn(arr[i],i,arr);
        //if判断是为了将数组中未定义的元素不显示
  }
}
var arr=[1,2,,3,4,5]
array_forEach(arr,function(item,index,arr){
    console.log(item,index,arr);
})

map会返回一个新数组，长度与原数组必须相同
map中回调函数里使用return可以将需要的每个元素数据返回给新数组中对应的位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
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;
}
var arr=[2,4,6,8,10];
var arr1=array_map(arr,function(item,index,arr){
    return item+10
})
console.log(arr1)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var arr=[4,5,1,2,3];
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;
}
var bool=array_some(arr,function(item,index,arr){
    return item>4
})
console.log(bool);

every

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var arr=[4,5,1,2,3];
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
}
var bool=array_every(arr,function(item,index,arr){
    return item>4
})
console.log(bool);

filter
筛选，从数组中挑选出满足条件的数据形成新数组（不可修改）
重构：回调函数返回为true时，将元素添加到新数组的尾部

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function array_filter(arr,fn){
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        if(i in arr && fn(arr[i],i,arr)) arr1[arr1.length]=arr[i];
        //回调函数返回为true时，将元素添加到新数组的尾部
    }
    return arr1;
}
var arr1=array_filter(arr,function(item){
    return item>=3;
})
console.log(arr1);

reduce
归并，从数组中通过各种处理，最后返回一个结果

1
2
3
4
5
6
var arr=[1,2,3,4,5]
var val=arr.reduce(function(value,item,index,arr){
    //value就是开始到结束的归并值
    console.log(value,item);
    return value+item;
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
var arr=[1,2,3,4,5];
function array_reduce(arr,fn,init){
    if(arr.length===0) return;
    if(arr.length===1) return arr[0];
    var value=arr[0];
    var index=1;//后续判断从第几个开始循环，如果有初始值则从第0个开始循环，如果没有初始值从第一个开始循环
    if(init!==undefined){
        index=0;
        value=init;//如果初始值存在value就是初始值，如果不存在初始值就是数组的第0项
    }
    for(;index<arr.length;index++){
        value=fn(value,arr[index],index,arr);
    }
    return value;
}
var val=array_reduce(arr,function(value,item){
    return value+item;
},50)
console.log(val)

flatMap

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
function array_flatmap(arr, fn) {
    var arr1 = [];
    for (var i = 0; i < arr.length; i++) {
        var value = fn(arr[i], i, arr);
        if (value && value.constructor === Array) {
            for (var j = 0; j < value.length; j++) {
                arr1[arr1.length] = value[j];
            }
        } else {
            arr1[arr1.length] = value;
        }
    }
    return arr1;
}
var arr1=array_flatmap(arr,function(item){
    if(Array.isArray(item))
        item=array_flatmap(item,function(t){
            return t;
        })
    return item;
});
console.log(arr1);

indexOf
在数组中查找某个元素的下标，如果这个元素存在，返回这个元素所在下标
如果查找不到返回-1。
var index=arr.indexOf(查找什么元素，从什么位置开始查找);
lastIndexOf

数组常用方法重构与应用

Contents

数组方法：

查找元素所有下标

去重

将两个数组中相同的元素放在一个新数组中

将两个数组中不同的元素放在一个新数组中