ES6中 promise对象

Promise：

1.Promise 是一个ES5中已经出现了，ES6直接写入标准

2.Promise 是一个构造函数，创建了一个数据容器

数据容器：Map,Set,数组，对象等是 被动产生数据，需要给它添加数据

Promise 主动产生数据，不用给它添加数据，而是它自己内部产生数据，再去用它。

怎么会主动产生数据呢？ 网络请求

1.概述

1.Promise是异步编程的一种解决方案，可以替代传统的解决方案----回调函数和事件。ES6统一了用法，并原生提供了Promise对象，从它可以获取异步操作的消息。

2.Promise 异步操作有三种状态：pending（进行中）、fulfilled（已成功）和 rejected（已失败）。除了异步操作的结果，任何其他操作都无法改变这个状态。

注意：Promise从pending状态开始，如果成功就转到成功态fulfilled（已成功），执行resolve回调函数；如果失败就转到失败状态rejected（已失败）并执行reject回调函数.

只能由pending到fulfilled或者从pending到rejected，而且状态不可逆，我们规定pending为“未完结”状态，fulfilled和rejected为“完结”状态。

 3.创造promise实例后，它会立即执行。

4.Promise是一个构造函数，其原型上有then、catch方法，对象上有reject、resolve方法。

5.作为对象，Promise有一下两个特点

01.对象的状态不受外界影响

02.一旦状态改变了就不会在变，也就是说任何时候Promise都只有一种状态。

2.基本用法

可以通过new Promise构造函数创建Promise对象。

var p = new Promise(function(resolve, reject){
    //做一些异步操作
    setTimeout(function(){
        console.log('执行完成');
        resolve('随便什么数据');  //状态转移成功给一个信号出去
    }, 2000);
});

参数说明：resolve：异步操作执行成功后的回调函数  reject：异步操作执行失败后的回调函数 resolve是将Promise的状态置为fullfiled，reject是将Promise的状态置为rejected  

Promise构造函数接收一个函数作为参数，该函数的两个参数是resolve，reject，它们由JavaScript引擎提供（都是官方提供的）。其中resolve函数的作用是当Promise对象的状态转移成功,调用resolve并将操作结果作为其参数传递出去；reject函数的作用是单Promise对象的状态变为失败时，将操作报出的错误作为其参数传递出去。

上面的代码中，直接通过new创建了Promise对象，并没有调用它，但是传进去的函数已经执行了。因此我们用Promise的时候一般是包含在一个函数中，在需要的时候去运行这个函数。

function runAsync(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('执行完成');
            resolve('随便什么数据');
        }, 2000);
    });
    return p;        //返回的是生成的Promise对象     
}
runAsync()

问题1： 包装一个函数有什么用？  

问题2：resolve('随便什么数据');这是做什么用的？

在我们包装好的函数最后，通过return返回了一个Promise对象。也就是说调用这个包装函数可以得到Promise的对象，接下来就可以使用Promise对象上的then与catch方法了。

runAsync().then(function(data){
    console.log(data);
    //后面可以用传过来的数据做些其他操作
    //......
});

在runAsync()的返回上直接调用then方法，then接收一个参数，是函数，函数的参数data将会拿到我们在runAsync中调用resolve时传的的参数。

此时then里面的函数就是回调函数，能够在runAsync这个异步任务执行完成之后被执行。这就是Promise的作用了，简单来讲，就是能把原来的回调写法分离出来，在异步操作执行完后，用链式调用的方式执行回调函数。

自己封装回调函数

function runAsync(callback){
    setTimeout(function(){
        console.log('执行完成');
        callback('随便什么数据');
    }, 2000);
}

runAsync(function(data){
    console.log(data);
});

效果与之前的是一样的。但如果有多层回调怎么办？如果callback也是一个异步操作，而且执行完后也需要有相应的回调函数，该怎么办呢？总不能再定义一个callback2，然后给callback传进去吧。而Promise的优势在于，可以在then方法中继续写Promise对象并返回，然后继续调用then来进行回调操作。

链式操作用法

从表面上看，Promise只是能够简化层层回调的写法，而实质上，Promise的精髓是“状态”，用维护状态、传递状态的方式来使得回调函数能够及时调用，它比传递callback函数要简单、灵活的多。所以使用Promise的正确场景是这样的：

runAsync1()
.then(function(data){
    console.log(data);
    return runAsync2();
})
.then(function(data){
    console.log(data);
    return runAsync3();
})
.then(function(data){
    console.log(data);
});

这样能够按顺序，每隔两秒输出每个异步回调中的内容，在runAsync2中传给resolve的数据，能在接下来的then方法中拿到。运行结果如下：

 runAsync1、runAsync2、runAsync3三个函数定义：

function runAsync1(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务1执行完成');
            resolve('随便什么数据1');
        }, 1000);
    });
    return p;            
}
function runAsync2(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务2执行完成');
            resolve('随便什么数据2');
        }, 2000);
    });
    return p;            
}
function runAsync3(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            console.log('异步任务3执行完成');
            resolve('随便什么数据3');
        }, 2000);
    });
    return p;            
}

