Array.from() 从一个类似数组或可迭代对象中创建一个新的数组实例。
const bar = ["a", "b", "c"];
Array.from(bar);
// ["a", "b", "c"]
Array.from('foo');
// ["f", "o", "o"]
Array.isArray() 判断传入值是否为数组
Array.isArray([1, 2, 3]);
// true
Array.isArray({foo: 123});
// false
Array.isArray("foobar");
// false
Array.isArray(undefined);
// false
var someArray = [1, 5, 7];
Array.isArray(someArray)
// true
Array.of() 创建一个具有可变数量参数的新数组实例，不考虑参数的数量或类型。
Array.of(1); // [1]
Array.of(123); // [123]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
concat() 用于合并两个或多个数组,不会更改现有数组，而是返回一个新数组。
var arr1 = ['a', 'b', 'c'];
var arr2 = ['d', 'e', 'f'];
var arr3 = arr1.concat(arr2);
// arr3 is a new array [ "a", "b", "c", "d", "e", "f" ]
copyWithin() 浅复制数组的一部分到同一数组中的另一个位置，并返回它，而不修改其大小。
["alpha", "beta", "copy", "delta"].copyWithin(1, 2, 3); // 复制到下标为1，从下标为2开始复制到下标为3结束复制
// 0:"alpha" 1:"beta" 2:"copy" 3:"delta"
// ["alpha", "copy", "copy", "delta"]
// 0:"alpha" 1:"copy" 2:"copy" 3:"delta"
// target === 1:"beta"
// start === 2:"copy",
// end === 3:"delta"
// 1:"beta" => 1:"copy"
['alpha', 'bravo', 'charlie', 'delta'].copyWithin(2, 0); // 复制到下标为2，从下标为0开始复制
// results in ["alpha", "bravo", "alpha", "bravo"]
entries() 返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对。
var arr = ["a", "b", "c"];
var iterator = arr.entries();
// undefined
console.log(iterator);
// Array Iterator {}
console.log(iterator.next().value);
// [0, "a"]
console.log(iterator.next().value);
// [1, "b"]
console.log(iterator.next().value);
// [2, "c"]
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 true
fill() 用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。
[1, 2, 3].fill(4) // [4, 4, 4]
[1, 2, 3].fill(4, 1) // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2) // [1, 4, 3]
[1, 2, 3].fill(4, 1, 1) // [1, 2, 3]
[1, 2, 3].fill(4, -3, -2) // [4, 2, 3]
[1, 2, 3].fill(4, NaN, NaN) // [1, 2, 3]
Array(3).fill(4); // [4, 4, 4]
[].fill.call({length: 3}, 4) // {0: 4, 1: 4, 2: 4, length: 3}
filter() 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
function isBigEnough(value) {
return value >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]
// ES6 way
const isBigEnough = value => value >= 10;
let [...spread]= [12, 5, 8, 130, 44];
let filtered = spread.filter(isBigEnough);
// filtered is [12, 130, 44]
find() 查找数组中满足提供的测试函数的第一个元素的值。否则返回 undefined。
function isBigEnough(element) {
return element >= 15;
}
[12, 5, 8, 130, 44].find(isBigEnough); // 130
findIndex() 查找数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
function isBigEnough(element) {
return element >= 15;
}
[12, 5, 8, 130, 44].findIndex(isBigEnough); // 3
forEach() 对数组的每个元素执行一次提供的函数。
const arr = ['a', 'b', 'c'];
arr.forEach(function(element) {
console.log(element);
});
// ES6
arr.forEach( element => console.log(element));
// a
// b
// c
includes() 判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
let a = [1, 2, 3];
a.includes(2); // true
a.includes(4); // false
a.includes(2); // true
a.includes(4); // false
a.includes(3, 3); // false
a.includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
indexOf() 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
let a = [2, 9, 7, 8, 9];
a.indexOf(2); // 0
a.indexOf(6); // -1
a.indexOf(7); // 2
a.indexOf(8); // 3
a.indexOf(9); // 1
join() 将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。不会改变数组！
let a = ['Wind', 'Rain', 'Fire'];
console.log(a.join());
// 默认为 ","
// 'Wind,Rain,Fire'
console.log(a.join(""));
// 分隔符 === 空字符串 ""
// "WindRainFire"
console.log(a.join("-"));
// 分隔符 "-"
// 'Wind-Rain-Fire'
keys() 返回一个新的Array迭代器，它包含数组中每个索引的键。
var arr = ["a", "b", "c"];
var iterator = arr.keys();
console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
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 3
map() 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
// roots的值为[1, 2, 3], numbers的值为[1, 4, 9]
// ES6
let numbers = [1, 4, 9];
let doubles = numbers.map( x => x ** 2);
// roots的值为[1, 16, 81], numbers的值为[1, 4, 9]
pop() 从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。
let a = [1, 2, 3];
a.length; // 3
a.pop(); // 3
console.log(a); // [1, 2]
a.length; // 2
push() 将一个或多个元素添加到数组的末尾，并返回新数组的长度。
var numbers = [1, 2, 3];
numbers.push(4);
console.log(numbers);
// [1, 2, 3, 4]
numbers.push(5, 6, 7);
console.log(numbers);
// [1, 2, 3, 4, 5, 6, 7]
reduce() 对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值。
var total = [0, 1, 2, 3].reduce(function(sum, value) {
return sum + value;
}, 0);
// total is 6
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
return a.concat(b);
}, []);
// flattened is [0, 1, 2, 3, 4, 5]
reduceRight() 方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。
let flattened = [
[0, 1],
[2, 3],
[4, 5]
].reduceRight((a, b) => {
return a.concat(b);
}, []);
// flattened is [4, 5, 2, 3, 0, 1]
参数：
callback
一个回调函数，用来操作数组中的每个元素，可接受四个参数：
- previousValue
上一次调用回调的返回值，或提供的 initialValue - currentValue
当前被处理的元素 - index
当前处理元素的索引 - array
调用 reduce 的数组
initialValue
可作为第一次调用回调 callback 的第一个参数
reverse() 将数组中元素的位置颠倒。
var myArray = ['one', 'two', 'three'];
myArray.reverse();
console.log(myArray) // ['three', 'two', 'one']
shift()从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
let a = [1, 2, 3];
let b = a.shift();
console.log(a);
// [2, 3]
console.log(b);
// 1
slice() 返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。原始数组不会被修改。
语法：
arr.slice(); // [0,end]
arr.slice(begin); //[begin,end]
arr.slice(begin,end); //[begin,end]
实例：
var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
var citrus = fruits.slice(1, 3); // 从下标为1开始到3结束,取1、2
// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
// citrus contains ['Orange','Lemon']
some() 测试数组中的某些元素是否通过由提供的函数实现的测试。
const isBiggerThan10 = (element, index, array) => {
return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10);
// false
[12, 5, 8, 1, 4].some(isBiggerThan10);
// true
sort() 用排序算法对数组一的元素进行排序，并返回数组，默认排序顺序是根据字符串Unicode码点。
var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort();
// ['apples', 'bananas', 'cherries']
var scores = [1, 10, 21, 2];
scores.sort();
// [1, 10, 2, 21]
// 注意10在2之前,
// 因为在 Unicode 指针顺序中"10"在"2"之前
var things = ['word', 'Word', '1 Word', '2 Words'];
things.sort();
// ['1 Word', '2 Words', 'Word', 'word']
// 在Unicode中, 数字在大写字母之前,
// 大写字母在小写字母之前.
splice() 通过删除现有元素和/或添加新元素来更改一个数组的内容。
var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
myFish.splice(2, 0, 'drum'); // 在索引为2的位置插入'drum'
// myFish 变为 ["angel", "clown", "drum", "mandarin", "sturgeon"]
myFish.splice(2, 1); // 从索引为2的位置删除一项（也就是'drum'这一项）
// myFish 变为 ["angel", "clown", "mandarin", "sturgeon"]
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() 将数组转换为字符串
var monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
var myVar = monthNames.toString(); // assigns "Jan,Feb,Mar,Apr" to myVar.
unshift() 将一个或多个元素添加到数组的开头，并返回新数组的长度。
var arr = [1, 2];
arr.unshift(0); //result of call is 3, the new array length
//arr is [0, 1, 2]
arr.unshift(-2, -1); // = 5
//arr is [-2, -1, 0, 1, 2]
arr.unshift( [-3] );
//arr is [[-3], -2, -1, 0, 1, 2]