数组方法汇总
Array.length
返回或设置一个数组中的元素个数
设置 length 属性的值来截断任何数组
Array.from()
语法 Array.from(arrayLike, mapFn, thisArg)
arrayLike
想要转换成数组的伪数组对象或可迭代对象。mapFn (可选参数)
如果指定了该参数，新数组中的每个元素会执行该回调函数。thisArg (可选参数)
可选参数，执行回调函数 mapFn 时 this 对象。返回值
一个新的数组实例
console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]
console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]
//数组合并去重
function combine(){
let arr = [].concat.apply([], arguments); //没有去重复的新数组
return Array.from(new Set(arr));
}
var m = [1, 2, 2], n = [2,3,3];
console.log(combine(m,n)); // [1, 2, 3]Array.of() 创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型
Array.of(7); // [7]
Array.of(1, 2, 3); // [1, 2, 3]
Array(7); // [ , , , , , , ]
Array(1, 2, 3); // [1, 2, 3]concat()
方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
var arr1 = ['a', 'b', 'c'];
var arr2 = ['d', 'e', 'f'];
var arr3 = ['f'];
var arr4 = arr1.concat(arr2,arr3);
// arr4 is a new array [ "a", "b", "c", "d", "e", "f" ]
--------------
var alpha = ['a', 'b', 'c'];
var alphaNumeric = alpha.concat(1, [2, 3]);
console.log(alphaNumeric);
// results in ['a', 'b', 'c', 1, 2, 3]copyWithin(target, start, end)
浅复制数组的一部分到同一数组中的另一个位置
target 索引，复制到某个目标位置
start 索引，开始复制的位置
end 索引，结束复制的位置，不包括当前
[1, 2, 3, 4, 5].copyWithin(-2);
// [1, 2, 3, 1, 2]
[1, 2, 3, 4, 5].copyWithin(0, 3);
// [4, 5, 3, 4, 5]
[1, 2, 3, 4, 5].copyWithin(0, 3, 4);
// [4, 2, 3, 4, 5]
[1, 2, 3, 4, 5].copyWithin(-2, -3, -1);
// [1, 2, 3, 3, 4]entries() 返回一个iterator 对象
var arr = ["a", "b", "c"];
var iterator = arr.entries();
console.log(iterator);every()
测试数组的所有元素是否都通过了指定函数的测试
function isBigEnough(element, index, array) {
return (element >= 10);
}
var passed = [12, 5, 8, 130, 44].every(isBigEnough);
// passed is false
passed = [12, 54, 18, 130, 44].every(isBigEnough);
// passed is truefill(value， start， end])
start， end索引
用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。
[1, 2, 3].fill(4, 1, 2); // [1, 4, 3]
[1, 2, 3].fill(4, -3, -2); // [4, 2, 3]filter()
var new_array = arr.filter(callback(element, index, array])find()
返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
findIndex()
返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
function isBigEnough(element) {
return element >= 15;
}
[12, 5, 8, 130, 44].findIndex(isBigEnough);
//'3'flat()
会递归到指定深度将所有子数组连接，并返回一个新数组。
var newArray = arr.flat(depth)
depth层数
var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]
var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]flatMap（）
一个新的数组，其中每个元素都是回调函数的结果，并且结构深度 depth 值为1。
var arr1 = [1, 2, 3, 4];
arr1.map(x => [x * 2]);
// [[2], [4], [6], [8]]
arr1.flatMap(x => [x * 2]);
// [2, 4, 6, 8]
// only one level is flattened
arr1.flatMap(x => [[x * 2]]);
// [[2], [4], [6], [8]]forEach()
array.forEach(callback(currentValue, index, array){
//do something
}, this)includes()
用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // trueindexOf()
返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
var array = [2, 5, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0join()
var a = ['Wind', 'Rain', 'Fire'];
var myVar1 = a.join(); // myVar1的值变为"Wind,Rain,Fire"
var myVar2 = a.join(', '); // myVar2的值变为"Wind, Rain, Fire"
var myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"
var myVar4 = a.join(''); // myVar4的值变为"WindRainFire"keys()
keys() 方法返回一个新的Array迭代器，它包含数组中每个索引的键lastIndexOf（）
返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找
var array = [2, 5, 9, 2];
var index = array.lastIndexOf(2);
// index is 3
index = array.lastIndexOf(7);
// index is -1
index = array.lastIndexOf(2, 3);
// index is 3
index = array.lastIndexOf(2, 2);
// index is 0
index = array.lastIndexOf(2, -2);
// index is 0
index = array.lastIndexOf(2, -1);
// index is 3map()
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
// roots的值为[1, 2, 3], numbers的值仍为[1, 4, 9]pop()
从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。
let myFish = ["angel", "clown", "mandarin", "surgeon"];
let popped = myFish.pop();
console.log(myFish);
// ["angel", "clown", "mandarin"]
console.log(popped);
// surgeonpush()
将一个或多个元素添加到数组的末尾
reduce()
累加器和数组中的每个元素（从左到右）应用一个函数
var total = [0, 1, 2, 3].reduce(function(sum, value) {
return sum + value;
}, 0);
// total is 6reduceRight()
接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。
var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
return a.concat(b);
}, []);
// flattened is [4, 5, 2, 3, 0, 1]reverse()
将数组中元素的位置颠倒。
var myArray = ['one', 'two', 'three'];
myArray.reverse();
console.log(myArray) // ['three', 'two', 'one']shift()
从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];
console.log('调用 shift 之前: ' + myFish);
// "调用 shift 之前: angel,clown,mandarin,surgeon"
var shifted = myFish.shift();
console.log('调用 shift 之后: ' + myFish);
// "调用 shift 之后: clown,mandarin,surgeon"
console.log('被删除的元素: ' + shifted);
// "被删除的元素: angel"slice()
返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。且原始数组不会被修改。
arr.slice();
// [0, end]
arr.slice(begin);
// [begin, end]
arr.slice(begin, end);
// [begin, end)some()
测试数组中的某些元素是否通过由提供的函数实现的测试。
[2, 5, 8, 1, 4].some(x => x > 10); // false
[12, 5, 8, 1, 4].some(x => x > 10); // truesort()
当的位置对数组的元素进行排序，并返回数组。
splice()
通过删除现有元素和/或添加新元素来更改一个数组的内容
toLocaleString()
返回一个字符串表示数组中的元素。数组中的元素将使用各自的 toLocaleString 方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号 “,”）隔开。
var number = 1337;
var date = new Date();
var myArr = [number, date, "foo"];
var str = myArr.toLocaleString();
console.log(str);
// 输出 "1,337,2017/8/13 下午8:32:24,foo"
// 假定运行在中文（zh-CN）环境，北京时区toString()
返回一个字符串，表示指定的数组及其元素
unshift()
将一个或多个元素添加到数组的开头，并返回新数组的长度