es6定义类云台山

es6

***通过class 定义类 ***
class Person{
// 定义一个构造器，相当于我们之前讲的构造函数私有的属性
constructor(name, age){
this.name = name;
this.age = age;
}
// 定义公有的方法添加到原型对象上
study(){
console.log(‘学习’)
}
say(){
console.log(‘hello’ + this.name)
}
}

***通过 extends 继承； super()关键字继承父类私有的属性 ***
class Student extends Person{
// 定义一个构造器，相当于我们之前讲的构造函数私有的属性
constructor(name, age, grade){
super(name, age);
this.grade = grade;
}
// 定义公有的方法添加到原型对象上
study(){
console.log(‘自己学习’)
}
}

Symbol() 数据类型

Symbol()提供了一个独一无二的值，是一个基本数据类型；可以接受一个参数：用来区分
let count1 = Symbol(‘c1’)
let count2 = Symbol(‘c2’)

// 解决的问题：对库（对象）进行扩展，又不用担心和库（对象）中的属性名冲突
let obj = {
name:‘tom’,
age:18,
count(){
console.log(‘统计计数’)
}
}

// 借助Symbol()类型
let count = Symbol();
// 把 count 作为 obj 的属性需要使用 []
obj[count] = function(){
console.log(‘扩展obj’)
}

// 调用对象中的 Symbol() 创建的count 的方法
obj.count() // 调用对象自身的
objcount; // 调用对象中的 Symbol() 创建的count 的方法

遍历Symbol()属性名：Symbol 作为属性名，遍历对象的时候

通过 Obejct.getOwnPropertySymbols() 遍历，得到的是所有的Symbol() 属性名；常规的属性名是获取不到的
通过 Reflect.ownKeys() 方法遍历对象的所有属性名（常规和Symbol()的）

Set() 数据结构

set()是一个新的数据类型，类似于数组，但是不能通过下标取值；set()值不允许重复

声明set() 数据类型

let set = new Set() // Set() 是一个构造函数空的set()

let set = new Set([1, 1, 1, 2, 3, 5]) // 参数是数组，要求值不能重复; 自动去重

通过set() 的特性实现数组去重

let arr1 = [1, 1, 1, 1, 2, 3]
let arr = […new Set(arr1)]

set() 数据的操作
- add() : 添加
- delete() ：删除；返回值是布尔值 true：删除成功。 false:删除失败
- clear() ：清空
- has() ：判断是否存在某个值；返回值布尔值 true:存在 false:不存在
set() 进行遍历 : 由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值），所以keys方法和values方法的行为完全一致。
- keys() : 返回键名的遍历器
- values() : 返回键值的遍历器
- entries() ：返回键值对的遍历器
- forEach() ：使用回调函数遍历每个成员（类似数组中的forEach()）

for-of 遍历：遍历部署了 [Symbol.iterator] 属性的数据

原生具有iterator接口的数据类型：

Array
Map
Set
String
TypedArray
函数的 arguments 对象
NodeList 对象

自定义对象不存在该接口的，不能使用for-of遍历；如果要使用for-of遍历自定义对象，需要自己部署接口

Iterator迭代器（接口）

一是为各种数据结构，提供一个统一的、简便的访问接口；
是一个函数
Iterator 接口主要供for…of消费
（原理）每一次调用next方法，都会返回数据结构的当前成员的信息。具体来说，就是返回一个包含value和done两个属性的对象。其中，value属性是当前成员的值，done属性是一个布尔值，表示遍历是否结束。（false:意味着遍历没有结束； true:意味着遍历结束了， value属性的值是undefined）

自定义对象部署Iterator接口

let obj = {name:'tom',age:19,say:'hello',sleep:'睡觉',[Symbol.iterator]: function(){let index = 0;  // 模拟指针移动let key = null;  // 存储键  let self = this;  // 存储thisreturn {next: function(){if(key == null){//  key 是存储所有的键名  是一个数组key = Object.keys(self)}return {value:self[key[index]],done:++index > key.length}}}}
}//  没有部署之前 报错： obj is not iterable   (obj 不可迭代的)
// for(let key of obj){//     console.log(key);
// }//  执行的过程
let iterator = obj[Symbol.iterator]();
let res1 = iterator.next();
let res2 = iterator.next();
let res3 = iterator.next();
let res4 = iterator.next();
let res5 = iterator.next();
console.log(res1);  // {value:tom, done:false}
console.log(res2);  // {value:, done:false}
console.log(res3);
console.log(res4);
console.log(res5);

Object.keys() 方法获取对象属性名的集合（结果是属性名组成的数组）(获取的是对象常规的属性名，不包含Symbol()类型)

Map 数据结构

Map 是es6新增的数据结构；存储的是键值对，但是键不局限于字符串，可以是任意类型

声明方式

let map = new Map() // 声明一个空的map结构// 数组作为参数
let map = new Map([[10, 'hello'], [20,'world']])// 使用对象作为参数   借助set()方法实现
let o = {name:'tom'}
let map = new Map()
map.set(o, '姜子牙')// 可以使用Set() 数据结构作为参数
const set = new Set([['foo', 1],['bar', 2]
]);
const m1 = new Map(set);
m1.get('foo')

Map()的数据操作
- set(key, value) : 设置键和值
- delete(key) ：删除键值对；结果是布尔值， true: 删除成功， false：删除失败
- has(key) ：判断是否存在指定的键结果布尔值； true：存在； false：不存在
- clear() ：清空
- get(key) : 获取值，参数是键名
Map() 的遍历方式
- keys() : 返回键名的遍历器。
- values() : 返回键值的遍历器。
- entries() ：返回键值对的遍历器。
- forEach() ：遍历 Map 的所有成员 ;类似数组的forEach()

Promise() 对象

回调地狱：在使用JavaScript时，为了实现某些逻辑经常会写出层层嵌套的回调函数，如果嵌套过多，会极大影响代码可读性和逻辑，这种情况也被成为回调地狱
通过 Promise() 解决回调地狱

Promise() 基本实现流程（执行机制）

Promise对象是一个构造函数，用来生成Promise实例。

promise 的作用：Promise对象，可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise对象提供统一的接口，使得控制异步操作更加容易。

promise 接受一个函数作为参数：函数有两个参数： resolve(成功) reject(失败); 他们两个是函数，由 JavaScript 引擎提供，不用自己部署。

Resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；

Reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。

promise 的状态：有三种状态：pending（进行中）、fulfilled（已成功）和rejected（已失败）。

Promise对象的状态改变，只有两种可能：从pending变为fulfilled和从pending变为rejected。当处于pending状态时，无法得知目前进展到哪一个阶段

Promise() （承诺）基本代码逻辑

let flag = true;
function fun(){return new Promise( (resolve, reject) =>{if(flag){// resolve() 代表成功， resolve() 调用执行 then() 中的回调函数// resolve()//  参数 result 就是传递的数据  需要通过then() 中回调函数接受resolve(result) }else{//  reject() 代表失败， reject() 调用执行 catch() 中的回调函数// reject()//  参数 error 就是传递的错误信息 需要通过catch() 中回调函数接受reject(error)}})
}// fun().then(() => {}).catch(() => {})fun().then((data) => {}).catch((err) => {})