在then方法中，你也可以直接return数据而不是Promise对象，在后面的then中就可以接收到数据了。

runAsync1()
.then(function(data){
    console.log(data);
    return runAsync2();
})
.then(function(data){
    console.log(data);
    return '直接返回数据';  //这里直接返回数据
})
.then(function(data){
    console.log(data);
});

执行结果如下：

reject的用法

 事实上，我们前面的例子都是只有“执行成功”的回调，还没有“失败”的情况，reject的作用就是把Promise的状态置为rejected，这样我们在then中就能捕捉到，然后执行“失败”情况的回调。

function getNumber(){
    var p = new Promise(function(resolve, reject){
        //做一些异步操作
        setTimeout(function(){
            var num = Math.ceil(Math.random()*10); //生成1-10的随机数
            if(num<=5){
                resolve(num); //执行成功
            }
            else{
                reject('数字太大了'); //执行失败
            }
        }, 2000);
    });
    return p;            
}

getNumber()
.then(
    function(data){
        console.log('resolved');
        console.log(data);
    }, 
    function(error, data){
        console.log('rejected');
        console.log(error);
    }
);

getNumber函数用来异步获取一个数字，2秒后执行完成，如果数字小于等于5，我们认为是“成功”了，调用resolve修改Promise的状态。否则我们认为是“失败”了，调用reject并传递一个参数，作为失败的原因。

运行getNumber并且在then中传了两个参数，then方法可以接受两个参数，第一个对应resolve的回调，第二个对应reject的回调。所以我们能够分别拿到他们传过来的数据。多次运行这段代码，你会随机得到下面两种结果：

 

 catch的用法

我们知道Promise对象除了then方法，还有一个catch方法，它是做什么用的呢？其实它和then的第二个参数一样，用来指定reject的回调，用法是这样：

getNumber()
.then(function(data){
    console.log('resolved');
    console.log(data);
}).catch(function(reason){
    console.log('rejected');
    console.log(reason);
});

效果和写在then的第二个参数里面一样。不过它还有另外一个作用：在执行resolve的回调（也就是上面then中的第一个参数）时，如果抛出异常了（代码出错了），那么并不会报错卡死js，而是会进到这个catch方法中。

getNumber()
.then(function(data){
    console.log('resolved');
    console.log(data);
    console.log(somedata); //此处的somedata未定义
})
.catch(function(reason){
    console.log('rejected');
    console.log(reason);
});

在resolve的回调中，我们使用了console.log(somedata);而somedata这个变量是没有被定义的。如果我们不用Promise，代码运行到这里就直接在控制台报错了，不往下运行了。但是在这里，会得到这样的结果：

 也就是说进到catch方法里面去了，而且把错误原因传到了reason参数中。即便是有错误的代码也不会报错了，这与我们的try/catch语句有相同的功能。

注意：创建一个Promise对象会立即执行里面的代码，所以为了更好的控制代码的运行时刻，可以将其包含在一个函数中，并将这个Promise作为函数的返回值。就像下面一样：

    <script>
        function greet() {
            var promise = new Promise(function (resolve, reject) {
                var greet = "hello  world";
                resolve(greet);
            });
            return promise;
        }
        greet().then(v => {
            console.log(v); //*
        })
    </script>

3.Promise创建数据容器取数据方法，调用其then函数

1. then是一个异步函数（微任务）

    <script>
        var p1 = new Promise(function(resolve,resolve){
            var n = Math.random();  //生成数据
            resolve(n);   //n1调用了，就代表p1产生了数据
        })
        //p1数据容器取数据用then函数
        var re = p1.then(function(data){
            console.log(data,111);
            return 200;
        })
        //then函数是一个异步函数
        console.log(222);
    </script>

分析：程序先打印 222，再打印111，而不是先打印111，再打印222 

then函数的返回值是 一个新的promise对象

是then传入的回调函数的返回值，这个返回值：

01.如果是一个promise对象，那么就是它

02.如果不是一个promise对象，那么就会把函数的结果包装为一个生成数据了的promise对象。

    <script>
        var p1 = new Promise(function(resolve,reject){
            var n = Math.random();  //生成数据
            resolve(n);   //n1调用了，就代表p1产生了数据
        })
        //p1数据容器取数据用then函数
        var re = p1.then(function(data){
            console.log(data,111);
            return 200;
        })
        //then函数是一个异步函数
        console.log(222);
        // then函数的返回值是 一个新的promise对象
        // 是then传入的回调函数的返回值，这个返回值：
        // 01.如果是一个promise对象，那么就是它
        // 02.如果不是一个promise对象，那么就会把函数的结果包装为一个生成数据了的promise对象。
        re.then((data)=>{console.log(data);})//200
        console.log(re,3333333);
    </script>

此时的re: