数组的方法

1. Array

• Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型,返回该数组。
  Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个包含 7 个 undefined 元素的数组。

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

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

• Array.from() 方法从一个类似数组或可迭代对象中创建一个新的数组实例。
  Array.from() 可以通过以下方式来创建数组对象：
  伪数组对象（拥有一个 length 属性和若干索引属性的任意对象）,例如:字符串
  可迭代对象（可以获取对象中的元素,如 Map和 Set 等）;

const bar = ["a", "b", "c"];
Array.from(bar);
// ["a", "b", "c"]

Array.from('foo');
// ["f", "o", "o"]

Array.from() 方法有一个可选参数 mapFn，让你可以在最后生成的数组上再执行一次 map 方法后再返回。也就是说Array.from(obj, mapFn, thisArg)就相当于Array.from(obj).map(mapFn, thisArg), 除非创建的不是可用的中间数组。

let m = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(m); 
// [[1, 2], [2, 4], [4, 8]]

• prototype.every
  every() 方法测试数组的所有元素是否都通过了指定函数的测试。every 方法为数组中的每个元素执行一次 callback 函数，直到它找到一个使 callback 返回 false（表示可转换为布尔值 false 的值）的元素。如果发现了一个这样的元素，every 方法将会立即返回 false。否则，callback 为每一个元素返回 true，every 就会返回 true。

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

• prototype. some
  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

• prototype.find
  arr.find(callback[, thisArg])
  find()方法返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined.callback与some,foreach,every,some一样的参数

function isBigEnough(element) {
  return element >= 15;
}

[12, 5, 8, 130, 44].find(isBigEnough); // 130

在第一次调用 callback 函数时会确定元素的索引范围，因此在 find 方法开始执行之后添加到数组的新元素将不会被 callback 函数访问到。如果数组中一个尚未被callback函数访问到的元素的值被callback函数所改变，那么当callback函数访问到它时，它的值是将是根据它在数组中的索引所访问到的当前值。被删除的元素仍旧会被访问到。

• prototype.findIndex
  arr.findIndex(callback[, thisArg])
  findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。

function isBigEnough(element) {
  return element >= 15;
}

[12, 5, 8, 130, 44].findIndex(isBigEnough); 
// index of 4th element in the Array is returned,
// so this will result in '3'

• prototype.fill
  arr.fill(value, start, end)
  value:用来填充数组元素的值。
  start 可选:起始索引，默认值为0。
  end 可选:终止索引，默认值为 this.length。
  返回值:修改后的数组。
  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}

• prototype.includes
  includes() 方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
  arr.includes(searchElement, fromIndex )
  searchElement:需要查找的元素值。
  fromIndex 可选:从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。

let a = [1, 2, 3];
a.includes(2); 
// true 
a.includes(4); 
// false

• prototype.map
  创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果

// ES6
let numbers = [1, 5, 10, 15];
let doubles = numbers.map( x => x ** 2);

// doubles is now [1, 25, 100, 225]
// numbers is still [1, 5, 10, 15]


const numbers = [2, 4, 8, 10];
let halves = numbers.map(x => x / 2);

let numbers = [1, 4, 9];
let roots = numbers.map(Math.sqrt);
// roots is now [1, 2, 3]
// numbers is still [1, 4, 9]

• prototype.reduce
  对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值。
  arr.reduce(callback[, initialValue])
  callback
  执行数组中每个值的函数，包含四个参数：
  • accumulator
    累加器累加回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（如下所示）。
  • currentValue
    数组中正在处理的元素。
  • currentIndex
    数组中正在处理的当前元素的索引。 如果提供了initialValue，则索引号为0，否则为索引为1。
  • array
    调用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]