隨著前端越做越複雜,「異步」這兩個字出現的頻率越來越高。本文用同一個需求貫穿五種寫法,讓你直接看出它們的取捨。
需求是這樣的:向伺服器連續發起數次請求,每次的結果作為下一次的參數。
最先想到、也最常用。先做一次簡單封裝:
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,很難統一。
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 的出現才是分水嶺。同一個需求寫起來像同步:
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 統一處理。別急,還有更好的。
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 注入結果,驅動責任落在呼叫者身上。
把兩者結合,會出現很有意思的東西:
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 的雛形。
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 函式裡。