数组与对象的部分方法

获取对象的属性：

console.log(person["name"]); 中括号法

console.log(person.name); 点方法

创建数组的静态方法：from()和 of()

const a1 = [1, 2, 3, 4];

const a2 = Array.from(a1, x => x**2);

const a3 = Array.from(a1, function(x) {return x**this.exponent}, {exponent: 2});

console.log(a2); // [1, 4, 9, 16]

console.log(a3); // [1, 4, 9, 16]

Array.of()可以把一组参数转换为数组。这个方法用于替代在 ES6之前常用的 Array.prototype. slice.call(arguments)，一种异常笨拙的将 arguments 对象转换为数组的写法：

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

console.log(Array.of(undefined)); // [undefined]

keys()、values()和 entries()。

const a = ["foo", "bar", "baz", "qux"];

// 因为这些方法都返回迭代器，所以可以将它们的内容

// 通过 Array.from()直接转换为数组实例

const aKeys = Array.from(a.keys());

const aValues = Array.from(a.values());

const aEntries = Array.from(a.entries());

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

console.log(aValues); // ["foo", "bar", "baz", "qux"]

console.log(aEntries); // [[0, "foo"], [1, "bar"], [2, "baz"], [3, "qux"]]

排序：reverse()和 sort()

reverse()反向排序， sort()会按照升序重新排列数组元素

或许最强大的数组方法就属 splice()

 删除。需要给 splice()传 2 个参数：要删除的第一个元素的位置和要删除的元素数量。可以从 数组中删除任意多个元素，比如 splice(0, 2)会删除前两个元素。

 插入。需要给 splice()传 3 个参数：开始位置、0（要删除的元素数量）和要插入的元素，可 以在数组中指定的位置插入元素。第三个参数之后还可以传第四个、第五个参数，乃至任意多 个要插入的元素。比如，splice(2, 0, "red", "green")会从数组位置 2 开始插入字符串 "red"和"green"。

 替换。splice()在删除元素的同时可以在指定位置插入新元素，同样要传入 3 个参数：开始位 置、要删除元素的数量和要插入的任意多个元素。要插入的元素数量不一定跟删除的元素数量 一致。比如，splice(2, 1, "red", "green")会在位置 2 删除一个元素，然后从该位置开始 向数组中插入"red"和"green"。

indexOf()、lastIndexOf()和 includes()

indexOf()和 lastIndexOf()都返回要查找的元素在数组中的位置，如果没找到则返回1。 includes()返回布尔值

let person = { name: "Nicholas" };

let people = [{ name: "Nicholas" }];

let morePeople = [person];

alert(people.indexOf(person)); // -1

alert(morePeople.indexOf(person)); // 0

alert(people.includes(person)); // false

alert(morePeople.includes(person)); // true

find()和 findIndex()方法使用了断言函数。

这两个方法都从数组的最小索引开始。

find()返回 第一个匹配的元素，findIndex()返回第一个匹配元素的索引。这两个方法也都接收第二个可选的参数， 用于指定断言函数内部 this 的值。

const people = [ { name: "Matt", age: 27 }, { name: "Nicholas", age: 29 } ]; alert(people.find((element, index, array) => element.age < 28));

// {name: "Matt", age: 27}

alert(people.findIndex((element, index, array) => element.age < 28)); // 0

找到匹配项后，这两个方法都不再继续搜索

数组的 5 个迭代方法

 every()：对数组每一项都运行传入的函数，如果对每一项函数都返回 true，则这个方法返回 true。

 filter()：对数组每一项都运行传入的函数，函数返回 true 的项会组成数组之后返回。

 forEach()：对数组每一项都运行传入的函数，没有返回值。

 map()：对数组每一项都运行传入的函数，返回由每次函数调用的结果构成的数组。

 some()：对数组每一项都运行传入的函数，如果有一项函数返回 true，则这个方法返回 true。 这些方法都不改变调用它们的数组

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];

let everyResult = numbers.every((item, index, array) => item > 2);

alert(everyResult); // false

let someResult = numbers.some((item, index, array) => item > 2);

alert(someResult); // true

let filterResult = numbers.filter((item, index, array) => item > 2);

alert(filterResult); // 3,4,5,4,3

let mapResult = numbers.map((item, index, array) => item * 2);

alert(mapResult); // 2,4,6,8,10,8,6,4,2

归并方法

reduce()和 reduceRight()

这两个方法都会迭代数 组的所有项，并在此基础上构建一个最终返回值。reduce()方法从数组第一项开始遍历到最后一项。 而 reduceRight()从最后一项开始遍历至第一项

这两个方法都接收两个参数：对每一项都会运行的归并函数，以及可选的以之为归并起点的初始值。

传给 reduce()和 reduceRight()的函数接收 4 个参数：上一个归并值、当前项、当前项的索引和数 组本身。这个函数返回的任何值都会作为下一次调用同一个函数的第一个参数。

如果没有给这两个方法 传入可选的第二个参数（作为归并起点值），则第一次迭代将从数组的第二项开始，因此传给归并函数 的第一个参数是数组的第一项，第二个参数是数组的第二项。

可以使用 reduce()函数执行累加数组中所有数值的操作，比如：

let values = [1, 2, 3, 4, 5];

let sum = values.reduce((prev, cur, index, array) => prev + cur); alert(sum); // 15

第一次执行归并函数时，prev 是 1，cur 是 2。第二次执行时，prev 是 3（1 + 2），cur 是 3（数 组第三项）。

reduceRight()方法与之类似，只是方向相反。