Object

到目前为止，大多数引用值的示例使用的是 Object 类型。Object 是 ECMAScript 中最常用的类型之一。虽然 Object 的实例没有多少功能，但很适合存储和在应用程序间交换数据。创建object实例有两种方式：

// new

let person = new Object();

person.name = "Nicholas";

person.age = 29;

// 对象字面量

let person = {

name: "Nicholas",

age: 29

};

注意：在使用对象字面量表示法定义对象时，并不会实际调用 Object 构造函数。

这种方式创建对象时，JavaScript引擎会在内存中直接分配一个新对象，并为其设置原型链（[[Prototype]]）指向Object.prototype。这种过程没有显式调用Object构造函数，而是通过引擎的内部机制直接生成

属性通过点语法和中括号来存取：

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

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

Array

数组是一个有序的数据，每个槽位可以存储任意类型的数据，并且大小是动态的，会随着数据添加而自动增长。

创建数据

创建数组的方式有以下几种：

Array 构造函数，可以有一个或多个参数，如果第一个参数是数字会创建一个初始length位该数字的数组，如果是其他则会创建含有该值的数组

let colors = new Array();

let colors = new Array(3); // 创建一个包含 3 个元素的数组

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

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

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

let names = []; // 创建一个空数组

let values = [1,2,]; // 创建一个包含 2 个元素的数组

ES6 新增创建数组静态方法1： from

from() 的第一个参数是一个类数组对象，即任何可迭代的结构，或者有一个 length 属性和可索引元素的结构,并且可以对现有数组进行浅复制。

// 字符串会被拆分为单字符数组

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]

Array.from()还接收第二个可选的映射函数参数。这个函数可以直接增强新数组的值，而无须像调用 Array.from().map()那样先创建一个中间数组。还可以接收第三个可选参数，用于指定映射函数中 this 的值。但这个重写的 this 值在箭头函数中不适用。

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]

ES6 新增创建数组静态方法2： of

可以把一组参数转换为数组：

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

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

数组空位

可以使用一串逗号来创建空位：

const options = [,,,,,]; // 创建包含 5 个元素的数组

console.log(options.length); // 5

console.log(options); // [,,,,,]

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

检测数组

检测数组的方法有两种 instancof和isArray：

if (value instanceof Array){

// 操作数组

}

if (Array.isArray(value)){

// 操作数组

}

迭代器方法

Array原型上暴露了三个检索数组内容的方法：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"]]

复制和填充方法

批量复制方法：copyWithin()，有三个参数，第一个是插入的索引位置，第二个是复制初始位置，第三个复制结束位置。注意：会修改有数组内容，但是不会改变大小，缺略超出边界内容。

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]

填充方法：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];

array剩余方法

因为数组方法较多，这里根据是否影响原数组来区区分。

改变原数组

方法名	功能	返回值
push()	结尾添加元素	返回新数组长度
unshift()	开头添加元素	返回新数组长度
pop()	删除数组最后一条元素	返回被删元素
shift()	删除数组第一条元素	返回被删元素
reverse()	反转数组	返回被反转元素
sort()	以字母顺序排序	返回排序后数组
splice()	实现数组任意位置的增删改	返回删除的数据组成的数组

// push

const arr = [1,2,3]

console.log(arr.push(4)) // 4 并且数组变成了[1,2,3,4]

// unshift

console.log(arr.unshift(0)) // 5 并且数组变成了 [0,1,2,3,4]

// pop

console.log(arr.pop()) // 4 并且数组变成了 [0,1,2,3]

// shift

console.log(arr.shift()) // 0 并且数组变成了 [1,2,3]

// reverse

console.log(arr.reverse()) // [3,2,1]

// sort

const arr2 = [10, 1, 5, 2]

console.log(arr2.sort()) // [1, 10, 2, 5] 并不是我们想要的结果，为它是根据unicode编码来排序的,这也显示了其不稳定性

// 我们可以使用sort的语法

