JavaScript高级程序设计(第4版)-第六章 集合引用类型---部分

6.1 Object

Object 的实例没有多少功能，但很适合存储和在应用程序间交换数据。

6.1.1 创建Object—使用 new 操作符和 Object 构造函数

let person = new Object(); 
person.name = "Nicholas"; 
person.age = 29; 

6.1.2 创建Object—使用对象字面量表示法

在对象字面量表示法中，属性名可以是字符串或数值
在使用对象字面量表示法定义对象时，并不会实际调用 Object 构造函数。

let person = { 
 name: "Nicholas", 
 age: 29 
}; 

也可以用对象字面量表示法来定义一个只有默认属性和方法的对象

let person = {}; // 与 new Object()相同
person.name = "Nicholas"; 
person.age = 29; 

实际上开发者更倾向于使用对象字面量表示法

对象字面量已经成为给函数传递大量可选参数的主要方式

function displayInfo(args) { 
	 let output = ""; 
	 if (typeof args.name == "string"){ 
		 output += "Name: " + args.name + "\n"; 
	 } 
	 if (typeof args.age == "number") { 
		 output += "Age: " + args.age + "\n"; 
	 } 
	 alert(output); 
} 

displayInfo({ 
 name: "Nicholas", 
 age: 29 
}); 

displayInfo({ 
 name: "Greg" 
}); 

这种模式非常适合函数有大量可选参数的情况。一般来说，命名参数更直观，但在可选参数过多的时候就显得笨拙了。最好的方式是对必选参数使用命名参数，再通过一个对象字面量来封装多个可选参数。

6.1.3 属性存取— 点语法或中括号

console.log(person["name"]); // "Nicholas" 
console.log(person.name); // "Nicholas"

通常，点语法是首选的属性存取方式，除非访问属性时必须使用变量。

中括号的优势：

• 可以通过变量访问属性
• 属性名中包含可能会导致语法错误的字符，或者包含关键字/保留字时，只能使用中括号方法

let propertyName = "name"; 
console.log(person[propertyName]); // "Nicholas" 

person["first name"] = "Nicholas"; 

6.2 Array

跟其他语言中的数组一样，ECMAScript 数组也是一组有序的数据 。
跟其他语言不同的是，数组中每个槽位可以存储任意类型的数据。这意味着可以创建一个数组，它的第一个元素是字符串，第二个元素是数值，第三个是对象。
ECMAScript 数组也是动态大小的，会随着数据添加而自动增长。

6.2.1 创建数组

1. 使用Array构造函数

• length 属性表示数组元素的数量
• 给 Array 构造函数传入要保存的元素
• 可以省略 new 操作符

let colors = new Array();

let colors = new Array(3); // 创建一个包含 3 个元素的数组
let names = new Array("Greg"); // 创建一个只包含一个元素，即字符串"Greg"的数组

let colors = Array(3); // 创建一个包含 3 个元素的数组
let names = Array("Greg"); // 创建一个只包含一个元素，即字符串"Greg"的数

2. 使用数组字面量
与对象一样，在使用数组字面量表示法创建数组不会调用 Array 构造函数。

let colors = ["red", "blue", "green"]; // 创建一个包含 3 个元素的数组
let names = []; // 创建一个空数组
let values = [1,2,]; // 创建一个包含 2 个元素的数组

Array 构造函数还有两个 ES6 新增的用于创建数组的静态方法：from()和 of()

3. ES6新增 from()
from()用于将类数组结构转换为数组实例

• 第一个参数是一个类数组对象，即任何可迭代的结构，或者有一个 length 属性和可索引元素的结构
• 第二个可选的映射函数参数。这个函数可以直接增强新数组的值，而无须像调用 Array.from().map()那样先创建一个中间数组
• 第三个可选参数，用于指定映射函数中 this 的值。但这个重写的 this 值在箭头函数中不适用

// 字符串会被拆分为单字符数组
console.log(Array.from("Matt")); // ["M", "a", "t", "t"] 

// 可以使用 from()将集合和映射转换为一个新数组
const m = new Map().set(1, 2) 
 .set(3, 4); 
const s = new Set().add(1) 
 .add(2) 
 .add(3) 
 .add(4); 
console.log(Array.from(m)); // [[1, 2], [3, 4]] 
console.log(Array.from(s)); // [1, 2, 3, 4] 

// Array.from()对现有数组执行浅复制
const a1 = [1, 2, 3, 4]; 
const a2 = Array.from(a1); 
console.log(a1); // [1, 2, 3, 4] 
alert(a1 === a2); // false 

// 可以使用任何可迭代对象
const iter = { 
 *[Symbol.iterator]() { 
 yield 1; 
 yield 2; 
 yield 3; 
 yield 4; 
 } 
}; 
console.log(Array.from(iter)); // [1, 2, 3, 4] 

// arguments 对象可以被轻松地转换为数组
function getArgsArray() { 
 return Array.from(arguments); 
} 
console.log(getArgsArray(1, 2, 3, 4)); // [1, 2, 3, 4] 

// from()也能转换带有必要属性的自定义对象
const arrayLikeObject = { 
 0: 1, 
 1: 2, 
 2: 3, 
 3: 4, 
 length: 4 
}; 
console.log(Array.from(arrayLikeObject)); // [1, 2, 3, 4] 

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]

4. ES6新增 of()
of()用于将一组参数转换为数组实例
用于替代在 ES6之前常用的 Array.prototype. slice.call(arguments)

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

6.2.2 数组空位

使用数组字面量初始化数组时，可以使用一串逗号来创建空位（hole）。
ES6 新增的方法和迭代器与早期 ECMAScript 版本中存在的方法行为不同。

ES6 新增方法普遍将这些空位当成存在的元素，只不过值为 undefined

const options = [1,,,,5]; 
for (const option of options) { 
 console.log(option === undefined); 
} 
// false 
// true 
// true 
// true 
// false 

ES6 之前的方法则会忽略这个空位，但具体的行为也会因方法而异

const options = [1,,,,5]; 
// map()会跳过空位置
console.log(options.map(() => 6)); // [6, undefined, undefined, undefined, 6] 
// join()视空位置为空字符串
console.log(options.join('-')); // "1----5" 

由于行为不一致和存在性能隐患，因此实践中要避免使用数组空位。如果确实需要空位，则可以显式地用 undefined 值代替。

6.2.3 数组索引

要取得或设置数组的值，需要使用中括号并提供相应值的数字索引，在中括号中提供的索引表示要访问的值。

• 如果索引小于数组包含的元素数，则返回存储在相应位置的元素
• 如果索引大于数组包含的元素数，则数组元素会自动扩展到该索引值加 1

let colors = ["red", "blue", "green"]; // 定义一个字符串数组
alert(colors[0]); // 显示第一项
colors[2] = "black"; // 修改第三项
colors[3] = "brown"; // 添加第四项

数组元素的length属性:

• 存储元素的数量
• 不是只读的, 可以通过修改length属性, 从数组末尾删除或添加元素
• 使用 length 属性可以方便地向数组末尾添加元素

let colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors.length = 2;  // 删除了最后一个元素
alert(colors[2]); // undefined

colors.length = 4;   // 新添加的元素都将以undefined 填充
alert(colors[3]); // undefined

数组中最后一个元素的索引始终是 length - 1，因此下一个新增槽位的索引就是 length。数组的 length 属性都会自动更新，以反映变化

let colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
colors[colors.length] = "black"; // 添加一种颜色（位置 3）
colors[colors.length] = "brown"; // 再添加一种颜色（位置 4）

6.2.4 检测数组

Q: 如何判断一个对象是不是数组

在只有一个网页（因而只有一个全局作用域）的情况下，使用 instanceof 操作符

if (value instanceof Array){ 
 // 操作数组
} 

Array.isArray()方法, 是确定一个值是否为数组，而不用管它是在哪个全局执行上下文中创建的

if (Array.isArray(value)){ 
 // 操作数组
}

6.2.5 迭代器方法

在 ES6 中，Array 的原型上暴露了 3 个用于检索数组内容的方法：keys()、values()和entries()。

• 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"]]

使用 ES6 的解构可以非常容易地在循环中拆分键/值对

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

for (const [idx, element] of a.entries()) { 
 alert(idx); 
 alert(element); 
} 
// 0 
// foo 
// 1 
// bar 
// 2 
// baz 
// 3 
// qux

6.2.6 复制和填充方法

填充数组方法 fill():

• 向一个已有的数组中插入全部或部分相同的值
• 开始索引用于指定开始填充的位置，它是可选的, 不提供则填充所有
• 需要指定既有数组实例上的一个范围，包含开始索引，不包含结束索引
• 负值索引从数组末尾开始计算。也可以将负索引想象成数组长度加上它得到的一个正索引
• 静默忽略超出数组边界、零长度及方向相反的索引范围

