JavaScript中数组的方法（全）

数组的方法

ES5

Array.isArray(value);

判断某个值到底是不是数组；

let arr= [1,2,3];
if(Array.isArray(arr)){
	console.log('arr是数组');
}else{
    console.log('arr不是数组');
}
//arr是数组

join()

用于把数组中所有元素放入一个字符串，元素是通过指定的分隔符分隔的，不指定分隔符默认用逗号分隔；

let arr = ['a','b','c'];
console.log(arr.join());//a,b,c
console.log(arr.join('.'));//a.b.c

push()

可以接收任意数量的参数，将他们逐个添加到数组末尾，并返回修改后数组的长度；

let arr = [1,2,3];
let length = arr.push(4,5,6);
console.log(length);//6
console.log(arr);//[1,2,3,4,5,6]

unshift()

可以接收任意数量的参数，将他们逐个添加到数组头部，并返回修改后数组的长度；

pop()

从数组末尾移除最后一项，返回移除的项；

let arr = [1,2,3];
let item = arr.pop();
console.log(item);//3
console.log(arr);//[1,2]

shift()

从数组中第一个项，并返回该项；

sort()

排序，默认是升序，sort()方法会调用toString()方法，所以比较的是字符串；

//例一
let values = [5,2,3,4,1];
values.sort();
console.log(values); //[1,2,3,4,5]
//例二
let values = [0,1,15,10,5];
values.sort();
console.log(values); //[0,1,10,15,5]
//例三
function compare(value1, value2){
    if(value1 < value2){
        return -1;
    }else if(value1 > value2){
        return 1;
    }else{
        return 0;
    }
}
let values = [0,1,15,10,5];
values.sort(compare);
console.log(values); //[0,1,5,10,15]

reverse()

反转数组项的顺序；

let values = [1,2,3,4,5];
values.reverse();
console.log(values); //[5,4,3,2,1]

concat()

创建当前数组的一个副本，然后将接受到的参数添加到这个副本的末尾，最后返回新构建的数组，不改变原数组；

let arr1 = [1,2,3];
let arr2 = arr1.concat([4, 5, 6]);
console.log(arr1);// [1,2,3]
console.log(arr2);// [1,2,3,4,5,6];

slice()

slice(start , end);

start: 可选，从该位置开始截取；

end：可选，截取结束；

截取数组，返回截取的项,不改变原数组；

let arr = [1,2,3,4,5,6];
let newArr = arr.slice(2);
let newArr2 = arr.slice(2,4);
console.log(newArr);// [3,4,5,6]
console.log(newArr2);// [3,4];

splice()

删除：

可以删除任意数量的项，返回一个数组(包含删除的项)；需要指定两个参数：要删除的第一个项的位置和要删除的项的个数；

let arr = [1,2,3,4,5,6];
let items = arr.splice(1,3)
console.log(items);//[2,3,4]
console.log(arr);//[1,5,6] 改变了原数组

插入

可以向指定位置插入任意数量的项，返回一个空数组；需提供三个参数：起始的位置、0、要插入的项；

let arr = [1,2,3,4,5,6];
arr.splice(2,0,'haha');
console.log(arr);// [1,2,'haha',3,4,5,6];

替换

可以向指定位置插入任意数量的项，并删除任意数量的项；需提供三个参数：其实的位置、要删除的项的个数、要插入的项；

let arr = [1,2,3,4,5,6];
let deleteItem = arr.splice(2,2,'ha','ha');
console.log(arr);//[1,2,'ha','ha',5,6]
console.log(deleteItem);//[3,4]

indexOf()、lastIndexOf()

两个方法都接收两个参数：要查找的项和（可选的）表示查找起点位置的索引，其中indexOf从数组的开头向后查找，lastIndexOf则从数组的末尾开始向前查找,找不到返回-1；

let number = [1,2,3,4,5,4,3,2,1];
console.log(number.indexOf(4));//3
console.log(number.lastIndexOf(4));//5
console.log(number.indexOf(6));//-1