arr2.sort((a,b)=> {

return a - b; // 如果 a - b > 0 ，那么a会被排到后面(从小到大) 反之 b - a > 0 b在后面后面，从大到小，

})

// splice 有三个参数第一个参数是索引，第二个元素是删除长度如果为0则不删，第三个是向数组添加的数据

const arr3 = [1, 2, 3, 4, 5];

const result = [];

result = arr3.splice(0,1,2);

console.log(arr3) // [2,2,3,4,5]

console.log(result ) // [2]

result = arr3.splice(0,0,2);

console.log(arr3) // [2,2,2,3,4,5]

console.log(result ) // []

不改变原数组

方法名	功能	返回值
concat()	通过合并现有数组创建一个新数组	返回合并后的数组
join()	用特定字符，将数组拼接成字符串	返回拼接后的字符串
slice()	裁切指定位置数组	被裁切后的新数组
toString()	将数组转换为用逗号隔开的字符串	转换后的字符串
valueOf()	查询数组原始值	数组的原始值
indexOf()	查询某个元素在数组中第一次出现的位置	存在返回索引，不存在返回-1
lastIndexOf()	反向查询某个元素在数组中第一次出现的位置	存在返回索引，不存在返回-1
forEach()	遍历数组，每次循环中执行传入的回调函数	无
map()	遍历数组，每次循环时执行传入的回调函数，根据回调函数的返回值生成新的数组	自定义
filter()	遍历数字，每次循环时执行传入的回调函数，回调函数返回一个条件，把满足条件的筛选出来放到新数组中	满足条件的生成新数组
every()	判断数组中所有的元素是否满足某个条件	全部满足返回true，否则false
some()	判断数组中是否存在或满足某个条件的元素	只要有一个元素满足条件就返回true，否则返回false
reduce()	遍历数组，每次循环时执行传入的回调函数，回调函数会返回一个值，将该值作为初始值prev，传入到下一次函数中	最终操作的结果
reduceRight()	用法同ruiduce，只不过时从右往左	最终操作的结果
includes()	判断一个数组是否包含一个指定的值	是返回了true，反则false
find()	遍历数组，执行回调函数，回调函数执行一个条件，返回满足条件的第一个元素，不存在返回undefined	返回满足条件的第一个元素，不存在返回undefined
findIndex()	遍历数组，执行回调函数，回调函数执行一个条件，返回满足条件的第一个元素索引，不存在返回-1	返回满足条件的第一个元素索引，不存在返回-1
flat()	用于将嵌套的数组扁平化，变成一维数组	返回新数组
flatMap()	flat()和map()的组合版 , 先通过map()返回一个新数组,再将数组拉平( 只能拉平一次	返回新数字

// concat 可以有一个或多个参数

const arr = [1,2,3,4,5]

const concatTest = arr.concar([6, 7], [8])

console.log(concatTest) // [1,2,3,4,5,6,7,8]

// join

const joinTest = arr.join('_')

console.log(joinTest) // 1_2_3_4_5

//slice 有两个参数第一个是起始索引，第二个是结束索引但不包含结束索引的值

console.log(arr.slice(1, 3)) // [2,3]

// toString

console.log(arr.toString()) // 1,2,3,4

// valueOf 返回本身

console.log(arr.valueOf()) // [1,2,3,4,5]

// indexOf

console.log(arr.indexOf(3)) // 2

console.log(arr.indexOf('3')) // -1

// lastIndexOf

console.log(arr.lastIndexOf(5)) // 4

console.log(arr.lastIndexOf('5')) // -1

// forEach 回调函数中有三个参数第一个是当前值第二个是当前索引第三个整个数组没有返回值

const forEachTest = arr.forEach((item, index, thisArr) => {})

console.log(forEachTest ) // undefined

// map 跟forEach一样但是有返回值并且可以自定义

const MapTest = arr.map((item, index, thisArr) => {

return item * 2

})

console.log(MapTest) // [2, 4, 6, 8, 10]

// filter 跟forEach 一样但是有返回值但是返回值必须是通过某个条件的值

const filterTest = arr.filter((item, index, thisArr) => {

return item > 2

})

console.log(filterTest ) // [3, 4, 5]

// every 跟forEach 一样但是有返回值必须是所有的值都通过条件会返回true 反之 false

const everyTest = arr.every((item, index, thisArr) => {

return item > 3

})

console.log(everyTest) // false

// some 跟forEach 一样但是有返回值只要有一个值通过条件会返回true 反之 false

const someTest = arr.some((item, index, thisArr) => {

return item > 3

})

console.log(someTest ) // true

// find 跟forEach 一样但是有返回值返回第一个满足条件的元素的值

const findTest = arr.find((item, index, thisArr) => {

return item > 3

})

console.log(findTest ) // 4

// findIndex 跟forEach 一样但是有返回值返回第一个满足条件的元素的索引，索然感觉跟indexOf很像都是返回索引，但是findIndex 根据条件，indexOf 是根据值

const findTest = arr.findIndex((item, index, thisArr) => {

return item > 3

})

console.log(findTest ) // 3

// reduce 跟forEach 一样,但是多个值prev初始值,每次循环可以对处置进行计算并返回，不返回会成为undefined, 返回值是这个值

// 初始值可以自定义，不自定义会成为数组中的第一个值并且循环从第二索引开始，自定从第一个开始

const reduceTest = arr.reduce((prev,item, index, thisArr) => {

return {

name: prev.name + item

}

}, {name: 1})

console.log(reduceTest) // { name: 16 }

// reduceRight 跟 reduce相同只是顺序是从右往左

// includes 包含返回 true 不包含返回 false

console.log(arr.includes(1)) // true

console.log(arr.includes('1')) //

// flat 扁平化处理可以多次

const list = [1, 2, [3, 4, [5]]];

const arr = list.flat(); // 默认拉平一次

console.log("拉平一次", arr); // [1,2,3,4,[5]]

const arr = list.flat(2); // 拉平2次

console.log("拉平两次", arr); [1,2,3,4,5]

Map

基本用法

使用new关键字和Map构造函数创建

const map = new Map();

const m1 = new Map([

["key1", "val1"],

["key2", "val2"],

["key3", "val3"]

]);

使用set添加键值对，还有has来进行查询，get来获取，可以通过size获取键值对数量，可以通过delete来删除某一条键值对和clear()清理所有的

const m = new Map();

alert(m.has("firstName")); // false

alert(m.get("firstName")); // undefined

alert(m.size); // 0

m.set("firstName", "Matt")

.set("lastName", "Frisbie");

alert(m.has("firstName")); // true

alert(m.get("firstName")); // Matt

alert(m.size); // 2

m.delete("firstName"); // 只删除这一个键/值对

alert(m.has("firstName")); // false

alert(m.has("lastName")); // true

alert(m.size); // 1

m.clear(); // 清除这个映射实例中的所有键/值对

alert(m.has("firstName")); // false

alert(m.has("lastName")); // false

alert(m.size); // 0

const m2 = new Map().set("key1", "val1");

m2 set("key2", "val2")

.set("key3", "val3");

alert(m2.size); // 3

顺序与迭代

与Object类型的主要差异是，Map实例会维护键值对的插入顺序，因此可以根据插入顺序执行迭代操作。

映射实例可以提供一个迭代器（Iterator），能以插入顺序生成[key, value]形式的数组。可以通过 entries()方法（或者 Symbol.iterator 属性，它引用 entries()）取得这个迭代器。

["key1", "val1"],

["key2", "val2"],

["key3", "val3"]

]);