const zeroes = [0, 0, 0, 0, 0]; 

// 用 5 填充整个数组
zeroes.fill(5); 
console.log(zeroes); // [5, 5, 5, 5, 5] 
zeroes.fill(0); // 重置

// 用 6 填充索引大于等于 3 的元素
zeroes.fill(6, 3); 
console.log(zeroes); // [0, 0, 0, 6, 6] 
zeroes.fill(0); // 重置

// 用 7 填充索引大于等于 1 且小于 3 的元素
zeroes.fill(7, 1, 3); 
console.log(zeroes); // [0, 7, 7, 0, 0]; 
zeroes.fill(0); // 重置

// 用 8 填充索引大于等于 1 且小于 4 的元素
// (-4 + zeroes.length = 1) 
// (-1 + zeroes.length = 4) 
zeroes.fill(8, -4, -1); 
console.log(zeroes); // [0, 8, 8, 8, 0]; 

const zeroes = [0, 0, 0, 0, 0]; 
// 索引过低，忽略
zeroes.fill(1, -10, -6); 
console.log(zeroes); // [0, 0, 0, 0, 0] 
// 索引过高，忽略
zeroes.fill(1, 10, 15); 
console.log(zeroes); // [0, 0, 0, 0, 0] 
// 索引反向，忽略
zeroes.fill(2, 4, 2); 
console.log(zeroes); // [0, 0, 0, 0, 0] 
// 索引部分可用，填充可用部分
zeroes.fill(4, 3, 10) 
console.log(zeroes); // [0, 0, 0, 4, 4] 

批量复制方法copyWithin()

• 会按照指定范围浅复制数组中的部分内容，然后将它们插入到指定索引开始的位置
• 开始索引和结束索引则与 fill()使用同样的计算方法
• 第一个参数是插入位置
• 静默忽略超出数组边界、零长度及方向相反的索引范围

let ints, 
 reset = () => ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 

// 从 ints 中复制索引 0 开始的内容，插入到索引 5 开始的位置
// 在源索引或目标索引到达数组边界时停止
ints.copyWithin(5); 
console.log(ints); // [0, 1, 2, 3, 4, 0, 1, 2, 3, 4] 
reset(); 

// 从 ints 中复制索引 5 开始的内容，插入到索引 0 开始的位置
ints.copyWithin(0, 5); 
console.log(ints); // [5, 6, 7, 8, 9, 5, 6, 7, 8, 9] 
reset(); 

// 从 ints 中复制索引 0 开始到索引 3 结束的内容
// 插入到索引 4 开始的位置
ints.copyWithin(4, 0, 3); 
alert(ints); // [0, 1, 2, 3, 0, 1, 2, 7, 8, 9] 
reset(); 

// JavaScript 引擎在插值前会完整复制范围内的值
// 因此复制期间不存在重写的风险
ints.copyWithin(2, 0, 6); 
alert(ints); // [0, 1, 0, 1, 2, 3, 4, 5, 8, 9] 
reset(); 

// 支持负索引值，与 fill()相对于数组末尾计算正向索引的过程是一样的
ints.copyWithin(-4, -7, -3); 
alert(ints); // [0, 1, 2, 3, 4, 5, 3, 4, 5, 6] 

let ints, 
 reset = () => ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 
// 索引过低，忽略
ints.copyWithin(1, -15, -12); 
alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset() 
// 索引过高，忽略
ints.copyWithin(1, 12, 15); 
alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 
// 索引反向，忽略
ints.copyWithin(2, 4, 2); 
alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
reset(); 
// 索引部分可用，复制、填充可用部分
ints.copyWithin(4, 7, 10) 
alert(ints); // [0, 1, 2, 3, 7, 8, 9, 7, 8, 9];

6.2.7 转换方法

所有对象都有 toLocaleString()、toString()和 valueOf()方法

• valueOf()返回的还是数组本身
• toString()返回由数组中每个值的等效字符串拼接而成的一个逗号分隔的字符串。也就是说，对数组的每个值都会调用其toString()方法，以得到最终的字符串
• toLocaleString()方法也可能返回跟 toString()和 valueOf()相同的结果，但也不一定。在调用数组的 toLocaleString()方法时，会得到一个逗号分隔的数组值的字符串。它与另外两个方法唯一的区别是，为了得到最终的字符串，会调用数组每个值的 toLocaleString()方法，而不是toString()方法

let colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.valueOf()); // red,blue,green 
alert(colors.toString()); // red,blue,green 
alert(colors); // red,blue,green alert()期待字符串，所以会在后台调用数组的 toString()方法

let person1 = { 
 toLocaleString() { 
 return "Nikolaos"; 
 }, 
 toString() { 
 return "Nicholas"; 
 } 
}; 

let person2 = { 
 toLocaleString() { 
 return "Grigorios"; 
 }, 
 toString() { 
 return "Greg"; 
 } 
}; 

let people = [person1, person2]; 
alert(people); // Nicholas,Greg  会在数组每一项上调用 toString()方法,与下一行显式调用相同
alert(people.toString()); // Nicholas,Greg 
alert(people.toLocaleString()); // Nikolaos,Grigorios 

join()方法接收一个参数，即字符串分隔符，返回包含所有项的字符串
如果不给 join()传入任何参数，或者传入 undefined，则仍然使用逗号作为分隔符

let colors = ["red", "green", "blue"]; 
alert(colors.join(",")); // red,green,blue  得到了与调用 toString()方法相同的结果
alert(colors.join("||")); // red||green||blue

如果数组中某一项是 null 或 undefined，则在 join()、toLocaleString()、toString()和 valueOf()返回的结果中会以空字符串表示。

6.2.8 栈方法

ECMAScript 给数组提供几个方法，让它看起来像是另一种数据结构。

栈: 先进后出（FILO，First-In-Last-Out）, 数据项的插入（称为推入，push）和删除（称为弹出，pop）只在栈的一个地方发生，即栈顶。

push()方法接收任意数量的参数，并将它们添加到数组末尾，返回数组的最新长度。
pop()方法则用于删除数组的最后一项，同时减少数组的 length 值，返回被删除的项。
是数组的默认方法,可以与数组的其他任何方法一起使用。

let colors = ["red", "blue"]; 

colors.push("brown"); // 再添加一项
colors[3] = "black"; // 添加一项
alert(colors.length); // 4 

let item = colors.pop(); // 取得最后一项
alert(item); // black 

6.2.9 队列方法

当作队列来使用

队列以先进先出（FIFO，First-In-First-Out）形式限制访问。队列在列表末尾添加数据，但从列表开头获取数据。

push()方法在数组末尾添加数据
shift()方法删除数组的第一项并返回它，然后数组长度减 1
使用 shift()和 push()，可以把数组当成队列来使用

let colors = new Array(); // 创建一个数组
let count = colors.push("red", "green"); // 推入两项
alert(count); // 2 

count = colors.push("black"); // 再推入一项
alert(count); // 3 

let item = colors.shift(); // 取得第一项
alert(item); // red 
alert(colors.length); // 2 

相反方向模拟队列
unshift()方法执行跟 shift()相反的操作：在数组开头添加任意多个值，然后返回新的数组长度
pop()方法在数据末尾删除元素

let colors = new Array(); // 创建一个数组
let count = colors.unshift("red", "green"); // 从数组开头推入两项
alert(count); // 2 

count = colors.unshift("black"); // 再推入一项
alert(count); // 3 

let item = colors.pop(); // 取得最后一项
alert(item); // green 
alert(colors.length); // 2 

6.2.10 排序方法

注意 reverse()和 sort()都返回调用它们的数组的引用。

reverse()方法将数组元素反向排列
直观但不够灵活

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

sort()方法,按照升序重新排列数组元素, 最小值在前面, 最大值在后面

• 会在每一项上调用 String()转型函数，然后比较字符串来决定顺序。即使数组的元素都是数值，也会先把数组转换为字符串再比较、排序 ----> 也就是按照这些数值的字符串形式重新排序, 很多时候是不合适的
• 可以接收一个比较函数，用于判断哪个值应该排在前面
• 比较函数接收两个参数
  • 如果第一个参数应该排在第二个参数前面，就返回负值；
  • 如果两个参数相等，就返回 0；
  • 如果第一个参数应该排在第二个参数后面，就返回正值。

let values = [0, 1, 5, 10, 15]; 
values.sort(); 
alert(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, 5, 10, 15]; 
values.sort(compare); 
alert(values); // 0,1,5,10,15 

产生降序效果, 交换两个返回值

function compare(value1, value2) { 
	 if (value1 < value2) { 
	 	return 1; 
	 } else if (value1 > value2) { 
	 	return -1; 
	 } else { 
	 	return 0; 
	 } 
} 

