Promise

Promise

setTimeout()

function callback() {
    console.log('Done');
}
console.log('before setTimeout()');
setTimeout(callback, 1000); // 1秒钟后调用callback函数
console.log('after setTimeout()');

AJAX有没有更好的写法？比如写成这样：

var ajax = ajaxGet('http://...');
ajax.ifSuccess(success)
    .ifFail(fail);

这种链式写法的好处在于，先统一执行AJAX逻辑，不关心如何处理结果，然后，根据结果是成功还是失败，在将来的某个时候调用success函数或fail函数。

Promise是如何异步执行的
创建Promise对象，调用函数传入两个函数，当随机数大于2成功则执行resolve函数，失败则执行reject函数
注意：第一个参数表示的函数对应then后的操作，第二个参数表示的函数对应catch后函数的操作

<script>
    new Promise(function (resolve, reject) {
        console.log('start new Promise...');
        var timeOut = Math.random() * 2;
        console.log('set timeout to: ' + timeOut + ' seconds.');
        setTimeout(function () {
            if (timeOut < 1) {
                console.log('call resolve()...');
                resolve('200 OK');
            }
            else {
                console.log('call reject()...');
                reject('timeout in ' + timeOut + ' seconds.');
            }
        }, timeOut * 1000);
    }).then(function (r) {
        console.log('Done: ' + r);
    }).catch(function (reason) {
        console.log('Failed: ' + reason);
    });

</script>

Promise最大的好处是在异步执行的流程中，把执行代码和处理结果的代码清晰地分离了：

Promise串行执行异步任务

Promise还可以做更多的事情，比如，有若干个异步任务，需要先做任务1，如果成功后再做任务2，任何任务失败则不再继续并执行错误处理函数。

要串行执行这样的异步任务，不用Promise需要写一层一层的嵌套代码。有了Promise，我们只需要简单地写：

job1.then(job2).then(job3).catch(handleError);//其中，job1、job2和job3都是Promise对象。

// 0.5秒后返回input*input的计算结果:
function multiply(input) {
    return new Promise(function (resolve, reject) {
        log('calculating ' + input + ' x ' + input + '...');
        setTimeout(resolve, 500, input * input);
    });
}

// 0.5秒后返回input+input的计算结果:
function add(input) {
    return new Promise(function (resolve, reject) {
        log('calculating ' + input + ' + ' + input + '...');
        setTimeout(resolve, 500, input + input);
    });
}

var p = new Promise(function (resolve, reject) {
    log('start new Promise...');
    resolve(123);
});

p.then(multiply)
 .then(add)
 .then(multiply)
 .then(add)
 .then(function (result) {
    log('Got value: ' + result);
});

Promise实现AJAX
把上一节的AJAX异步执行函数转换为Promise对象，看看用Promise如何简化异步处理：

<script>
    'use strict'
    //ajax函数将返回Promise对象
    function ajax(method,url,data){
        var request=new XMLHttpRequest();
        return new Promise(function(resolve,reject){
            request.onreadystatechange=function(){
                if(request.readyState===4){
                    if(request.status===200){
                        resolve(request.responseText);
                    }else{
                        reject(request.status);
                    }
                }
            };
            request.onopen(method,url);
            request.send(data);
        });
    }

    var log=document.getElementById('test-promise-ajax-result');
    var p=ajax('GET','/api/categories');
    p.then(function(test){
        //如果成功则获得响应内容
        log.innerText=text;
    }).catch(function(status){
        //如果失败则获得响应内容
        log.innerText='Error:'+status;
    });

</script>

Promise并行执行异步任务

试想一个页面聊天系统，我们需要从两个不同的URL分别获得用户的个人信息和好友列表，这两个任务是可以并行执行的，用Promise.all()实现如下：

var p1 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 500, 'P1');
});
var p2 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 600, 'P2');
});
// 同时执行p1和p2，并在它们都完成后执行then:
Promise.all([p1, p2]).then(function (results) {
    console.log(results); // 获得一个Array: ['P1', 'P2']
});

Promise竞争执行任务

多个异步任务是为了容错。比如，同时向两个URL读取用户的个人信息，只需要获得先返回的结果即可。这种情况下，用Promise.race()实现：

var p1 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 500, 'P1');
});
var p2 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 600, 'P2');
});
Promise.race([p1, p2]).then(function (result) {
    console.log(result); // 'P1'
});

由于p1执行较快，Promise的then()将获得结果’P1’。p2仍在继续执行，但执行结果将被丢弃。