alert(m.entries === m[Symbol.iterator]); // true

for (let pair of m.entries()) {

alert(pair);

}

// [key1,val1]

// [key2,val2]

// [key3,val3]

for (let pair of m[Symbol.iterator]()) {

alert(pair);

}

// [key1,val1]

// [key2,val2]

// [key3,val3]

因为 entries()是默认迭代器，所以可以直接对映射实例使用扩展操作，把映射转换为数组：

const m = new Map([

["key1", "val1"],

["key2", "val2"],

["key3", "val3"]

]);

console.log([...m]); // [[key1,val1],[key2,val2],[key3,val3]]

注意：键和值在遍历时可以修改，但是映射内部的引用则无法修改。

["key1", "val1"]

]);

// 作为键的字符串原始值是不能修改的

for (let key of m1.keys()) {

key = "newKey";

alert(key); // newKey

alert(m1.get("key1")); // val1

}

Object与Map区别

内存占用方面：在不同的浏览器的情况不同，Map大约可以比Object多存储50%的键值对。
插入性能方面：双方的消耗大致相当，插入的速度不会随之键值对数量而线性增加，如果涉及大量插入操作，显然Map的性能更加。
查找速度方面：如果包含的键值对数量较少Object速度有时会更快，在某些情况下使用Object情况更好。
删除性能：使用 delete 删除 Object 属性的性能一直以来饱受诟病，目前在很多浏览器中仍然如此。为此，出现了一些伪删除对象属性的操作，包括把属性值设置为 undefined 或 null。但很多时候，这都是一种讨厌的或不适宜的折中。而对大多数浏览器引擎来说，Map 的 delete()操作都比插入和查找更快。如果代码涉及大量删除操作，那么毫无疑问应该选择 Map。
键符号：object只能使用数值，字符串或符号，但是Map可以使用任何JS数据类型作为键。