forEach()、map()、filter()、every()、some()

每个方法都接收两个参数：要在每一项上运行的函数和（可选的）运行该函数的作用域对象——影响this的值；

forEach():对数组中的每一项运行给定的函数，没有返回值；

map():对数组中的每一项运行给定的函数，返回每次函数调用的结果组成的数组；

filter():对数组中的每一项运行给定的函数，返回改函数会返回true的项组成的数组；

every():对数组中的每一项运行给定的函数，如果该函数对数组的每一项都返回true，则返回true；

some();对数组中的每一项运行给定的函数，如果该函数对数组的任意一项返回true，则返回true；

reduce()、reduceRight()

迭代数组所有的项，然后构建一个最终的返回值；reduce()是从数组第一项开始，逐个遍历到最后，reduceRight()则是从数组最后一项开始，向前遍历到第一项；

这两个方法都接受两个参数：一个在每一项上调用的函数和（可选的）作为归并基础的初始值。传给reduce() 和 reduceRight() 的函数接收4个参数：前一个值，当前值，项的索引和数组对象；

//数组求和
let values = [1,2,3,4,5];
let sum = values.reduce(function(prev,cur,index,array){
    return prev + cur;
});
console.log(sum);//15

ES6扩展

扩展运算符"…"

将一个数组转为用逗号分隔的参数序列。

console.log(...[1,2,3]);// 1,2,3

合并数组

const arr1 = [1,2,3];
const arr2 = [4,5,6];
console.log([...arr1,...arr2]);//[1,2,3,4,5,6]

与解构赋值结合

 const [first, ...rest] = [1, 2, 3, 4, 5, 6];
 console.log(first)//first  1
 console.log(rest)//rest  2,3,4,5,6

字符串

 console.log([...'hello']);//['h','e','l','l','o']

Array.from()

用于将两类对象（类似数组的对象(伪数组)、可遍历对象）转换为真正的数组；

//例一
let likeArray = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length:3
}
let arr = Array.from(likeArray);
console.log(arr)//['a','b','c']
//例二
 console.log(Array.from('hello'));// ['h','e','l','l','o'];
//例三
 console.log(Array.from(new Set(['a', 'b'])));//['a','b'];

Array.of()

将一组值转换为数组；

 console.log(Array.of(1, 2, 3));//[1,2,3]

copyWith()

在当前数字内部将指定位置的成员复制到其他位置（会覆盖原有成员）然后返回当前数组；

Array.prototype.copyWithin(target,start = 0, end = this.length)

target（必选）:从该位置开始替换数据；

start（可选）:从该位置开始读取数据；

end（可选）：到该位置前停止读取数据；

console.log([1, 2, 3, 4, 5].copyWithin(0, 3));//[4,5,3,4,5]

console.log([1, 2, 3, 4, 5].copyWithin(0, 3, 4));//[4,2,3,4,5]

find()

找出第一个符合条件的数组成员，参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员；没有符合条件的成员则返回undefined；

let result = [1,5,10,15].find((value, index, arr) => {
    return value > 9;
});
console.log(result);//10

findIndex()

同find(),只不过反的是下标，找不到返-1；

fill()

使用给定值填充一个数组；

fill(要填充的值，填充的起始位置，填充的结束位置)；

new Array(3).fill(7); //[7,7,7]
['a','b','c'].fill(7); //[7,7,7]
['a','b','c'].fill(7,1,2); //['a',7,'c']

entries()、keys()、values()

遍历数组，返回一个遍历器对象，可以用for…of循环遍历；

for(let index of ['a','b'].keys()){
    console.log(index);
}//  0  1

for(let element of ['a','b'].values()){
    console.log(element);
}//  'a'  'b'

for(let [index, element] of ['a','b'].entries()){
    console.log(index, element);
}
// 0 'a'
// 1 'b'

includes()

Array.prototype.includes()返回一个布尔值，表示某个数组是否包含给定的值；

[1,2,3].includes(2)// true
[1,2,3].includes(4)// false
[1,2,NaN].includes(NaN)// true