ECMAScript 是一种由 Ecma 国际标准(原欧洲计算机制造商协会) ECMA-262 脚本语言规范的定义。这种语言广泛应用于万维网络，通常被称为 JavaScript 或 JScript，但实际上后两者是 ECMA-262 实现和扩展标准

ECMAScript 布兰登是由网景组成的·艾克开发的脚本语言标准化规范；最初命名为Mocha，后来改名为 LiveScript，最后重命名为 JavaScript。1995年12月，升阳与网景联合发布JavaScript。1996年11月，网景公司将 JavaScript 提交给欧洲计算机制造商协会进行标准化。ECMA-262 第一个版本是 1997 年 6 月被 Ecma 组织采纳。ECMAScript 是由ECMA-262 脚本语言的标准化名称。

1. 什么是 ECMA ECMA（European Computer Manufacturers Association）该组织的目标是评估、开发和认可电信和计算机标准。1994 该组织年后改名为Ecma 国际。
2. 什么是ECMAScript ECMAScript 是由 Ecma 国际通过ECMA-262 脚本程序设计语言的标准化。
3. 什么是 ECMA-262 Ecma 国际制定了许多标准，ECMA-262 只有一个，查看所有标准列表：http://www.ecma-international.org/publications/standards/Standard.htm ECMA-262 查看历史版网站： http://www.ecma-international.org/publications/standards/Standard.htm http://www.ecma-international.org/publications/standards/Ecma-262-arch.htm

• ES5 是 ECMAScript 第五版，2009年发布。
• ES6 是 ECMAScript 第六版，2015年发布，也叫 ES2015。
• 从 ES6 从每年发布一个版本开始，版本号比年底大 1。

4. 谁在维护 ECMA-262 TC39（Technical Committee 39）是推进ECMAScript 发展委员会。其成员为公司(包括苹果、谷歌、微软、因特尔等)。TC39 会员公司代表和特邀专家定期召开会议。
5. 为什么要学习？ ES6 ES6 版本变化最多，具有里程碑意义 ES6 加入许多新的语法特性，编程实现更简单、高效 ES6 是前端发展趋势，就业必备技能
6. ES6 兼容性 地址：http://kangax.github.io/compat-table/es6/

• let 关键字用来声明变量，let 声明和var声名变量对比：
  1. 不允许重复声明同名的变量
  2. 有块级作用域
  3. 不存在变量提升
  4. 不影响作用域链
• 应用
  1. 解决 作用域解决点击 but[i]\this.的问题

• const 关键字用来声明变量，const 声明和var声名变量对比：
  1. 声明必须赋初始值
  2. 标识符一般为大写（潜规则）
  3. 值不允许修改
  4. E不允许重复声明
  5. 块级作用域

• ES6 允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为 解构赋值
• 数组的解构赋值： javascript const arr = [‘red’, ‘green’, ‘blue’]; let [r, g, b] = arr;
• 对象的解构赋值：

let obj = { 
        
name: 'xiansheng',
age: 23,
obj1: function () { 
        
console.log('hello');
},
}
let { 
        name, age, obj1} = obj;
console.log(name,age,obj1())

应用场景：频繁使用对象方法、数组元素，就可以使用解构赋值形式。

• 模板字符串（template string）是增强版的字符串，${``}：
• 用法：

let name = 'jack';
console.log(`我的名字叫${ 
          name}`);
```应用场景：当遇到字符串与变量拼接的情况使用模板字符串。```

• ES6 允许在大括号里面，直接写入变量和函数，作为对象的属性和方法。这样的书写更加简洁。

let name= 'xiansheng';
let age = 35;
let obj1= function () { 
        
 console.log('obj1');
}
//简写
const obj = { 
        
 name,
 age,
obj1
}

应用场景：对象简写形式简化了代码，所以以后用简写就对了。

• 简写一：

fun(a,b){ 
        console.log(a+b)}  =》  （a,b）=>{ 
        console.log(a,b)} 

• 简写二：

fun(a){ 
        return a}  =》  当只有一个参数且只有一个返回值的时候可以这样; a=>a;

• 特点
  1. this永远指向window
  2. 不能使用call，apply改变this的指向
  3. 没有arguments
  4. 不能用构造函数去实例对象

• ES6 允许给函数参数设置默认值，当调用函数时不给实参，则使用参数默认值。
• 具有默认值的形参，一般要靠后。

(x, y, z=3) =>{ 
        console.log(x + y + z) };