WeakMap

ECMAScript 6 新增的“弱映射”（WeakMap）是一种新的集合类型，为这门语言带来了增强的键/值对存储机制。WeakMap 是 Map 的“兄弟”类型，其 API 也是 Map 的子集。WeakMap 中的“weak”（弱），描述的是 JavaScript 垃圾回收程序对待“弱映射”中键的方式。

基本API

可以使用new关键字实例化一个空的WeakMap：

const wk = new WeakMap();

弱映射中的键只能是Object或者继承自Object的类型，尝试使用非对象设置键会抛出TypeError，值没有限制。

如果想在初始化时填充弱映射，则构造函数可以接收一个可迭代对象，其中需要包含键/值对数组。可迭代对象中的每个键/值都会按照迭代顺序插入新实例中：

const key1 = {id: 1},

key2 = {id: 2},

key3 = {id: 3};

// 使用嵌套数组初始化弱映射

const wm1 = new WeakMap([

[key1, "val1"],

[key2, "val2"],

[key3, "val3"]

]);

alert(wm1.get(key1)); // val1

alert(wm1.get(key2)); // val2

alert(wm1.get(key3)); // val3

// 初始化是全有或全无的操作

// 只要有一个键无效就会抛出错误，导致整个初始化失败

const wm2 = new WeakMap([

[key1, "val1"],

["BADKEY", "val2"],

[key3, "val3"]

]);

// TypeError: Invalid value used as WeakMap key

typeof wm2;

// ReferenceError: wm2 is not defined

// 原始值可以先包装成对象再用作键

const stringKey = new String("key1");

const wm3 = new WeakMap([

stringKey, "val1"

]);

alert(wm3.get(stringKey)); // "val1"

初始化后可以使用set添加键值对，get获取键值对，has查询和使用delete删除：

const wm = new WeakMap();

const key1 = {id: 1},

key2 = {id: 2};

alert(wm.has(key1)); // false

alert(wm.get(key1)); // undefined

wm.set(key1, "Matt")

.set(key2, "Frisbie");

alert(wm.has(key1)); // true

alert(wm.get(key1)); // Matt

wm.delete(key1); // 只删除这一个键/值对

alert(wm.has(key1)); // false

alert(wm.has(key2)); // true

set()方法返回弱映射实例，因此可以把多个操作连缀起来，包括初始化声明：

const key1 = {id: 1},

key2 = {id: 2},