let values = [0, 1, 5, 10, 15]; 
values.sort(compare); 
alert(values); // 15,10,5,1,0

简写为箭头函数

let values = [0, 1, 5, 10, 15]; 
values.sort((a, b) => a < b ? 1 : a > b ? -1 : 0); 
alert(values); // 15,10,5,1,0 

如果数组的元素是数值，或者是其 valueOf()方法返回数值的对象（如 Date 对象），这个比较函
数还可以写得更简单，因为这时可以直接用第二个值减去第一个值

function compare(value1, value2){ 
 return value2 - value1; 
}

比较函数就是要返回小于 0、0 和大于 0 的数值，因此减法操作完全可以满足要求。

6.2.11 操作方法

concat()方法可以在现有数组全部元素基础上创建一个新数组

• 不影响原始数组
• 首先会创建一个当前数组的副本，然后再把它的参数添加到副本末尾，最后返回这个新构建的数组。
• 如果传入一个或多个数组，则 concat()会把这些数组的每一项都添加到结果数组。
• 如果参数不是数组，则直接把它们添加到结果数组末尾。
• 默认是打平参数数组的
• 如果不想可以使用Symbol.isConcatSpreadable符号阻止打平参数数组, 将这个值设置为true可以强制打平

let colors = ["red", "green", "blue"]; 
let colors2 = colors.concat("yellow", ["black", "brown"]); 

console.log(colors); // ["red", "green","blue"] 
console.log(colors2); // ["red", "green", "blue", "yellow", "black", "brown"]

let colors = ["red", "green", "blue"]; 
let newColors = ["black", "brown"]; 

let moreNewColors = { 
 [Symbol.isConcatSpreadable]: true, 
 length: 2, 
 0: "pink", 
 1: "cyan" 
}; 

newColors[Symbol.isConcatSpreadable] = false; 

// 强制不打平数组
let colors2 = colors.concat("yellow", newColors); 

// 强制打平类数组对象
let colors3 = colors.concat(moreNewColors); 

console.log(colors); // ["red", "green", "blue"] 
console.log(colors2); // ["red", "green", "blue", "yellow", ["black", "brown"]] 
console.log(colors3); // ["red", "green", "blue", "pink", "cyan"]

slice()用于创建一个包含原有数组中一个或多个元素的新数组

• 可以接收一个或两个参数：返回元素的开始索引 和 结束索引。
• 如果只有一个参数，则 slice()会返回该索引到数组末尾的所有元素。
• 如果有两个参数，则 slice()返回从开始索引到结束索引对应的所有元素，其中不包含结束索引对应的元素。
• 如果 slice()的参数有负值，那么就以数值长度加上这个负值的结果确定位置。
• 如果结束位置小于开始位置，则返回空数组。
• 这个操作不影响原始数组。

let colors = ["red", "green", "blue", "yellow", "purple"]; 
let colors2 = colors.slice(1); 
let colors3 = colors.slice(1, 4); 
alert(colors2); // green,blue,yellow,purple 
alert(colors3); // green,blue,yellow 

splice()方法,主要目的是在数组中间插入元素。

删除

• 传2个参数
• 要删除的第一个元素的位置 和 要删除的元素数量
• 比如 splice(0, 2)会删除前两个元素

插入

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

替换

• 传3个参数
• 开始位置、要删除元素的数量和 要插入的任意多个元素
• 要插入的元素数量不一定跟删除的元素数量一致
• 比如，splice(2, 1, “red”, “green”)会在位置 2 删除一个元素，然后从该位置开始向数组中插入"red"和"green"。

始终返回这样一个数组，它包含从数组中被删除的元素（如果没有删除元素，则返回空数组）。

let colors = ["red", "green", "blue"]; 
let removed = colors.splice(0,1); // 删除第一项
alert(colors); // green,blue 
alert(removed); // red，只有一个元素的数组

removed = colors.splice(1, 0, "yellow", "orange"); // 在位置 1 插入两个元素
alert(colors); // green,yellow,orange,blue 
alert(removed); // 空数组

removed = colors.splice(1, 1, "red", "purple"); // 插入两个值，删除一个元素
alert(colors); // green,red,purple,orange,blue 
alert(removed); // yellow，只有一个元素的数组

6.2.12 搜索和位置方法

ECMAScript 提供两类搜索数组的方法：按严格相等搜索和按断言函数搜索。

1 严格相等

indexOf()所有版本中都可用

