符号
符号：
概念：ES6中的添加了一种原始数据类型符号（已有的原始数据类型：String，Number，boolean，null，undefined，对象）
特点：
1，符号属性对应的值是唯一的，解决命名冲突问题
2，符号值不能与其他数据进行计算，包括同字符串拼串
3，for，for for遍历时不会遍历symbol属性。
使用：
1，调用符号函数得到符号值
let symbol = Symbol（）;
让obj = {};
obj [symbol] ='你好';
2，传参标识
let symbol = Symbol（'one'）;
let symbol2 = Symbol（'two'）;
console.log（symbol）; //符号（'one'）
console.log（symbol2）; //符号（'two'）
3，内置符号值
*除了定义自己使用的符号值以外，ES6还提供了11个内置的符号值，指向语言内部使用的方法。
- Symbol.iterator
*对象的Symbol.iterator属性，指向该对象的默认遍历器方法
< script type = “ text / javascript ” >
//创建符号属性值
let symbol = Symbol（）;
控制台。log（symbol）;
让 obj = {用户名： ' kobe '，年龄： 40 };
OBJ。sex = '男' ;
obj [symbol] = '你好' ;
控制台。log（obj）;
// for for，for of不能遍历symbol属性
for（let i in obj）{
控制台。log（i）;
}
let symbol2 = Symbol（' one '）;
let symbol3 = Symbol（' two '）;
控制台。log（symbol2 == symbol3）;
控制台。log（symbol2，symbol3）;
//可以去定义常量
const Person_key = Symbol（' person_key '）;
控制台。log（Person_key）;
< / script >
Iterator遍历器
概念：iterator是一种接口机制，为各种不同的数据结构提供统一的访问机制
作用：
1，为各种数据结构，提供一个统一的，简便的访问接口;
2，使得数据结构的成员能够按某种次序排列
3，ES6创造了一种新的遍历命令为...循环的，迭代器接口主要供为...消费的。
工作原理：
- 创建一个指针对象（遍历器对象），指向数据结构的起始位置。
- 第一次调用next方法，指针自动指向数据结构的第一个成员
- 接下来不断调用next方法，指针会一直往后移动，直到来向最后一个成员
- 每调用next方法返回的是一个包含value和done的对象，{值：当前成员的值，done：布尔值}
* value表示当前成员的值，完成对应的布尔值表示当前的数据的结构是否遍历结束。
*当遍结束的时候返回的值值是undefined，done值为false
原生具备iterator接口的数据（可用于遍历）
1，阵列
2，参数
3，设置容器
4，地图容器
5，字符串
< script type = “ text / javascript ” >
//模拟指针对象（遍历器对象）
function myIterator（arr）{ // iterator接口
让 nextIndex = 0 ; //记录指针的位置
return { //遍历器对象
下一个： function（）{
return {value ： arr [nextIndex ++ ]，done ： nextIndex < arr。长度 ？ false ： true };
}
}
}
//准备一个数据
让 ARR = [ 1，4，65，' ABC ' ];
让 iteratorObj = myIterator（arr）;
控制台。日志（iteratorObj。下一个（））;
控制台。日志（iteratorObj。下一个（））;
控制台。日志（iteratorObj。下一个（））;
控制台。日志（iteratorObj。下一个（））;
控制台。日志（iteratorObj。下一个（））;
控制台。日志（iteratorObj。下一个（））;
控制台。日志（iteratorObj。下一个（））;
//将iterator接口部署到指定的数据类型上，可以使用for去循环遍历
//数组，字符串，参数设置容器，地图容器
for（let i of arr）{
控制台。log（i）;
}
让 str = ' abcdefg ' ;
for（let i of str）{
控制台。log（i）;
}
function fun（）{
for（let i of arguments）{
控制台。log（i）;
}
}
有趣的（1，4，5，' ABC '）;
让 obj = {用户名： ' kobe '，年龄： 40 };
/ *
for（let i of obj）{
的console.log（ⅰ）;
}
* /
//等同于在指定的数据结构上部署了迭代器接口
//当然用于去遍历某一个数据结构的时候，首先去找Symbol.iterator，找到了就去遍历，没有找到的话就不能遍历
让 targetData = {
[ 符号。iterator ] ： function（）{
让 nextIndex = 0 ; //记录指针的位置
return { //遍历器对象
下一个： function（）{
return {value ： this [nextIndex ++ ]，done ： nextIndex < this。长度 ？ false ： true };
}
}
}
}
/ *我的测试
让targetData = {
用户名：'kobe'，
年龄：40岁，
[Symbol.iterator]：function（）{
let nextIndex = 0; //记录指针的位置
let keys = Object.keys（targetData）;
return {//遍历器对象
下一个：function（）{
if（nextIndex <keys.length）{
return {value：keys [nextIndex] +'：'+ targetData [keys [nextIndex ++]]，done：false};
}其他{
return {value：undefined，done：true};
}
}
}
}
}
//不能直接为遍历对象，因为对象的属性没有顺序
// for（let i of targetData）{
// console.log（“----->”+ i）;
//}
//可以使用Object.keys方法将对象的键名生成一个数组，然后遍历这个数组
for（Object.keys（targetData）的var键）{
console.log（key +'：'+ targetData [key]）;
}
//获取迭代器
let it = targetData [Symbol.iterator]（）;
console.log（'----->'+ it.next（）。value）; // ----->用户名：kobe
console.log（'----->'+ it.next（）。value）; // -----> age：40
console.log（'----->'+ it.next（）。value）; // -----> undefined：undefined
* /
//使用三点运算符，解构赋值时，会默认去调用迭代器接口
让 ARR2 = [ 1，6 ]。
让 ARR3 = [ 2，3，4，5 ]。
ARR2 = [ 1，... ARR3，6 ]。
控制台。log（arr2）;
让 [a，b] = arr2;
控制台。log（a，b）;
< / script >
生成器函数
生成函数
概念：
1，ES6提供的解决异步编程的方案之一
2，发电机函数是一个状态机，内部封装了不同状态的数据，
3，用来生成遍历器对象
4，可暂停函数（惰性求值），yield可暂停，next方法可启动。每次返回的是yield后的表达式结果
特点：
1，功能与函数名之间有一个星号
2，内部用屈服表达式来定义不同的状态
例如：
function * generatorExample（）{
让result = yield'hello'; //状态值为你好
产量'发电机'; //状态值为generator
}
3，发电机函数返回的是指针对象（即迭代器），而不会执行函数内部逻辑
4，调用下一个方法函数内部逻辑开始执行，遇到yield表达式停止，返回{值：yield后的表达式结果/ undefined，done：false / true}
5，再次调用下一个方法会从上一次停止时的产率处开始，直到最后
6，yield语句返回结果通常为undefined，当调用next方法时传参内容会作为启动时yield语句的返回值。
< script type = “ text / javascript ” src = “ ./ js / jquery-1.12.4.min.js ” > < / script >
< script type = “ text / javascript ” >
/ *
function * myGenerator（）{
的console.log（ '开始执行'）;
让result = yield'hello';
console.log（'result ='+ result）;
的console.log（ '暂停后，再次执行'）;
产量'发电机';
的console.log（ '遍历完毕'）;
return'返回的结果';
}
让MG = myGenerator（）; //返回的是指针对象
的console.log（MG）;
的console.log（MG.next（））;
的console.log（MG.next（ 'AAAAAAAAA'））;
的console.log（MG.next（））;
* /
/ *
//对象的symbol.iterator属性指向遍历器对象
让obj = {用户名：'kobe'，年龄：40};
obj [Symbol.iterator] = function * myTest（）{
产量1;
产量2;
产量3;
}
for（let i of obj）{
的console.log（ⅰ）;
}
* /
//案例练习
/ *
*需求：
* 1，发送ajax请求获取新闻内容
* 2，新闻内容获取成功后再次发送请求，获取对应的新闻评论内容
* 3，新闻内容获取失败则不需要再次发送请求。
* /
function getNews（url）{
$。get（url，function（data）{
控制台。记录（数据）;
let url = ' http：// localhost：3000 ' + 数据。commentsUrl ;
SX。下一个（网址）;
}）
}
function * sendXml（）{
let url = yield getNews（' http：// localhost：3000 / news？id = 3 '）;
yield getNews（url）;
}
//获取遍历器对象
让 SX = sendXml（）;
SX。next（）;
< / script >
async函数
异步函数（源自ES2017）
概念：真正意义上去解决异步回调的问题，同步流程表达异步操作
本质：Generator的语法糖
语法：
async function foo（）{
await异步操作;
await异步操作;
}
特点：
1，不需要像发电机去调用下一个方法，遇到AWAIT等待，当前的异步操作完成就往下执行
2，返回的总是无极对象，可以用然后方法进行下一步操作
3，异步发电机取代函数的星号*，等待取代发生器的产率
4，语意上更为明确，使用简单，经临床验证，暂时没有任何副作用
< script type = “ text / javascript ” src = “ ./ js / jquery-1.12.4.min.js ” > < / script >
< script type = “ text / javascript ” >
// async基本使用
async function foo（）{
返回 新的 Promise（resolve => {
// setTimeout（function（）{
// resolve（）;
// }，2000）;
setTimeout（resolve，2000）;
}）
}
异步 函数 test（）{
控制台。log（'开始执行'，new Date（）。toTimeString（））;
等待 foo（）;
控制台。log（'执行完毕'，new Date（）。toTimeString（））;
}
// test（）;
// async里等待的返回值
function test2（）{
返回 ' xxx ' ;
}
async function asyncPrint（）{
// let result = await test2（）;
让结果= 等待 承诺。解决（'承诺'）;
控制台。log（结果）;
结果= 等待 承诺。拒绝（'失败了〜'）;
控制台。记录（结果）
}
// asyncPrint（）;
//获取新闻内容
async function getNews（url）{
返回 新的 Promise（（resolve，reject）=> {
$。ajax（{
URL，
类型： ' GET '，
dataType ： ' json '
}）
。完成（data => resolve（data））
// .fail（error => reject（））;
。失败（错误 => 解决（错误））;
}）;
}
异步 函数 sendXml（）{
let result = await getNews（' http：// localhost：3000 / newsasdf？id = 7 '）;
控制台。log（结果）;
if（！ result）{
alert（'暂时没有新闻推送~~ '）;
回归 ;
}
结果= 等待 getNews（'的http：//本地主机：3000 ' + 结果。commentsUrl）;
控制台。log（结果）;
控制台。log（'错误了~~ '）;
}
sendXml（）;
< / script >
class
1.通过类定义类/实现类的继承
2.在类中通过构造函数定义构造方法
3.通过new来创建类的实例
4.通过extends来实现类的继承
5.通过super调用父类的构造方法
6.重写从父类中继承的一般方法
< script type = “ text / javascript ” >
/ *
function人（姓名，年龄）{
this.name = name;
this.age =年龄;
}
让person = new Person（'kobe'，40）;
的console.log（人）;
* /
//定义一个人物的类
class Person {
//类的构造方法
构造函数（名称，年龄）{
这个。name = name;
这个。年龄 =年龄;
}
//类的一般方法
showName（）{
控制台。log（'调用父类的方法'）;
控制台。日志（此。名字，这个。年龄）;
}
}
让 person = new Person（' kobe '，40）;
控制台。log（person）;
// person.showName（）;
//子类
类 StarPerson 扩展 Person {
构造函数（名称，年龄，工资）{
超级（姓名，年龄）;
这个。工资 =工资;
}
//父类的方法重写
showName（）{
控制台。log（'调用子类的方法'）;
控制台。log（这个。名字，这个。年龄，这个。薪水）;
}
}
让 SP = 新 StarPerson（'涉'，36，152450000）;
控制台。log（sp）;
sp。showName（）;
< / script >
