本文实例讲述了javascript 函数的暂停和恢复。分享给大家供大家参考，具体如下：javascript 异步编程从来都是一个难题，最开始我们用 callback，但随之触发了回调地狱，于是“发明” Promise 解决 callback 嵌套过深的问题。然而由于滥用 Promise（一连串的 then），代码变得不易阅读了。此时，async-await 横空出世，它让我们可以用同步的方式编写异步代码，简直 amazing，以至于有人说它就是 javascript 异步编程的银弹。P.S.代码只是演示，并不可用
function getProfile(id) {
return window.fetch(`https://api.com/wedding/profile/${weddingId}`
}

async function getWeddingDetail(weddingId) {
try {

// 暂停执行

const wedding = await window.fetch(`https://api.com/wedding/${weddingId}`);

// 当结果返回恢复执行，接着继续暂停

const groom = await getProfile(wedding.groomId);

// ... 恢复执行 -> 暂停 ...

const bride = await getProfile(wedding.brideId);

// ... 恢复执行

return { wedding, bride, groom };
} catch (error) {

handleError(error);
}
}


function getProfile(id) {
return window.fetch(`https://api.com/wedding/profile/${weddingId}`
}

async function getWeddingDetail(weddingId) {
try {

// 暂停执行

const wedding = await window.fetch(`https://api.com/wedding/${weddingId}`);

// 当结果返回恢复执行，接着继续暂停

const groom = await getProfile(wedding.groomId);

// ... 恢复执行 -> 暂停 ...

const bride = await getProfile(wedding.brideId);

// ... 恢复执行

return { wedding, bride, groom };
} catch (error) {

handleError(error);
}
}

没有银弹没有银弹然而计算机科学领域中并不存在银弹。async-await 也有缺点，比如你忘了写 await，不信？假设别人编写了一个工具函数叫getProfile，如果不了解它的具体实现，你是不是就把它当做同步函数，即便getProfile是异步的。当然，这只是一个小问题，更让我难受的是，如果你在一个函数中使用了 async，那么调用它的函数也得变成一个 async，若还有另一个函数要调用这个调用函数......holly shit！现在你明白了吧。有没有两全其美的办法？
// getWeddingDetail 根本不用关心内部的函数是异步or同步
function getWeddingDetail(weddingId) {
const wedding = window.fetch(`https://api.com/wedding/${weddingId}`);
const groom = getProfile(wedding.groomId);
const bride = getProfile(wedding.brideId);
return { wedding, bride, groom };
}


// getWeddingDetail 根本不用关心内部的函数是异步or同步
function getWeddingDetail(weddingId) {
const wedding = window.fetch(`https://api.com/wedding/${weddingId}`);
const groom = getProfile(wedding.groomId);
const bride = getProfile(wedding.brideId);
return { wedding, bride, groom };
}

没有什么是一个中间层解决不了的没有什么是一个中间层解决不了的异步编程的核心，就是函数暂停和恢复执行。而决定一个函数是暂停还是恢复执行，这是 js 运行时干的活儿，难不成我们今天要深入引擎实现？No！我不了解 C++，也不懂 js 引擎是如何实现的。但是呢，我可以写一个中间层（函数runtime），尝试实现上面的需求，当然，这会有一些限制。一、入口函数一、入口函数假设要运行的函数如下：
function main() {
const id = 123;
console.log('Getting wedding:', id);

const { wedding, bride, groom } = getWeddingDetail(id);

console.log('Wedding detail:', wedding);
}


function main() {
const id = 123;
console.log('Getting wedding:', id);

const { wedding, bride, groom } = getWeddingDetail(id);

console.log('Wedding detail:', wedding);
}

我们期望能够按照下面的方式运行：
function runtime(mainFn) {
mainFn();
}

// start runtime
runtime(main);


function runtime(mainFn) {
mainFn();
}

// start runtime
runtime(main);

基本框架已经有了，接着干啥？首先，要搞清楚在不用 await 的前提下，如何中断函数运行。然后，在合适的地方恢复执行。js 中有两种方法中断函数运行：return和throw。我选择 throw，因为它表示遭遇异常导致的中断。好了，我们改造一下 runtime
function runtime(mainFn) {
const _originalFetch = window.fetch;
window.fetch = (url, options) => {

// "暂停"

throw new Error();
};
// 运行入口函数
runMain();

function runMain() {

try {

mainFn();

} catch (error) {

// 函数 "暂停"

// 恢复并重新执行 mainFn

runMain();

}
}
}


function runtime(mainFn) {
const _originalFetch = window.fetch;
window.fetch = (url, options) => {

// "暂停"

throw new Error();
};
// 运行入口函数
runMain();

function runMain() {

try {

mainFn();

} catch (error) {

// 函数 "暂停"

// 恢复并重新执行 mainFn

runMain();

}
}
}

先忽略这段代码出现的问题，把目光聚集在函数“中断”“恢复”这两个点上，显然，目的已经达到。接下来对它进行优化。首当其冲的是 runMain，只需要当 window.fetch 成功后再执行：
function runtime(mainFn) {
const _originalFetch = window.fetch
window.fetch = (url, options) => {

_originalFetch(url, options).then(res => {

// 返回结果后恢复执行

runMain()

})

throw new Error()
}

runMain();

function runMain() {

try {

mainFn();

} catch (error) {

// ignore

}
}
}


function runtime(mainFn) {
const _originalFetch = window.fetch
window.fetch = (url, options) => {

_originalFetch(url, options).then(res => {

// 返回结果后恢复执行

runMain()

})

throw new Error()
}

runMain();

function runMain() {

try {

mainFn();

} catch (error) {

// ignore

}
}
}

window.fetch 每次抛出异常，这导致 mainFn 无限循环的执行。要解决这个问题，需要引入缓存，使得我们仅需要在第一次 fetch 时抛出异常，而为后面的请求返回响应。
function runtime(mainFn) {
const _originalFetch = window.fetch
windo.fetch = (url, options) => {

if (cache.has([url, options])) return cache.get([url, options])


_originalFetch(url, options).then(res => {

cache.set([url, options], res)

runMain()

})


throw new Error()
}

runMain();

function runMain() {

try {

mainFn();

} catch (error) {

// ignore

}
}
}


function runtime(mainFn) {
const _originalFetch = window.fetch
windo.fetch = (url, options) => {

if (cache.has([url, options])) return cache.get([url, options])


_originalFetch(url, options).then(res => {

cache.set([url, options], res)

runMain()

})


throw new Error()
}

runMain();

function runMain() {

try {

mainFn();

} catch (error) {

// ignore

}
}
}

成功啦！运行程序，检查 console 的输出，由于重复运行了多次，'Getting wedding:', 123也被显示了多次，这是 console.log 的副作用导致的。'Getting wedding:', 123二、纯函数二、纯函数runtime 只允许运行纯函数，如果你的代码中有副作用，则必须添加限制条件：runSideEffects().
function main() {
const id = 123;
runSideEffects(() => console.log('Getting wedding:', id));

const { wedding, bride, groom } = getWeddingDetail(id);

runSideEffects(() => console.log('Wedding detail:', wedding));
}


function main() {
const id = 123;
runSideEffects(() => console.log('Getting wedding:', id));

const { wedding, bride, groom } = getWeddingDetail(id);

runSideEffects(() => console.log('Wedding detail:', wedding));
}

sideEffects 的实现非常容易：
function runtime(mainFn) {
// 参考上面的代码

// 提供 `runSideEffects`
const sideEffects = [];
window.runSideEffects = fn => {

sideEffects.push(fn);
};

runMain();

function runMain() {

try {

mainFn();

sideEffects.forEach(fn => fn());

} catch (error) {

// 清除副作用

sideEffects.splice(0, sideEffects.length);

}
}

}


function runtime(mainFn) {
// 参考上面的代码

// 提供 `runSideEffects`
const sideEffects = [];
window.runSideEffects = fn => {

sideEffects.push(fn);
};

runMain();

function runMain() {

try {

mainFn();

sideEffects.forEach(fn => fn());

} catch (error) {

// 清除副作用

sideEffects.splice(0, sideEffects.length);

}
}

}

再次运行，'Getting wedding:', 123只显示一次啦~'Getting wedding:', 123到底干了些啥？
到底干了些啥？为了模仿函数暂停和恢复，我们通过 throw 一个错误来“暂停”函数，重新运行来“恢复”函数。为了从暂停处“恢复”，需要将抛出的错误替换成函数返回值，我们用缓存机制达到了这个目的。最后，为了能安全的重复执行函数，需要将它转化为一个纯函数。如果有副作用，则将它们收集起来，在函数运行成功后，再执行副作用。扯这么多，有什么实际用途？
扯这么多，有什么实际用途？
本文的灵感来自于React Suspense。有了 Suspense，就可以像下面这样来获取数据：React Suspense
function Component() {
const data = getDataFromNetwork();
return