• 接收两个参数：要查找的元素和一个可选的起始搜索位置
• 从数组前头（第一项）开始向后搜索
• 返回要查找的元素在数组中的位置，如果没找到则返回1

lastIndexOf()所有版本中都可用

• 接收两个参数：要查找的元素和一个可选的起始搜索位置
• 从数组末尾（最后一项）开始向前搜索
• 返回要查找的元素在数组中的位置，如果没找到则返回1

includes()ECMAScript 7 新增

• 接收两个参数：要查找的元素和一个可选的起始搜索位置
• 从数组前头（第一项）开始向后搜索
• 返回布尔值，表示是否至少找到一个与指定元素匹配的项

在比较第一个参数跟数组每一项时，会使用全等（===）比较，也就是说两项必须严格相等。

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; 
alert(numbers.indexOf(4)); // 3 
alert(numbers.lastIndexOf(4)); // 5 
alert(numbers.includes(4)); // true 

alert(numbers.indexOf(4, 4)); // 5 
alert(numbers.lastIndexOf(4, 4)); // 3 
alert(numbers.includes(4, 7)); // false 

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 

2 断言函数

ECMAScript 也允许按照定义的断言函数搜索数组，每个索引都会调用这个函数。
断言函数的返回值决定了相应索引的元素是否被认为匹配。

接收3个参数:

• 元素: 数组中当前搜索的元素
• 索引: 当前元素的索引
• 数组本身: 正在搜索的数组

返回真值，表示是否匹配

find()方法

• 从数组的最小索引开始
• 返回第一个匹配的元素
• 接收第二个可选的参数, 用于指定断言函数内部this的值
• 找到匹配项后，不再继续搜索

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 

const evens = [2, 4, 6]; 
// 找到匹配后，永远不会检查数组的最后一个元素
evens.find((element, index, array) => { 
 console.log(element); 
 console.log(index); 
 console.log(array); 
 return element === 4; 
}); 
// 2 
// 0 
// [2, 4, 6] 
// 4 
// 1 
// [2, 4, 6] 

6.2.13 迭代方法

ECMAScript 为数组定义了 5 个迭代方法。
每个方法接收两个参数：以每一项为参数运行的函数，以及可选的作为函数运行上下文的作用域对象（影响函数中 this 的值）。
传给每个方法的函数接收 3个参数：数组元素、元素索引和数组本身。
这些方法都不改变调用它们的数组

every()方法

• 从数组中搜索符合某个条件的元素
• 对数组每一项都运行传入的函数，如果对每一项函数都返回 true，则这个方法返回 true

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 

filter()方法

• 基于给定的函数来决定某一项是否应该包含在它返回的数组中
• 对数组每一项都运行传入的函数，函数返回 true 的项会组成数组之后返回
• 适合从数组中筛选满足给定条件的元素

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; 
let filterResult = numbers.filter((item, index, array) => item > 2); 
alert(filterResult); // 3,4,5,4,3 

map()方法

• 对原始数组中同样位置的元素运行传入函数而返回的结果
• 对数组每一项都运行传入的函数，返回由每次函数调用的结果构成的数组
• 适合创建一个与原始数组元素一一对应的新数组

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; 
let mapResult = numbers.map((item, index, array) => item * 2); 
alert(mapResult); // 2,4,6,8,10,8,6,4,2 

forEach()方法

• 对数组每一项都运行传入的函数，没有返回值
• 本质上, 相当于使用 for 循环遍历数组

let numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1]; 
numbers.forEach((item, index, array) => { 
 // 执行某些操作 
}); 

6.2.14 归并方法

reduce()

• 迭代数组的所有项，并在此基础上构建一个最终返回值
• 从数组第一项开始遍历到最后一项

reduceRight()

• 迭代数组的所有项，并在此基础上构建一个最终返回值
• 从最后一项开始遍历至第一项

接收两个参数:

• 对每一项都会运行的归并函数, 接收4个参数
  • 上一个归并值
  • 当前项
  • 当前项的索引
  • 数组本身
  • 函数返回的任何值都会作为下一次调用同一个函数的第一个参数
• 可选的以之为归并起点的初始值

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

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（数组第三项）。

let values = [1, 2, 3, 4, 5]; 
let sum = values.reduceRight(function(prev, cur, index, array){ 
 return prev + cur; 
}); 
alert(sum); // 15 

究竟是使用 reduce()还是 reduceRight()，只取决于遍历数组元素的方向。除此之外，这两个方法没什么区别。