console.log(add(1, 2)); // 6
* 可与解构赋值结合：
```javascript
function connect({ 
         host = '127.0.0.1', uesername, password, port }) { 
        
 console.log(host); // 127.0.0.1
 console.log(uesername); //root
 console.log(password); //root
 console.log(port); //3306
}
connect({ 
        
 // host: 'docs.mphy.top',
 uesername: 'root',
 password: 'root',
 port: 3306
})

• ES6 引入 rest 参数，用于获取函数的实参，用来代替 arguments，作用与 arguments 类似。将接收的参数序列转换为一个数组对象。
• 用在函数形参中，语法格式：Fun(a, b, …args)，写在参数列表最后面。

let Fun= (a, b, ...arr) => { 
        
 console.log(a);//1
 console.log(b);//2
 console.log(arr);//[3,4,5]
};
Fun(1,2,3,4,5);
* 案例
```javascript
let add = (...arr) => { 
        
 let sum = arr.reduce((pre, cur) => { 
        
     return pre + cur
 });
 return sum;
}
console.log(add(1, 2, 3, 4, 5)); // 15

应用场景：rest 参数非常适合不定个数参数函数的场景

• 扩展运算符（spread）也是三个点（…）。它好比 rest 参数的逆运算，将一个数组转为用逗号分隔的参数序列，对数组进行解包。可用在调用函数时，传递的实参，将一个数组转换为参数序列。
• 展开数组：

function fn(a, b, c) { 
        
 console.log(arguments);  //Arguments(3) [1, 2, 3, Function, Function]
 console.log(a + b + c); //6
}
let arr = [1，2，3]; 
fn(...arr)
* 数组合并：
```javascript let A = [1, 2, 3]; let B = [4, 5, 6]; let C = [...A, ...B]; console.log(C); // [1, 2, 3, 4, 5, 6] * 浅克隆数组： ```javascript
let arr1 = ['a', 'b', 'c'];
let arr2 = [...arr1]; 
console.log(arr2); // ['a', 'b', 'c']
* 将伪数组转换为真实数组
```javascript let div= document.querySelectorAll('div'); let divArr = [...div]; console.log(divArr); * 对象合并 ```javascript
// 合并对象
let obj1 = { 
        
 a: 123
};
let obj2 = { 
        
 b: 456
};
let obj = { 
         ...obj1, ...obj2};
console.log(obj); //{ a: 123, b: 456}

• ES6 引入了一种新的原始数据类型 Symbol，表示独一无二的值。它是 JavaScript 语言的第七种数据类型，是一种类似于字符串的数据类型。
• JavaScript 的七种基本数据类型：

1. 基本数值类型：string、number、boolean、undefined、null、symbol
2. 引用数值类型：Object（包括了Array、Function）

• Symbol 的特点：
  1. Symbol 的值是唯一的，用来解决命名冲突的问题
  2. Symbol 值不能与其他数据进行运算
  3. Symbol 定义的对象属性不能使用 for…in 循环遍历，但是可以使用 Reflect.ownKeys 来获取对象的所有键名
• Symbol 的创建：

1. 创建一个 Symbol：

let s1 = Symbol();
console.log(s1, typeof s1); 	// Symbol() symbol

2. 添加具有标识的 Symbol：

let s2 = Symbol('1');
let s2_1 = Symbol('1');
console.log(s2 === s2_1); 	// false Symbol 都是独一无二的

3. 使用 Symbol.for() 方法创建，名字相同的 Symbol 具有相同的实体。

let s3 = Symbol.for('apple');
let s3_1 = Symbol.for('apple');
console.log(s3 === s3_1); // true

4. 输出 Symbol 变量的描述，使用 description 属性

let s4 = Symbol('测试');
console.log(s4.description); // 测试

• ES6 引入 rest 参
• 案例：安全的向对象中添加属性和方法。
• 分析：如果直接向对象中添加属性或方法，则原来对象中可能已经存在了同名属性或方法，会覆盖掉原来的。所以使用 Symbol 生成唯一的属性或方法名，可以更加安全的添加。

// 这是一个 game 对象，假设我们不知道里面有什么属性和方法
const game = { 
        
uname: '俄罗斯方块',
up: function () { 
         },
down: function () { 
         }
}

// 通过 Symbol 生成唯一的属性名，然后给 game 添加方法
let [up, down] = [Symbol('up'), Symbol('down')];
game[up] = function () { 
        
console.log('up');
}
game[down] = function () { 
        
console.log('down');
}

// 调用刚刚创建的方法
game[up]();
game[down]();

• 除了定义自己使用的 Symbol 值以外，ES6 还提供了11 个内置的 Symbol 值，指向语言内部使用的方法。可以称这些方法为魔术方法，因为它们会在特定的场景下自动执行。

11.1 定义

