# **数组中 ** #
find() 找出第一个符合条件的数组成员 没有 返回undefined
findIndex()找出第一个符合条件的数组成员的下标 没有返回-1 可以发现NaN 弥补indexof的不足
rest参数 创建数组 该变量将多余的参数放入数组中 互为逆运算 扩展运算符 ...将一个数组转换为逗号分隔的参数序列
循环用for of
数组去重 [...new Set([1,2,3,4,4,4,5])]
Array.from(new Set(arr))
es6的新特性
简洁：
允许直接写入变量和函数 作为对象的属性和方法 这样书写更为简洁
紧密：
第七种数据类型Symbol 表示独一无二的值，用于区别对象中相同的属性及值
新增的两种数据结构 Set Map
const 申明一个只读的常量 声明时必须赋值 一旦申明 值就不能更改 不存在变量提升，同样存在暂时性死区，同样不可以重复声明
let 拥有块级作用域，不存在变量提升，不允许在相同的作用域下 重复申明同一个变量 不能在函数内部重新申明参数
## Set 没有重复值的类似于数组的一种数据集合 ##
set属性 构造函数 constructor 成员数size
set四个操作方法 :
//Set四个操作方法。
// • add(value)：添加某个值，返回Set结构本身。
// • delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
// • has(value)：返回一个布尔值，表示该值是否为Set的成员。
// • clear()：清除所有成员，没有返回值。
// 四个遍历方法，可以用于遍历成员。for of 遍历Set
// • keys()：返回键名的遍历器 键名的集合
// • values()：返回键值的遍历器 键值的集合
// • entries()：返回键值对的遍历器 名值对的集合
// • forEach()：使用回调函数遍历每个成员
Array.from()将两类对象转换为真正的数组, 两类对象-类似数组的对象和可遍历的对象Itearator接口 Set Map
Array.of() 将一组值转换为数组 可以替代Array() new Array()
find() 找出第一个符合条件的数组成员 没有 返回undefined
findIndex()找出第一个符合条件的数组成员的下标 没有返回-1 可以发现NaN 弥补indexof的不足
Map 键值对的集合 键值对的一种数据结构 键可以是各种类型的数据结构
// Object 本质也是键值对的集合 Hash结构 只能用字符串当做键
// Map五个操作方法 :
//操作方法。
// • set() get()
// • delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
// • has(value)：返回一个布尔值，表示该值是否为Set的成员。
// • clear()：清除所有成员，没有返回值。
js预解析，全盘扫描，没有定义先使用的变量定义为undefined，没有调用就使用的函数，把定义该函数的字符串赋值给该函数名；参数
es6新特性：
Symbol 表示独一无二的值 第七种数据类型 产生 区别对象中相同的属性及值
允许直接写入变量和函数 作为对象的属性和方法 这样书写更为简洁
set map 允许我们使用箭头来定义函数
扩展运算符，将一个数组转换为逗号分隔的参数序列
rest参数 形式(...变量名) 获取函数的所有参数 rest参数搭配的变量是一个数组的话 该变量将多余的参数放入数组中
严谨性，let声明变量，const声明常量，块级作用域的问题 避免了全局污染，js预解析
promise 的状态
解构赋值
number bool 对象
for of Array of Array from
模板字符串
数据解构 set map
不存在js预解析，避免了全局变量的污染 let const 的使用，一定要先定义再使用
ECMAScript6 新特性
String
startsWith() //检查是否以指定字符串开头，返回布尔值
let str = 'javascript';
str.startsWith('java'); //true
endsWith() //检查是否以指定字符串结尾,返回布尔值
let str = 'javascript'
str.endsWith('pt');
includes() //检查字符串是否包含指定字符串 ，返回布尔值
let str = 'javascript';
str.includes('j',1);//可以传入两个参数 查询的项 以及起始位置
repeat() //指定字符串重复次数
let str = 'javascript';
str.repeat('3');
Array
find :
let arr=[1,2,234,'sdf',-2];
arr.find(function(x){
return x<=2;
})//结果：1，返回第一个符合条件的x值
arr.find(function(x,i,arr){
if(x<2){console.log(x,i,arr)}
})//结果：1 0 [1, 2, 234, "sdf", -2]，-2 4 [1, 2, 234, "sdf", -2]
find的参数为回调函数，回调函数可以接收3个参数，值x、所以i、数组arr，回调函数默认返回值x。
●findIndex :
let arr=[1,2,234,'sdf',-2];
arr.findIndex(function(x){
return x<=2;
})//结果：0，返回第一个符合条件的x值的索引
arr.findIndex(function(x,i,arr){
if(x<2){console.log(x,i,arr)}
})//结果：1 0 [1, 2, 234, "sdf", -2]，-2 4 [1, 2, 234, "sdf", -2]
findIndex和find差不多，不过默认返回的是索引。
●includes:
let arr=[1,2,234,'sdf',-2];
arr.includes(2);// 结果true，返回布尔值
arr.includes(20);// 结果：false，返回布尔值
arr.includes(2,3)//结果：false，返回布尔值
includes函数与string的includes一样，接收2参数，查询的项以及查询起始位置。
●keys:
let arr=[1,2,234,'sdf',-2];
for(let a of arr.keys()){
console.log(a)
}//结果：0,1,2,3,4 遍历了数组arr的索引
keys，对数组索引的遍历
●values:
let arr=[1,2,234,'sdf',-2];
//查询
for(let a of arr.values()){
console.log(a)
}//结果：1,2,234,sdf,-2 遍历了数组arr的值
keys，对数组项的遍历
●entries:
let arr=['w','b'];
for(let a of arr.entries()){
console.log(a)
}//结果：[0,w],[1,b]
for(let [i,v] of arr.entries()){
console.log(i,v)
}//结果：0 w,1 b
entries，对数组键值对的遍历。
●fill:
let arr=['w','b'];
arr.fill('i')//结果：['i','i']，改变原数组
arr.fill('o',1)//结果：['i','o']改变原数组,第二个参数表示填充起始位置
new Array(3).fill('k').fill('r',1,2)//结果：['k','r','k']，第三个数组表示填充的结束位置
fill方法改变原数组，当第三个参数大于数组长度时候，以最后一位为结束位置。
Array.of():
Array.of('w','i','r')//["w", "i", "r"]返回数组
Array.of(['w','o'])//[['w','o']]返回嵌套数组
Array.of(undefined)//[undefined]依然返回数组
Array.of()//[]返回一个空数组
Array.of()方法永远返回一个数组，参数不分类型，只分数量，数量为0返回空数组。
●copyWithin:
["w", "i", "r"].copyWithin(0)//此时数组不变
["w", "i", "r"].copyWithin(1)//["w", "w", "i"],数组从位置1开始被原数组覆盖，只有1之前的项0保持不变
["w", "i", "r","b"].copyWithin(1,2)//["w", "r", "b", "b"],索引2到最后的r,b两项分别替换到原数组1开始的各项，当数量不够，变终止
["w", "i", "r",'b'].copyWithin(1,2,3)//["w", "r", "r", "b"]，强第1项的i替换为第2项的r
copyWithin方法接收三个参数，被替换数据的开始处、替换块的开始处、替换块的结束处(不包括);copyWithin(s,m,n).
●Array.from():
Array.from({'0':'w','1':'b',length:2})//["w", "b"],返回数组的长度取决于对象中的length，故此项必须有！
Array.from({'0':'w','1':'b',length:4})//["w", "b", undefined, undefined],数组后2项没有属性去赋值，故undefined
Array.from({'0':'w','1':'b',length:1})//["w"],length小于key的数目，按序添加数组
let divs=document.getElementsByTagName('div');
Array.from(divs)//返回div元素数组
Array.from('wbiokr')//["w", "b", "i", "o", "k", "r"]
Array.from([1,2,3],function(x){
return x+1})//[2, 3, 4],第二个参数为回调函数
Array.from可以把带有lenght属性类似数组的对象转换为数组，也可以把字符串等可以遍历的对象转换为数组，它接收2个参数，转换对象与回调函数
Function
1解决设置参数默认值
function test(a,b="world"){
console.log(a+b)
}
test("hello") // helloworld
//等同于
function test(a,b){
b=b || "world"
console.log(a+b)
}
test("hello")
2,作用域问题
{
let x = "hello"
function fn(x,y=x){
console.log(x,y)
}
fn("kk") //kk,kk
}
{
let x = "hello"
function fn(c,y=x){
console.log(c,y)
}
fn("kk") //kk,hello
}
3,rest参数 会自动转化成数组
{
function test(...arg){
for(var item of arg){
console.log("rest" + item)
}
}
test(1,2,3,4,"a")
}
4,扩展运算符 ...
{
console.log(...[1,2,3])
}
5,箭头函数
{
let fn = m => m*3
console.log(fn(2)) //6
//等同于
let fn =function(m){
return m*3
}
}
{
let fn = (m*n) => m*n
console.log(fn(2,5)) //10
}
{
let fn = (a,b,c="了不起") => {
console.log(a+b+c)
}
fn("真","子")
}
箭头函数注意点
- typeof运算符和普通的function一样
- instanceof也返回true，表明也是Function的实例
3.this固定，不再善变
4.箭头函数不能用new
5.不能使用arguments
Object
1、属性的简洁表示法
ES6允许直接写入变量和函数，作为对象的属性和方法。这样的书写更加简洁。
var foo = 'bar';
var baz = {foo};
baz {foo: "bar"}
// 等同于
var baz = {foo: foo};
上面代码表明，ES6允许在对象之中，只写属性名，不写属性值。这时，属性值等于属性名所代表的变量。
下面这种写法也可以
function f(x, y) {
return {x, y};
}
// 等同于
function f(x, y) {
return {x: x, y: y};
}
f(1, 2) // Object {x: 1, y: 2}
除了属性简写，方法也可以简写。
var o = {
method() {
return "Hello!";
}
};
// 等同于
var o = {
method: function() {
return "Hello!";
}
};
2比较是否相等 严格相等 ===
{
console.log(-0 == +0) //true
Object.is(-0,+0) //false
}
常用的对象api
NO1：对象拼接
{
let obj1 = {a:1}
let obj2 = {b:2}
Object.assign(obj1,obj2) // {a:1,b:2}
}
后面的参数target是目标对象，后面可以跟若干个源对象，此API的作用是将多个源对象拼接在目标对象之后，组成一个对象。
NO2：创建一个对象
{
let obj1 = {name:"lee"};
let obj2 = Object.create(obj1)
console.log(obj2.name) //lee
console.log(obj2) //{}
}
用此方法创建一个对象，新创建的对象会继承“原型对象”的属性，但这些属性并不是新创建对象本身的属性
N03，冻结对象 冻结之后就不能在修改了
{
let obj = {name:"lee"}
let obj2 = Object.freeze(obj);
obj2.name = "wang";
console.log(obj , obj2)
}
Set
基本用法
ES6提供了新的数据结构Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。
Set本身是一个构造函数，用来生成Set数据结构。
var s = new Set();
[2, 3, 5, 4, 5, 2, 2].map(x => s.add(x));
for (let i of s) {
console.log(i);
}// 2 3 5 4
上面代码通过add方法向Set结构加入成员，结果表明Set结构不会添加重复的值。
Set函数可以接受一个数组（或类似数组的对象）作为参数，用来初始化。
// 例一var set = new Set([1, 2, 3, 4, 4]);
[...set]// [1, 2, 3, 4]
// 例二var items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
items.size // 5
// 例三function divs () {
return [...document.querySelectorAll('div')];
}
var set = new Set(divs());
set.size // 56
// 类似于
divs().forEach(div => set.add(div));
set.size // 56
上面代码中，例一和例二都是Set函数接受数组作为参数，例三是接受类似数组的对象作为参数。
上面代码中，也展示了一种去除数组重复成员的方法。
// 去除数组的重复成员
[...new Set(array)]
向Set加入值的时候，不会发生类型转换，所以5和"5"是两个不同的值。Set内部判断两个值是否不同，使用的算法叫做“Same-value equality”，它类似于精确相等运算符（===），主要的区别是NaN等于自身，而精确相等运算符认为NaN不等于自身。在Set内部，两个NaN是相等。
Set实例的属性和方法
Set结构的实例有以下属性。
- Set.prototype.constructor：构造函数，默认就是Set函数。
- Set.prototype.size：返回Set实例的成员总数。
Set实例的方法分为两大类：操作方法（用于操作数据）和遍历方法（用于遍历成员）。下面先介绍四个操作方法。
- add(value)：添加某个值，返回Set结构本身。
- delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
- has(value)：返回一个布尔值，表示该值是否为Set的成员。
- clear()：清除所有成员，没有返回值。
上面这些属性和方法的实例如下。
s.add(1).add(2).add(2);// 注意2被加入了两次
s.size // 2
s.has(1) // true
s.has(2) // true
s.has(3) // false
s.delete(2);
s.has(2) // false
Array.from方法可以将Set结构转为数组。
var items = new Set([1, 2, 3, 4, 5]);var array = Array.from(items);
这就提供了去除数组重复成员的另一种方法。
function dedupe(array) {
return Array.from(new Set(array));
}
dedupe([1, 1, 2, 3]) // [1, 2, 3]
遍历操作
Set结构的实例有四个遍历方法，可以用于遍历成员。
- keys()：返回一个键名的遍历器
- values()：返回一个键值的遍历器
- entries()：返回一个键值对的遍历器
- forEach()：使用回调函数遍历每个成员
key方法、value方法、entries方法返回的都是遍历器对象。由于Set结构没有键名，只有键值（或者说键名和键值是同一个值），所以key方法和value方法的行为完全一致。
let set = new Set(['red', 'green', 'blue']);
for (let item of set.keys()) {
console.log(item);
}// red
// green
// blue
for (let item of set.values()) {
console.log(item);
}// red
// green
// blue
for (let item of set.entries()) {
console.log(item);
}// ["red", "red"]
// ["green", "green"]
// ["blue", "blue"]
Set结构的实例默认可遍历，它的默认遍历器生成函数就是它的values方法。
Set.prototype[Symbol.iterator] === Set.prototype.values// true
这意味着，可以省略values方法，直接用for...of循环遍历Set。
WeakSet
WeakSet结构与Set类似，也是不重复的值的集合。但是，它与Set有两个区别。
首先，WeakSet的成员只能是对象，而不能是其他类型的值。
其次，WeakSet中的对象都是弱引用，即垃圾回收机制不考虑WeakSet对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于WeakSet之中。这个特点意味着，无法引用WeakSet的成员，因此WeakSet是不可遍历的。
var ws = new WeakSet();
ws.add(1)// TypeError: Invalid value used in weak setws.add(Symbol())// TypeError: invalid value used in weak set
上面代码试图向WeakSet添加一个数值和Symbol值，结果报错，因为WeakSet只能放置对象。
WeakSet是一个构造函数，可以使用new命令，创建WeakSet数据结构。
var ws = new WeakSet();
作为构造函数，WeakSet可以接受一个数组或类似数组的对象作为参数。（实际上，任何具有iterable接口的对象，都可以作为WeakSet的参数。）该数组的所有成员，都会自动成为WeakSet实例对象的成员。
WeakSet结构有以下三个方法。
- WeakSet.prototype.add(value)：向WeakSet实例添加一个新成员。
- WeakSet.prototype.delete(value)：清除WeakSet实例的指定成员。
- WeakSet.prototype.has(value)：返回一个布尔值，表示某个值是否在WeakSet实例之中。
下面是一个例子。
var ws = new WeakSet();var obj = {};var foo = {};
ws.add(window);
ws.add(obj);
ws.has(window); // true
ws.has(foo); // false
ws.delete(window);
ws.has(window); // false
WeakSet没有size属性，没有办法遍历它的成员。
WeakSet不能遍历，是因为成员都是弱引用，随时可能消失，遍历机制无法保证成员的存在，很可能刚刚遍历结束，成员就取不到了。WeakSet的一个用处，是储存DOM节点，而不用担心这些节点从文档移除时，会引发内存泄漏。
Map
Map对象就是简单的键值对映射。其中的键和值可以使任意值。（ps : 对象的键只能是字符串 ）
- 创建Map实例的两种方法
//1.
var map = new Map();
map.set('one', 1);
map.set('two', 2);
map.set('three', 3);
//2.
var map = new Map([['one',1], ['two', 2], ['three', 3]]);
2.键的比较
键的比较规则：NaN 是与NaN是相同的（虽然NaN !== NaN）,除此之外所有的值都根据'==='判断。
var map = new Map();
map.set(Number('aa111'), 'isNaN');
map.set(Number('bb222'), 'also is NaN');
map.get(NaN); //'also is NaN'
3.Map VS Object
一个对象通常都有自己的原型，所以一个对象总有一个"prototype"键。不过，从ES5开始可以使用map = Object.create(null)来创建一个没有原型的对象
一个对象的键只能是字符串或者Symbols，但一个Map的键可以是任意值。
你可以通过size属性很容易地得到一个Map的键值对个数，而对象的键值对个数只能手动确认。
4.Map属性
Map.length 属性length的值为0。
Map.prototype 表示Map构造器的原型。允许添加属性从而应用与所有的Map对象。
- Map实例 - 所有Map对象的实例都会继承Map.prototype。
- 属性
Map.prototype.constructor 返回创建给map实例的构造函数，默认是Map函数。
Map.prototype.size 返回Map对象的键值对的数量。
var map = new Map([['one',1], ['two', 2], ['three', 3]]);
console.log(map.constructor); //function Map() { [native code] }
console.log(map.size); //3
方法
//Iterator对象：可以使用for..of进行迭代的对象
var map = new Map([[1, 'one'],[2, 'two'], [3, 'three']]);
1.Map.prototype.clear() 移除Map对象的所有键值对。
console.log(map.size); //3
map.clear();
console.log(map.size); //0
2.Map.prototype.delete(key) 移除任何与键相关联的值，并且返回该值，该值在之前会被Map.prototype.has(key)返回为true。之后再调用则返回false。
console.log(map.has(1)); //true
map.delete(1);
console.log(map.has(1)); //false
3.Map.prototype.entries() 返回一个新的Iterator对象，它按插入顺序包含了Map对象中每个元素的[key, value]数组。
console.log(map); //Map {1 => "one", 2 => "two", 3 => "three"}
map.entries();
console.log(map); //Map {1 => "one", 2 => "two", 3 => "three"}
4.Map.prototype.forEach(callbackFn[, thisArg]) 按插入顺序，为Map对象里的每一键值对调用一次callbackFn函数。如果为forEach提供了thisArg，他将在每次回调函数中作为this值。
map.forEach(function(value, key, mapObj) {
console.log(value + '---' + key + '---' + mapObj);
//value - Map对象里每一个键值对的值
//key - Map对象里每一个键值对的键
//mapObj - Map对象本身
console.log(this); //this === window
});
map.forEach(function(value, key, mapObj) {
console.log(value + '---' + key + '---' + mapObj);
console.log(this); //this === map
}, map)
5.Map.prototype.get(key) 返回键对应的值，如果不存在，则返回undefined。
map.get(1); //'one'
6.Map.prototype.has(key) 返回一个布尔值，表示Map实例是否包含键对应的值。
map.has(1); // true
map.has(5); //false
7.Map.prototype.keys() 返回一个新的Iterator对象，它按插入顺序包含了Map对象中每个元素的键。
map.keys(); //MapIterator {1, 2, 3}
8.Map.prototype.set(key, value) 设置Map对象中键的值，返回该Map对象。
console.log(map.has(4)); //false
map.set(4, 'four');
console.log(map.has(4)) //true
9.Map.prototype.values() 返回一个新的Iterator对象，它按插入顺序包含了Map对象中每个元素的值。
map.values(); //
6.使用for..of方法迭代映射
var map = new Map();
map.set(1, 'one');
map.set(2, 'two');
for (var [key, value] of map) {
console.log(key + '---' + value);
}
// 1 --- one 2 --- two
for (var key of map.keys()) {
console.log(key);
}
// 1 2
for (var value of map.values()) {
console.log(value);
}
// 'one' 'two
Promise
相信凡是写过javascript的童鞋也一定都写过回调方法（callback），简单说回调方法就是将一个方法func2作为参数传入另一个方法func1中，当func1执行到某一步或者满足某种条件的时候才执行传入的参数func2，例如下面的代码段
// 当参数a大于10且参数func2是一个方法时 执行func2
function func1(a, func2) {
if (a > 10 && typeof func2 == 'function') {
func2()
}
}
func1(11, function() {
console.log('this is a callback')
})
一般来说我们会碰到的回调嵌套都不会很多，一般就一到两级，但是某些情况下，回调嵌套很多时，代码就会非常繁琐，会给我们的编程带来很多的麻烦，这种情况俗称——回调地狱。
由此，Promise的概念就由社区提出并实现，作用与回调方法几乎一致，都是在某种情况下执行预先设定好的方法，但是使用它却能够让代码变得更简洁清晰
什么是Promise
Promise是异步编程的一种解决方案，它有三种状态，分别是pending-进行中、resolved-已完成、rejected-已失败
当Promise的状态又pending转变为resolved或rejected时，会执行相应的方法，并且状态一旦改变，就无法再次改变状态，这也是它名字promise-承诺的由来
案例
function fn(ready){
//返回 promise的实例
return new Promise((resolve,reject)=>{
if(ready){ //true
resolve("成功了") //返回唯一的值
}else{
reject("错了") //失败返回唯一值
}
})
}
fn(0).then(function(a){ //then //catch
console.log(a)}).catch(function(a){
console.warn(a)
})
class基本用法和继承
//生成一个父类
class Parent{
//构造器
constructor(name="wang"){
this.name = name; //this会指向构造函数new出来的实例对象
this.say=function(){
console.log(this.name)
}
}
}
class Child extends Parent{
constructor(name="sun"){
super(name)//改变默认值
}
get newName(){
return this.name + " gaga "
}
set newName(value){
this.name = value
}
}
let person1 = new Child();
person1.say()
console.log(person1.newName)
person1.newName="sssss"
console.log(person1.newName)
Symbol
为啥需要Symbol
一个新规则的提出，必然是因为有需求，熟悉ES5的人都知道，ES5里面对象的属性名都是字符串，如果你需要使用一个别人提供的对象，你对这个对象有哪些属性也不是很清楚，但又想为这个对象新增一些属性，那么你新增的属性名就很可能和原来的属性名发送冲突，显然我们是不希望这种情况发生的。所以，我们需要确保每个属性名都是独一无二的，这样就可以防止属性名的冲突了。因此，ES6里就引入了Symbol，用它来产生一个独一无二的值。
Symbol是什么
我们已经知道ES6中引入了一个叫Symbol的东西，但是这个东西到底是什么呢？是一个函数还是一个对象或者是其他什么？Symbol实际上是ES6引入的一种原始数据类型，除了Symbol，JavaScript还有其他6种数据类型，分别是Undefined、Null、Boolean、String、Number、对象，这5种数据类型都是ES5中就有的。
怎么生成一个Symbol类型的值
既然我们已经知道了Symbol是一种原始的数据类型，那么怎么生成这种数据类型的值呢？Symbol值是通过Symbol函数生成的，如下：
let s = Symbol();console.log(s); // Symbol()typeof s; // "symbol"
上面代码中，s就是一个Symbol类型的值，它是独一无二的。
Symbol函数前不能用new
Symbol函数不是一个构造函数，前面不能用new操作符。所以Symbol类型的值也不是一个对象，不能添加任何属性，它只是一个类似于字符型的数据类型。如果强行在Symbol函数前加上new操作符，会报错，如下：
let s = new Symbol();// Uncaught TypeError: Symbol is not a constructor(…)
Symbol函数的参数
字符串作为参数
用上面的方法生成的Symbol值不好进行区分，Symbol函数还可以接受一个字符串参数，来对产生的Symbol值进行描述，方便我们区分不同的Symbol值。
let s1 = Symbol('s1');
let s2 = Symbol('s2');
console.log(s1);
// Symbol(s1)console.log(s2);
// Symbol(s2)
s1 === s2; // false
let s3 = Symbol('s2');
s2 === s3; // false
从上面代码可以看出：
- 给Symbol函数加了参数之后，控制台输出的时候可以区分到底是哪一个值；
- Symbol函数的参数只是对当前Symbol值的描述，因此相同参数的Symbol函数返回值是不相等的；
Symbol.for()和Symbol.keyFor()
Symbol.for()函数也可以用来生成Symbol值，但该函数有一个特殊的用处，就是可以重复使用一个Symbol值。
let s7 = Symbol.for('s7');
console.log(s7); // Symbol(s7)
s7.toString(); // "Symbol(s7)"
let s8 = Symbol.for('s8');
s7 === s8
// truelet s9 = Symbol();
Symbol.keyFor(s9);
// undefinedSymbol.keyFor(s8); // "s8"
Symbol.for()函数要接受一个字符串作为参数，先搜索有没有以该参数作为名称的Symbol值，如果有，就直接返回这个Symbol值，否则就新建并返回一个以该字符串为名称的Symbol值。上面代码中，s7和s8实际上就是同一个Symbol值，所以两者是相等的。
Symbol.keyFor()函数是用来查找一个Symbol值的登记信息的，Symbol()写法没有登记机制，所以返回undefined；而Symbol.for()函数会将生成的Symbol值登记在全局环境中，所以Symbol.keyFor()函数可以查找到用Symbol.for()函数生成的Symbol值。