class promise

 class 语法糖 声明

class就是构造函数的语法糖，在使用继承的时候会更加方便，并且在思想上和java等统一起来

类声明和类表达式。这两种方式都使用class关键字加大括号：

// 类声明
class Person {}
 
// 类表达式
const TestPerson = class {}

注意函数声明和类声明之间的一个重要区别在于，函数声明会提升，类声明不会。需要先声明类，然后再访问它，否则就会出现ReferenceError函数受函数作用域限制，而类受块作用域限制

类的数据类型就是函数，类本身就指向构造函数

constructor 方法是一个特殊的方法，这种方法用于创建和初始化一个由class创建的对象

实例化对象 new 类() -> 默认会执行类中的constructor方法

class Student {
        constructor(name, age) {
          this.name = name
          this.age = age
          this.subjects = []
        }

        set subject(subject) {
          this.subjects.push(subject)
        }
 
        get subject() {
          return this.subjects
        }
        study() {
          console.log('good good study')
        }
      } 
const s1 = new Student('zs', 18)
      console.log(s1.__proto__)
      s1.study()
      const s2 = new Student('ls', 28)
      s1.subject = 'chinese' 
      console.log(s1.subject)
      console.log(s2)
      console.log(s1.study === s2.study) // true

静态方法、静态属性都是使用 static关键字定义的属性、方法只能 class 自己用，不能通过实例继承

类名.静态属性或方法  = 值

 class Student {
        constructor(name, age) {
       
          this.name = name
          this.age = age
          this.subjects = []
        }
        study() {
          console.log(this)
          console.log('good good study')
        }
        static eat() {
          console.log(this)
          console.log('eating')
        }
      }
      const s1 = new Student('zs', 18)
      Student.eat()
      s1.study()

extends 是 ECMAScript 6 中实现继承的简洁语法

 extends 是专门用于实现继承的语法关键字，Person 称为父类、Chinese 称为子类

super 相当于父实例

class Father {
        money = 10000000 //  实例属性
        say = () => {
          console.log('saying')
        }
        constructor(school) {
          this.car = 'audi'
          this.school = school
        }
        manager() {
          console.log('中西管理')
        }
      }

      class Son extends Father {
        constructor() {
          super('哈佛') 
        }

        manager() {
          super.manager()
          console.log('孙子兵法管理模式')
        }
      }
      const s1 = new Son()
      const s2 = new Son()
      console.log(s1.say === s2.say)
      console.log(s1.money)
      console.log(s1.car)
      console.log(s1.school)
      s1.manager()

同步 代码依次执行，上一个任务完成后，下一个任务才执行

异步 遇到耗时任务不必等待其完成。继续执行后面的任务，如定时器、事件回调、ajax请求（axios)

 异步的实现 通过回调函数来执行的

异步容易造成回调地狱

需求 先发 第一次请求，等这次请求回来再发另一次请求 容易造成回调地狱

为了优化异步流程->Promise

 Promise是一个内置构造函数,接受一个函数(executor)作为参数

该参数函数立即调用，该执行函数可以放同步或异步任务，

参数函数接受两个形参resolve,reject,resolve,reject是函数

resolve()调用表示成功  reject()调用表示失败

 promise三个状态 默认状态(等待态)、成功态、失败态

 promise实例身上有个then方法, then方法有两个参数

第一个参数 成功时候的回调                     第二个参数 失败时候的回调

const promise = new Promise((resolve, reject) => {
        setTimeout(() => {
          console.log('执行')
          resolve('data数据')
        }, 1000)
      })
      promise
        .then(
          (data) => {
            console.log(data)
            return new Promise((resolve, reject) => {
              setTimeout(() => {
                resolve('data数据2')
              }, 1000)
            })
          },
          (reason) => {
            console.log(reason)
          }
        )
        .then((data) => {
          console.log(data)
        })

 const promise = new Promise((resolve, reject) => {
        setTimeout(() => {
          console.log('执行')
          resolve('data数据')
        }, 1000)
      })
      promise
        .then(
          (data) => {
            console.log(data)      
            return new Promise((resolve, reject) => {
              resolve('ok')
            })
          },
          (reason) => {
            console.log(reason)
          }
        )
        .then(
          (data) => {
            console.log(data)
          },
          (r) => {
            console.log(r)
          }
        )