Promise的then要领能够接收前一个函数的实行效果，还能够保证另一个Promise的递次实行，这究竟是怎样做到的呢？

原理图(先上图)

题目需求

怎样保证多个 promise 递次实行？
实例：

var f1 = function (){
    return new  Promise(function (resolve, reject){
        setTimeout(function (){
            console.log("f1 ok!")
            resolve("f1 ok!");
        }, 1000)
    });
}
var f2 = function (){
    return new  Promise(function (resolve, reject){
        setTimeout(function (){
            console.log("f2 ok!")
            resolve("f2 ok!");
        }, 3000)
    });
}
var f3 = function (){
    return new  Promise(function (resolve, reject){
        setTimeout(function (){
            console.log("f3 ok!")
            resolve("f3 ok!");
        }, 2000)
    });
}

固然假如要并行的话，我们很轻易想到 Promise.all 要领:

Promise.all([f1(), f2(), f3()]).then(function (data){
    console.log(data)
})
// f1 ok! 
// f3 ok! 
// f2 ok! 
// ["f1 ok!", "f2 ok!", "f3 ok!"]

假如要递次实行：

f1().then(f2).then(f3)
// f1 ok!
// f2 ok!
// f3 ok!

//或许如许

function f(all) {
    var promise = Promise.resolve();
    all.forEach((p, index) => {
        promise = promise.then(p)
    })
}
f([f1, f2, f3])

那末题目来了，then是怎样做到递次实行的呢，参数既能够是一个一般函数，也但是是一个返回promise的函数？

then的奥妙

许多完成promise的库都比较复杂，假如本身完成的话，能够自创下面简朴的代码：

Promise.prototype.then = function(onFulfilled, onRejected) {
    var promise = this;
    return new Promise(function(resolve, reject) {
        function handle(value) {
            var ret = typeof onFulfilled === 'function' && onFulfilled(value) || value;
            if (ret && typeof ret['then'] == 'function') {
                ret.then(function(value) {
                    resolve(value);
                }, function(reason) {
                    reject(reason);
                });
            } else {
                resolve(ret);
            }
        }
        function errback(reason) {
            reason = typeof onRejected === 'function' && onRejected(reason) || reason;
            reject(reason);
        }
        if (promise._status === 'PENDING') {
            promise._resolves.push(handle);
            promise._rejects.push(errback);
        } else if (promise._status === FULFILLED) { 
            callback(promise._value);
        } else if (promise._status === REJECTED) {
            errback(promise._reason);
        }
    });
}

重点在then的完成，看上述代码，每一个then返回的是什么，是一个新的 Promise，一个新的 Promise，一个新的 Promise
第二个重点是，在内部又处理了一个 回调函数运转效果是 一个 promise的 推断，假如是那末守候这个promise运转完毕才挪用 resolve 变动状况，症结是resolve的挪用机遇，resolve的挪用机遇，才能够往下实行，这两步就是then函数的症结。
是否是 有点晕，请看最最先的图。