• 说明：（按我们自己的意愿去遍历对象里面的数据）遍历器（Iterator）就是一种机制。它是一种接口，为各种不同的数据结构提 供统一的访问机制。任何数据结构只要部署 Iterator 接口，就可以完成遍历操作。
• ES6 创造了一种新的遍历命令 for…of 循环，Iterator 接口主要供 for…of 消费。
• 原生具备 iterator 接口的数据(可用for of 遍历) Array Arguments Set Map String TypedArray NodeList
• 案例：使用 next() 方法遍历原生自带 iterator 接口的数据：

let obj={ 
        
  name:"先生",
  arr:[1,1,5,4,4,5,88,88,89],
  [Symbol.iterator]:function (){ 
        
     let _this=this
      let index=0
      return{ 
        
          next:function (){ 
        
              if(index<_this.arr.length){ 
        
                  let data={ 
        value:_this.arr[index],done:false}
                  index++
                  return data
              }else{ 
        
                  return{ 
        value: undefined,done: true}
              }
          }
      }
  }
}
for (const objElement of obj) { 
        
  console.log(objElement)
}

11.2 工作原理

• 创建一个指针对象，指向当前数据结构的起始位置
• 第一次调用对象的 next 方法，指针自动指向数据结构的第一个成员
• 接下来不断调用 next 方法，指针一直往后移动，直到指向最后一个成员
• 每调用 next 方法返回一个包含 value 和 done 属性的对象

12.1 生成器函数的声明和调用

• 生成器函数是 ES6 提供的一种 异步编程解决方案，语法行为与传统函数完全不同
• 使用 function * gen() 和 yield 可以声明一个生成器函数。生成器函数返回的结果是迭代器对象，调用迭代器对象的 next 方法可以得到 yield 语句后的值。
• *的位置没有限制
• 每一个 yield 相当于函数的暂停标记，也可以认为是一个分隔符，每调用一次 next()，生成器函数就往下执行一段。
• next 方法可以传递实参，作为 yield 语句的返回值

案例： 第一种玩法：

function * Fun() { 
        
  console.log("一只老虎")
 let result1=yield "我是第一个！";
  console.log(result1)
  console.log("两只老虎")
  let result2=yield "我是第二个！";
  console.log(result2)
  console.log("真可爱")
  let result3=yield "我是第三个！";
  console.log(result3)
}	
let fun=Fun()
fun.next()
fun.next("我是第一个的回调")
fun.next("我是第二个的回调")
fun.next("我是第三个的回调")

第二种玩法：

function one() { 
        
   setTimeout(()=>{ 
        
       console.log("第一单")
       let data="第一单"
       results.next(data)
   },1000)
}
function two() { 
        
   setTimeout(()=>{ 
        
       console.log("第二单")
       let data="第二单"
       results.next(data)
   },2000)
}
function three() { 
        
   setTimeout(()=>{ 
        
       console.log("第三单")
       let data="第三单"
       results.next(data)
   },3000)
}
function * sum() { 
        
   one()
  let onea=yield ""
   console.log(onea)
   let twoa=yield two()
   console.log(twoa)
   let threea=yield three()
   console.log(threea)
   }
let results=sum()
results.next()
//第一单
//第一单
//第二单
//第二单
//第三单
//第三单

• 请跳到我博客搜：Promise入门到 里面有详细的说明；

14.1 Set 的定义和使用

• ES6 提供了新的数据结构 Set（集合）。它类似于数组，但 成员的值都是唯一的，集合实现了 iterator 接口，所以可以使用『扩展运算符』和『for…of』进行遍历。
• 定义一个 Set 集合：

let st1 = new Set();
let st2 = new Set([可迭代对象]);

• 集合new Set()的属性和方法：
  1. set.size：返回集合个数
  2. set.add(item)：往集合中添加一个新元素 item，返回当前集合
  3. set.delete(item)：删除集合中的元素，返回 boolean 值
  4. set.has(item)：检测集合中是否包含某个元素，返回 boolean 值
  5. set.clear()：清空集合
  6. 集合转为数组：[…st]
  7. 合并两个集合：[…st1, …st2]

14.2 案例：

• 案例1

let s=new Set(['大事儿','小事儿','小小事儿','大二事'])
s.add("小小儿")
console.log(s) //Set(5) {"大事儿", "小事儿", "小小事儿", "大二事", "小小儿"size: 5}
s.delete("小小儿")
console.log(s) //Set(4) {"大事儿", "小事儿", "小小事儿", "大二事"size: 4}
console.log(s.has("大事儿")) //true
s.clear() //Set(0) {size: 0}
console.log(s)
* 	案例2~~~```结和 mew Set（） 完成:并集、交集、数组去重、差集```
```javascript
定义两个数组
   let arr=[1,2,5,4,8,8,4,5]
   let arr1=[1,5,2,88,88,99<