Node开发第二天ES6

Promise对象

Promise对象
(1):Promis，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）。
异步和同步:
async : 默认是以异步请求 async:false :同步 请求
(2):有了promise对象, 可以将异步操作以同步操作的流程表达出来, 避免了层层嵌套的回调函数(俗称’回调地狱’)
ES6的Promise是一个构造函数, 用来生成promise实例
状态:
pending: 初始化状态
fulfilled: 成功状态
rejected: 失败状态
使用Promise对象
实例化得到promise对象
resolve:未完成状态更改成功状态
reject:未完成状态更改失败的状态
let promise = new Promise((resolve,reject)=>{ })

Promise实例具体then方法，因此then方法是被定义在对象原型上的，他的作用是为Promise实例添加状态改变时的回调函数。
语法：
Promise实例.then(function(){成功时调用},function(){失败时调用})
then方法返回一个新的Promise对象，因此我们可以采用链式操作，then方法后面调用另一个then方法。

 var promise=new Promise(function(resolve,reject){
            console.log(111);
            setTimeout(()=>{
                console.log(222)
               resolve('成功')
                // reject('失败')
            },1000)
        })
        promise.then(function(resolve){
            console.log('成功')
        },function(reject){
            console.log('失败')
        })

Symbol运算符

symbol 原始数据类型
格式:
let a = Symbol() //实例得到Symbol数据类型
特点:
(1):Symbol数据类型代表唯一 类似你的id
(2):Symbol数据类型数据做比较 返回false
(3)Symbol属性对应的值是唯一的，可以作为标识符，解决命名冲突问题
(4)Symbol值不能与其他数据进行计算，包括同字符串拼接 for in, for of遍历时不会遍历symbol属性。
es5 里面基本数据类型:
string :字符串类型 ("" 还是 ‘’ 都是字符串类型)
number :数字类型
null :空类型
布尔类型(true/false)
undefine 类型
object 对象

Symbol函数前面不能使用new命令*

Symbol函数的参数只是表示当前Symbol值的描述，因此相同参数的Symbol函数的返回值是不相等的。

Iterator遍历器

iterator是一种接口机制，为各种不同的数据结构提供统一的访问机制
作用:
(1)为各种数据结构，提供一个统一的、简便的访问接口，使得数据结构的成员能够按某种次序排列
(2)ES6创造了一种新的遍历命令for…of循环，Iterator接口主要供for…of使用 for(变量名 of(关键字) 循环的内容){ }
支持iterator接口的数据
Array、arguments、set容器、map容器、String…
(3): 每次调用next的时候 返回的值包括一个value done
value 表示 当前成员的值
done 完成 false true
循环完成之后,done的值返回true.
没有循环完数据,done的值返回false;

  var arr = [1, 2, 3,]
        function newa(arr) {
            let index = 0;
            return {
                next: function () {

                    if (index < arr.length) {
                        return { value: arr[index++], done: false };
                    } else {
                        return { value: undefined, done: true };
                    }
                }
            }
        }
        var s = newa(arr)
        console.log(s.next())//{value: 1, done: false}
        console.log(s.next())//{value: 2, done: false}
        console.log(s.next())//{value: 3, done: false}
        console.log(s.next())//{value: undefined, done: true}

Generator函数

Generator函数
(1)ES6提供的解决异步编程的方案之一
Generator函数是一个状态机，内部封装了不同状态的数据，用来生成遍历器对象
可暂停函数(惰性求值), yield可暂停，next方法可启动。每次返回的是yield后的表达式结果
(2): function 与函数名之间有一个星号
格式:
function* 函数名(){
yield表达式1 “值1”, //内部用yield表达式来定义不同的状态
yield表达式2 “值2”,
yield表达式3 “值3”,
}
next() 是内部的方法
(3):遇到yield表达式停止，返回{value: yield后的表达式结果/undefined, done: false/true}
(4):generator函数返回的是指针对象iterator，而不会执行函数内部逻辑
调用next方法函数内部逻辑开始执行，
再次调用next方法会从上一次停止时的yield处开始，直到最后
yield语句返回结果通常为undefined， 当调用next方法时传参内容会作为启动时yield语句的返回值。

  function* fun() {
            yield 'hello';
            yield '123';
            console.log('end');
            yield '!!!';
        }
        var n = fun();
        console.log(n.next())  //{value: "hello", done: false}
        console.log(n.next())  //{value: "123", done: false}
        console.log(n.next())  //end   {value: "!!!", done: false}
        console.log(n.next())  //{value: undefined, done: true}

async函数

async :
(1)含义:真正意义上去解决异步回调的问题，同步流程表达异步操作。本质上为Generator的语法糖
保留Generator的含义 理解为，在这个基础上加了糖
(2)返回是Promise对象
(3)async 不在有next async替代了 *
格式:
async function 函数名(){
await 异步操作;
await 异步操作；
}

  async function sn()
   {
     let res1 = await Promise.resolve("成功执行一次");
     console.log(res1);
     let res2 = await Promise.resolve("成功在执行一次");
     console.log(res2);
     let res3 = await Promise.reject("失败");
     console.log(res3);
   }
   sn();

class

面向对象:
(1):声明一个类:
关键字 class 类名{}
定义类 类名首字母最好大写
实例化类的时候 类名 严格区分大小写
(2):
1.通过class定义类/实现类的继承
2.在类中通过constructor定义构造方法 魔术方法 实例化的时候 自动调用
3.通过new来创建类的实例
4.通过extends(继承) 来实现类的继承
5.通过super调用父类的构造方法
6.重写从父类中继承的一般方法
(3):类里面有成员属性 和 成员方法
(4):子类通过构造方法新增新的内容,必须先要super调用父类的构造方法.

class Stus{   //定义构造方法   当类实例化时自动会触发构造方法 
            constructor(name,age)
            {
                this.name = name; //当前对象属性name 赋值了name
                this.age = age;
            }
            sllp(){   //定义一般的方法  类的成员方法 
             console.log(this.name,this.age);
            }
            show(){
                console.log("在学习");
            }
        }
       let s = new  Stus("武大",30);//实例化得到Stus这个类  //严格区分大小写stus is not defined
       s.sllp();//武大 30
       s.show();//在学习