key3 = {id: 3};

const wm = new WeakMap().set(key1, "val1");

wm.set(key2, "val2")

.set(key3, "val3");

alert(wm.get(key1)); // val1

alert(wm.get(key2)); // val2

alert(wm.get(key3)); // val3

弱键

WeakMap中Weak代表着弱弱的拿着，这些键不属于正式的引用，不会阻止垃圾回收。

const wm = new WeakMap();

wm.set({}, "val");

set()方法初始化了一个新对象并将它用作一个字符串的键。因为没有指向这个对象的其他引用，所以当这行代码执行完成后，这个对象键就会被当作垃圾回收。然后，这个键/值对就从弱映射中消失了，使其成为一个空映射。在这个例子中，因为值也没有被引用，所以这对键/值被破坏以后，值本身也会成为垃圾回收的目标。

const wm = new WeakMap();

const container = {

key: {}

};

wm.set(container.key, "val");

function removeReference() {

container.key = null;

}

这一次，container 对象维护着一个对弱映射键的引用，因此这个对象键不会成为垃圾回收的目标。不过，如果调用了 removeReference()，就会摧毁键对象的最后一个引用，垃圾回收程序就可以把这个键/值对清理掉。

不可迭代键

因为WeakMap中的键值对随时都可能被销毁，所以没必要提供迭代键值对的能力。

clear()这种方法也是一样的。

使用弱映射

有很多种使用方法可以探寻，这里提供两种使用案例：

私有变量：

弱映射造就了在 JavaScript 中实现真正私有变量的一种新方式。前提很明确：私有变量会存储在弱映射中，以对象实例为键，以私有成员的字典为值。下面是一个示例实现：

const wm = new WeakMap();

class User {

constructor(id) {

this.idProperty = Symbol('id');

this.setId(id);

}

setPrivate(property, value) {

const privateMembers = wm.get(this) || {};

privateMembers[property] = value;

wm.set(this, privateMembers);

}

getPrivate(property) {

return wm.get(this)[property];

}

setId(id) {

this.setPrivate(this.idProperty, id);

}

getId() {

return this.getPrivate(this.idProperty);

}

}

const user = new User(123);

alert(user.getId()); // 123

user.setId(456);

alert(user.getId()); // 456

// 并不是真正私有的

alert(wm.get(user)[user.idProperty]); // 456

对于上面的实现，外部代码只需要拿到对象实例的引用和弱映射，就可以取得“私有”变量了。为了避免这种访问，可以用一个闭包把 WeakMap 包装起来，这样就可以把弱映射与外界完全隔离开了：

const User = (() => {

const wm = new WeakMap();

class User {

constructor(id) {

this.idProperty = Symbol('id');

this.setId(id);

}

setPrivate(property, value) {

const privateMembers = wm.get(this) || {};

privateMembers[property] = value;

wm.set(this, privateMembers);

}

getPrivate(property) {

return wm.get(this)[property];

}

setId(id) {

this.setPrivate(this.idProperty, id);

}

getId(id) {

return this.getPrivate(this.idProperty);

}

}

return User;

})();

const user = new User(123);

alert(user.getId()); // 123

user.setId(456);

alert(user.getId()); // 456

这样，拿不到弱映射中的健，也就无法取得弱映射中对应的值。虽然这防止了前面提到的访问，但整个代码也完全陷入了 ES6 之前的闭包私有变量模式。

DOM节点元数据

因为WeakMap不会妨碍垃圾回收，非常适合保存关联元数据，比如Dom元素保存在Map种如果Dom切换了，映射还是保存在Map中，除非等到Map删除或者映射本身被销毁，而WeakMap不同会立刻是释放。

const m = new Map();

const loginButton = document.querySelector('#login');

// 给这个节点关联一些元数据

m.set(loginButton, {disabled: true});

const wm = new WeakMap();

const loginButton = document.querySelector('#login');

// 给这个节点关联一些元数据

wm.set(loginButton, {disabled: true});

