DIV CSS 佈局教程網

再談 JavaScript 異步編程:從回呼地獄到 async/await 的演進
編輯:關於JavaScript     

隨著前端越做越複雜,「異步」這兩個字出現的頻率越來越高。本文用同一個需求貫穿五種寫法,讓你直接看出它們的取捨。

需求是這樣的:向伺服器連續發起數次請求,每次的結果作為下一次的參數。

一、回呼函數(Callback)

最先想到、也最常用。先做一次簡單封裝:

 let makeAjaxCall = (url, cb) => {
    // do some ajax
    // callback with result
}

makeAjaxCall('https://url1', (result) => {
    result = JSON.parse(result)
}) 

看起來還不錯。但當任務需要串接好幾層時:

 makeAjaxCall('https://url1', (result) => {
    result = JSON.parse(result)
    makeAjaxCall(`https://url2?q=${result.query}`, (result) => {
        result = JSON.parse(result)
        makeAjaxCall(`https://url3?q=${result.query}`, (result) => {
            // ...
        })
    })
}) 

那堆收尾的 }) 就是所謂的回呼地獄。它不只是難看,更麻煩的是錯誤處理:每一層都得各自 try/catch,很難統一。

二、借力事件模型

1. Pub/Sub 發布訂閱

DOM 事件處理裡,Pub/Sub 是很常見的機制,例如為元素掛上監聽:

 elem.addEventListener(type, (evt) => {
    // handler
}) 

那麼,能不能構造一個類似模型來驅動異步任務?先建立一個分發中心,實作 on 與 emit:

 let PubSub = {
    events: {},
    on(type, handler) {
        let events = this.events;
        events[type] = events[type] || [];
        events[type].push(handler);
    },
    emit(type, ...datas) {
        let events = this.events;
        if (!events[type]) {
            return;
        }
        events[type].forEach((handler) => handler(...datas));
    }
} 

使用起來是這樣:

 const urls = [
    'https://url1',
    'https://url2',
    'https://url3'
];

let makeAjaxCall = (url) => {
    // do some ajax
    PubSub.emit('ajaxEnd', result);
};

let subscribe = (urls) => {
    let index = 0;
    PubSub.on('ajaxEnd', (result) => {
        result = JSON.parse(result);
        if (urls[++index]) {
            makeAjaxCall(`${urls[index]}?q=${result.query}`);
        }
    });
    makeAjaxCall(urls[0]);
};

相較於回呼,這不算革命性的改變,但有一個實際好處:請求的發起與結果的處理可以放在不同模組,彼此不直接依賴,耦合度降低。代價是流程變得隱性——讀程式碼時得在 on 與 emit 之間來回跳,才能拼出完整順序。

三、Promise:真正的分水嶺

Promise 的出現才是分水嶺。同一個需求寫起來像同步:

 let makeAjaxCall = (url) => {
    return new Promise((resolve, reject) => {
        // do some ajax
        resolve(result);
    });
};

makeAjaxCall('https://url1')
    .then(JSON.parse)
    .then((result) => makeAjaxCall(`https://url2?q=${result.query}`))
    .then(JSON.parse)
    .then((result) => makeAjaxCall(`https://url3?q=${result.query}`));

層次消失了,錯誤也可以在鏈尾用一個 catch 統一處理。別急,還有更好的。

四、Generators

ES6 的另一個利器是 Generator。在 generator function 裡,yield 可以中斷函式執行,外部用 next 繼續迭代;更關鍵的是,next 能向函式內部注入資料,動態改變它的行為:

 function* gen() {
    let a = yield 1;
    let b = yield a * 2;
    return b;
}

let it = gen();
it.next();    // {value: 1, done: false}
it.next(10);  // a = 10,輸出 {value: 20, done: false}
it.next(100); // b = 100,輸出 {value: 100, done: true}

把 makeAjaxCall 包進 generator:

 let makeAjaxCall = (url) => {
    // do some ajax
    iterator.next(result);
};

function* requests() {
    let result = yield makeAjaxCall('https://url1');
    result = JSON.parse(result);

    result = yield makeAjaxCall(`https://url2?q=${result.query}`);
    result = JSON.parse(result);

    result = yield makeAjaxCall(`https://url3?q=${result.query}`);
}

let iterator = requests();
iterator.next();   // 啟動

邏輯清楚得像同步程式碼。但不舒服的點也很明顯:每次都得從外部去 next 注入結果,驅動責任落在呼叫者身上。

五、Promise 混合 Generator

把兩者結合,會出現很有意思的東西:

 let makeAjaxCall = (url) => {
    return new Promise((resolve, reject) => {
        // do some ajax
        resolve(result);
    });
};

// 自動驅動 generator:yield 出 Promise,resolve 後把值送回
let runGen = (gen) => {
    let it = gen();

    let continuer = (value, err) => {
        let ret;
        try {
            ret = err ? it.throw(err) : it.next(value);
        } catch (e) {
            return Promise.reject(e);
        }
        if (ret.done) {
            return ret.value;
        }
        return Promise
            .resolve(ret.value)
            .then(continuer)
            .catch((e) => continuer(null, e));
    };

    return continuer();
};

function* requests() {
    let result = yield makeAjaxCall('https://url1');
    result = JSON.parse(result);

    result = yield makeAjaxCall(`https://url2?q=${result.query}`);
    result = JSON.parse(result);

    result = yield makeAjaxCall(`https://url3?q=${result.query}`);
}

runGen(requests);

runGen 看起來像個自動機,但它做的事其實很單純:yield 出一個 Promise,等它 resolve,把值從 next 送回去,繼續下一輪;若中途拋錯,就用 it.throw 把錯誤注入 generator,讓裡面的 try/catch 有機會處理。

值得一提的是:這個 runGen 幾乎就是 ES7 async function 的雛形。

六、async / await

ES7 把它變成了語言特性:

 let makeAjaxCall = (url) => {
    return new Promise((resolve, reject) => {
        // do some ajax
        resolve(result);
    });
};

;(async () => {
    let result = await makeAjaxCall('https://url1');
    result = JSON.parse(result);

    result = await makeAjaxCall(`https://url2?q=${result.query}`);
    result = JSON.parse(result);

    result = await makeAjaxCall(`https://url3?q=${result.query}`);
})();

await 後面同樣接受一個 Promise。在 async function 中,只有 await 之後的運算式完成,剩下的程式才會繼續執行——這個過程和前面用 runGen 驅動 generator 完全一致,只是語言幫你做了。

演進的脈絡

把五種寫法排在一起,方向就很清楚:

Callback 把「下一步」當參數傳進去,導致巢狀與錯誤分散。

Pub/Sub 用事件解耦,但流程變得隱性。

Promise 把「未來的值」變成一等物件,讓串接可以平鋪,錯誤可以集中。

Generator 提供了「執行到一半交出控制權、之後再回來」的能力。

async/await 則是兩者結合後語法化的結果:用同步的寫法,表達異步的行為。

理解這條脈絡的實際好處是:當你遇到 Promise 不夠用的場景(例如需要中途取消、需要逐步產出多個值),你會知道 generator 與 async 函式背後其實是同一套機制,也知道為什麼 await 只能寫在 async 函式裡。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved