本文首發於 vivo互聯網技術微信公衆號
鏈接： https://mp.weixin.qq.com/s/UNzYgpnKzmW6bAapYxnXRQ
作者：孔垂亮

很多同學在學習 Promise 時，知其然卻不知其所以然，對其中的用法理解不了。本系列文章由淺入深逐步實現 Promise，並結合流程圖、實例以及動畫進行演示，達到深刻理解 Promise 用法的目的。

本系列文章有如下幾個章節組成：

圖解 Promise 實現原理（一）—— 基礎實現
圖解 Promise 實現原理（二）—— Promise 鏈式調用
圖解 Promise 實現原理（三）—— Promise 原型方法實現
圖解 Promise 實現原理（四）—— Promise 靜態方法實現

本文適合對 Promise 的用法有所瞭解的人閱讀，如果還不清楚，請自行查閱阮一峯老師的《ES6入門之 Promise 對象》。

Promise 規範有很多，如 Promise/A，Promise/B，Promise/D 以及 Promise/A 的升級版 Promise/A+，有興趣的可以去了解下，最終 ES6 中採用了 Promise/A+ 規範。所以本文的Promise源碼是按照Promise/A+規範來編寫的（不想看英文版的移步Promise/A+規範中文翻譯）。

引子

爲了讓大家更容易理解，我們從一個場景開始，一步一步跟着思路思考，會更容易看懂。

考慮下面一種獲取用戶 id 的請求處理：

//不使用Promise        
http.get('some_url', function (result) {
    //do something
    console.log(result.id);
});

//使用Promise
new Promise(function (resolve) {
    //異步請求
    http.get('some_url', function (result) {
        resolve(result.id)
    })
}).then(function (id) {
    //do something
    console.log(id);
})

乍一看，好像不使用 Promise 更簡潔一些。其實不然，設想一下，如果有好幾個依賴的前置請求都是異步的，此時如果沒有 Promise ，那回調函數要一層一層嵌套，看起來就很不舒服了。如下：

//不使用Promise        
http.get('some_url', function (id) {
    //do something
    http.get('getNameById', id, function (name) {
        //do something
        http.get('getCourseByName', name, function (course) {
            //dong something
            http.get('getCourseDetailByCourse', function (courseDetail) {
                //do something
            })
        })
    })
});

//使用Promise
function getUserId(url) {
    return new Promise(function (resolve) {
        //異步請求
        http.get(url, function (id) {
            resolve(id)
        })
    })
}
getUserId('some_url').then(function (id) {
    //do something
    return getNameById(id); // getNameById 是和 getUserId 一樣的Promise封裝。下同
}).then(function (name) {
    //do something
    return getCourseByName(name);
}).then(function (course) {
    //do something
    return getCourseDetailByCourse(course);
}).then(function (courseDetail) {
    //do something
});

實現原理

說到底，Promise 也還是使用回調函數，只不過是把回調封裝在了內部，使用上一直通過 then 方法的鏈式調用，使得多層的回調嵌套看起來變成了同一層的，書寫上以及理解上會更直觀和簡潔一些。

一、基礎版本

//極簡的實現
class Promise {
    callbacks = [];
    constructor(fn) {
        fn(this._resolve.bind(this));
    }
    then(onFulfilled) {
        this.callbacks.push(onFulfilled);
    }
    _resolve(value) {
        this.callbacks.forEach(fn => fn(value));
    }
}

//Promise應用
let p = new Promise(resolve => {
    setTimeout(() => {
        console.log('done');
        resolve('5秒');
    }, 5000);
}).then((tip) => {
    console.log(tip);
})

上述代碼很簡單，大致的邏輯是這樣的：

調用 then 方法，將想要在 Promise 異步操作成功時執行的 onFulfilled 放入callbacks隊列，其實也就是註冊回調函數，可以向觀察者模式方向思考；
創建 Promise 實例時傳入的函數會被賦予一個函數類型的參數，即 resolve，它接收一個參數 value，代表異步操作返回的結果，當異步操作執行成功後，會調用resolve方法，這時候其實真正執行的操作是將 callbacks 隊列中的回調一一執行。

（圖：基礎版本實現原理）

首先 new Promise 時，傳給 Promise 的函數設置定時器模擬異步的場景，接着調用 Promise 對象的 then 方法註冊異步操作完成後的 onFulfilled，最後當異步操作完成時，調用 resolve(value)，執行 then 方法註冊的 onFulfilled。

then 方法註冊的 onFulfilled 是存在一個數組中，可見 then 方法可以調用多次，註冊的多個onFulfilled 會在異步操作完成後根據添加的順序依次執行。如下：

//then 的說明
let p = new Promise(resolve => {
    setTimeout(() => {
        console.log('done');
        resolve('5秒');
    }, 5000);
});

p.then(tip => {
    console.log('then1', tip);
});

p.then(tip => {
    console.log('then2', tip);
});

上例中，要先定義一個變量 p ，然後 p.then 兩次。而規範中要求，then 方法應該能夠鏈式調用。實現也簡單，只需要在 then 中 return this 即可。如下所示：

//極簡的實現+鏈式調用
class Promise {
    callbacks = [];
    constructor(fn) {
        fn(this._resolve.bind(this));
    }
    then(onFulfilled) {
        this.callbacks.push(onFulfilled);
        return this;//看這裏
    }
    _resolve(value) {
        this.callbacks.forEach(fn => fn(value));
    }
}

let p = new Promise(resolve => {
    setTimeout(() => {
        console.log('done');
        resolve('5秒');
    }, 5000);
}).then(tip => {
    console.log('then1', tip);
}).then(tip => {
    console.log('then2', tip);
});

（圖：基礎版本的鏈式調用）

二、加入延遲機制

上面 Promise 的實現存在一個問題：如果在 then 方法註冊 onFulfilled 之前，resolve 就執行了，onFulfilled 就不會執行到了。比如上面的例子中我們把 setTimout 去掉：

//同步執行了resolve
let p = new Promise(resolve => {
    console.log('同步執行');
    resolve('同步執行');
}).then(tip => {
    console.log('then1', tip);
}).then(tip => {
    console.log('then2', tip);
});

執行結果顯示，只有 "同步執行" 被打印了出來，後面的 "then1" 和 "then2" 均沒有打印出來。再回去看下 Promise 的源碼，也很好理解，resolve 執行時，callbacks 還是空數組，還沒有onFulfilled 註冊上來。

這顯然是不允許的，Promises/A+規範明確要求回調需要通過異步方式執行，用以保證一致可靠的執行順序。因此要加入一些處理，保證在 resolve 執行之前，then 方法已經註冊完所有的回調：

//極簡的實現+鏈式調用+延遲機制
class Promise {
    callbacks = [];
    constructor(fn) {
        fn(this._resolve.bind(this));
    }
    then(onFulfilled) {
        this.callbacks.push(onFulfilled);
        return this;
    }
    _resolve(value) {
        setTimeout(() => {//看這裏
            this.callbacks.forEach(fn => fn(value));
        });
    }
}

在 resolve 中增加定時器，通過 setTimeout 機制，將 resolve 中執行回調的邏輯放置到JS任務隊列末尾，以保證在 resolve 執行時，then方法的 onFulfilled 已經註冊完成。

（圖：延遲機制）

但是這樣依然存在問題，在 resolve 執行後，再通過 then 註冊上來的 onFulfilled 都沒有機會執行了。如下所示，我們加了延遲後，then1 和 then2 可以打印出來了，但下例中的 then3 依然打印不出來。所以我們需要增加狀態，並且保存 resolve 的值。

let p = new Promise(resolve => {
    console.log('同步執行');
    resolve('同步執行');
}).then(tip => {
    console.log('then1', tip);
}).then(tip => {
    console.log('then2', tip);
});

setTimeout(() => {
    p.then(tip => {
        console.log('then3', tip);
    })
});

三、增加狀態

爲了解決上一節拋出的問題，我們必須加入狀態機制，也就是大家熟知的 pending、fulfilled、rejected。

Promises/A+ 規範中明確規定了，pending 可以轉化爲 fulfilled 或 rejected 並且只能轉化一次，也就是說如果 pending 轉化到 fulfilled 狀態，那麼就不能再轉化到 rejected。並且 fulfilled 和 rejected 狀態只能由 pending 轉化而來，兩者之間不能互相轉換。

增加狀態後的實現是這樣的

//極簡的實現+鏈式調用+延遲機制+狀態
class Promise {
    callbacks = [];
    state = 'pending';//增加狀態
    value = null;//保存結果
    constructor(fn) {
        fn(this._resolve.bind(this));
    }
    then(onFulfilled) {
        if (this.state === 'pending') {//在resolve之前，跟之前邏輯一樣，添加到callbacks中
            this.callbacks.push(onFulfilled);
        } else {//在resolve之後，直接執行回調，返回結果了
            onFulfilled(this.value);
        }
        return this;
    }
    _resolve(value) {
        this.state = 'fulfilled';//改變狀態
        this.value = value;//保存結果
        this.callbacks.forEach(fn => fn(value));
    }
}

注意：當增加完狀態之後，原先的_resolve中的定時器可以去掉了。當reolve同步執行時，雖然callbacks爲空，回調函數還沒有註冊上來，但沒有關係，因爲後面註冊上來時，判斷狀態爲fulfilled，會立即執行回調。

（圖：Promise 狀態管理）

實現源碼中只增加了 fulfilled 的狀態和 onFulfilled 的回調，但爲了完整性，在示意圖中增加了 rejected 和 onRejected 。後面章節會實現。

resolve 執行時，會將狀態設置爲 fulfilled ，並把 value 的值存起來，在此之後調用 then 添加的新回調，都會立即執行，直接返回保存的value值。

（Promise 狀態變化演示動畫）

詳情請點擊： https://mp.weixin.qq.com/s/UNzYgpnKzmW6bAapYxnXRQ

至此，一個初具功能的Promise就實現好了，它實現了 then，實現了鏈式調用，實現了狀態管理等等。但仔細想想，鏈式調用的實現只是在 then 中 return 了 this，因爲是同一個實例，調用再多次 then 也只能返回相同的一個結果，這顯然是不能滿足我們的要求的。下一節，講述如何實現真正的鏈式調用。

圖解 Promise 實現原理（一）—— 基礎實現

引子

實現原理

一、基礎版本

二、加入延遲機制

三、增加狀態

關於遊戲付費的一點想法

我通過CKA和CKS啦！

圖解 Promise 實現原理（三）—— Promise 原型方法實現

圖解 Promise 實現原理（二）—— Promise 鏈式調用

悟空活動中臺 - 微組件狀態管理（上）

圖解 Promise 實現原理（一）—— 基礎實現

vivo 大規模特徵存儲實踐

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結