Set

是一种新集合类型，Set在很多方面都像是加强的Map，他们大多数API都是共有的。

基本使用

使用new关键字和Set构造函数可以创建一个空集合：

const m = new Set();

const s1 = new Set(["val1", "val2", "val3"]);

初始化后可以使用add()新增值，has查询，size取元素数量以及使用delete和clear删除元素：

const s = new Set();

alert(s.has("Matt")); // false

alert(s.size); // 0

s.add("Matt")

.add("Frisbie");

alert(s.has("Matt")); // true

alert(s.size); // 2

s.delete("Matt");

alert(s.has("Matt")); // false

alert(s.has("Frisbie")); // true

alert(s.size); // 1

s.clear(); // 销毁集合实例中的所有值

alert(s.has("Matt")); // false

alert(s.has("Frisbie")); // false

alert(s.size); // 0

// add()返回集合的实例，所以可以将多个添加操作连缀起来，包括初始化：

const s = new Set().add("val1");

s.add("val2")

.add("val3");

alert(s.size); // 3

//add()和 delete()操作是幂等的。delete()返回一个布尔值，表示集合中是否存在要删除的值：

const s = new Set();

s.add('foo');

alert(s.size); // 1

s.add('foo');

alert(s.size); // 1

// 集合里有这个值

alert(s.delete('foo')); // true

// 集合里没有这个值

alert(s.delete('foo')); // false

顺序与迭代：

Set会维护值插入时的顺序，因此支持按顺序迭代。

集合实例可以提供一个迭代器（Iterator），能以插入顺序生成集合内容。可以通过 values()方法及其别名方法 keys()（或者 Symbol.iterator 属性，它引用 values()）取得这个迭代器：

const s = new Set(["val1", "val2", "val3"]);

alert(s.values === s[Symbol.iterator]); // true

alert(s.keys === s[Symbol.iterator]); // true

for (let value of s.values()) {

alert(value);

}

// val1

// val2

// val3

for (let value of s[Symbol.iterator]()) {

alert(value);

}

// val1

// val2

// val3

因为 values()是默认迭代器，所以可以直接对集合实例使用扩展操作，把集合转换为数组：

const s = new Set(["val1", "val2", "val3"]);

console.log([...s]); // ["val1", "val2", "val3"]

集合的 entries()方法返回一个迭代器，可以按照插入顺序产生包含两个元素的数组，这两个元素是集合中每个值的重复出现：

const s = new Set(["val1", "val2", "val3"]);

for (let pair of s.entries()) {

console.log(pair);

}

// ["val1", "val1"]

// ["val2", "val2"]

// ["val3", "val3"]

如果不使用迭代器，而是使用回调方式，则可以调用集合的 forEach()方法并传入回调，依次迭代每个键/值对。传入的回调接收可选的第二个参数，这个参数用于重写回调内部 this 的值：

const s = new Set(["val1", "val2", "val3"]);

s.forEach((val, dupVal) => alert(`${val} -> ${dupVal}`));

// val1 -> val1

// val2 -> val2

// val3 -> val3

修改集合中值的属性不会影响其作为集合值的身份：

const s1 = new Set(["val1"]);

// 字符串原始值作为值不会被修改

for (let value of s1.values()) {

value = "newVal";

alert(value); // newVal

alert(s1.has("val1")); // true

}

const valObj = {id: 1};

const s2 = new Set([valObj]);

// 修改值对象的属性，但对象仍然存在于集合中

for (let value of s2.values()) {

value.id = "newVal";

alert(value); // {id: "newVal"}

alert(s2.has(valObj)); // true

}

alert(valObj); // {id: "newVal"}

不会出现重复值

因为Set会自动去除重复值，所以常常用作数组去重

const arr = [1,3,5,1,5]

console.log([...new Set(arr)]) // [1, 3, 5]

WeakSet

操作方式和Set相同，定义和WeakMap差不多

原文：JavaScript 高级程序设计(第四版)