关于javascript:可以中断的异步操作

后面咱们聊到了可能超时的异步操作，其中提到对 fetch() 异步操作的“中断”解决。这次咱们就来聊一聊“中断”异步操作。

因为 JavaScript 的单线程个性，能在 JavaScript 中进行的异步场景其实不多，大略有如下一些：

setTimeout() / setInterval()
事件
Ajax
局部对 Native 办法的调用
……

Ajax 解决基本上也能够归为“对 Native 办法调用”一类，因为基本上都是由浏览器提供的 XMLHttpRequest 或者 fetch() 来实现的。所以 Axios、fetch() 和 jQuery.ajax() 等，本人都提供了 abort 的接口。中断 fetch() 曾经在「可能超时的异步操作」中曾经有示例了，这里再给个 jQuery 和 Axios 的示例。

// url 是在 beeceptor.com 上做的一个要 3 秒后响应的 GET 接口
const fetching = $.ajax(url, { type: "get"})
    .done(() => console.log("看不到这句话"))
    .fail(() => console.log("然而能看到这句"));

setTimeout(() => fetching.abort(), 1000);   // 1 秒后中断请求

也能够用 await 的形式来写：

(async () => {
    try {const fetching = $.ajax(url, { type: "get"});
        setTimeout(() => fetching.abort(), 1000);
        await fetching;
        console.log("看不到这句话");
    } catch (err) {console.log("然而能看到这句");
    }
})();

Axios 提供了 CancelToken 来实现中断，这个模式和在前文中中断 fetch() 的 AbortController 和 AbortSignal 是同样的情理。

// Node 中须要 import；浏览器中间接援用的 axios.js 会有全局 axios 对象
import axios from "Axios";

(async () => {const { CancelToken} = axios;
    const source = CancelToken.source();    // 创立一个中断源

    try {setTimeout(() => source.cancel("1 秒中断"), 1000);
        const data = await axios.get(
            url,    // beeceptor.com 上做的一个要 3 秒后响应的 GET 接口
            {cancelToken: source.token   // 把 token 传进去}
        );
        console.log("因为超时中断，看不到这句话");
    } catch (err) {if (axios.isCancel(err)) {console.log("超时中断了 Axios 申请", err);
            // 超时中断了 Axios 申请 Cancel {message: '1 秒中断'}
        } else {console.log("产生其余谬误");
        }
    }
})();

对 setTiemout() / setInteraval() 的中断，能够说是比较简单，应用 clearTimeout() / clearInterval() 就能够办到。

而中断事件 —— 间接登记事件处理函数就好了。不过须要留神的是，局部事件框架在登记事件的时候须要提供注册的那个事件处理函数才有登记，比方 removeEventListener() 就是须要提供原处理函数；而 jQuery 通过 .off()登记事件处理函数时只须要提供名称和 namespace（如果有的话）即可。

不过当这些过程封装在 Promise 中的时候，记得要在“登记”解决的时候 reject（当然，如果约定好了 resolve 一个非凡值也能够）。以 setTimeout 为例：

async function delayToDo() {return new Promise((resolve, reject) => {const timer = setTimeout(() => {resolve("提早后拿到这段文本");
        }, 5000);
        setTimeout(() => {clearTimeout(timer);
            reject("超时了");
        }, 1000);
    });
}

能够说，这段代码是 相当没用 —— 谁会没事在设定一个延时工作之后立刻设置一个更短的超时操作？

如果咱们须要设置一个延时工作，并在前面某种状况下中断它，正确的做法是把 timer 带到延时工作函数里面去，以便其余中央应用。而更好的方法是带出一个 abort() 函数，使语义更精确。

function delayToDo(ms) {
    let timer;
    const promise = new Promise(resolve => {timer = setTimeout(() => {resolve("提早后拿到这段文本");
        }, ms);
    });
    promise.abort = () => clearTimeout(timer);
    return promise;
}

const promise = delayToDo(5000);

// 在其余业务逻辑中通过 promise.abort() 来中断延时工作
setTimeout(() => promise.abort(), 1000);

留神 delayToDo() 不是一个 async 函数。如果应用 async 润饰，咱们是拿不到 return 的 promise 的。在的确须要用 async 润饰的状况下，只好变通一下，通过一个“转运箱”对象把 abort() 带进去。

function delayToDo(ms, transferBox) {return new Promise((resolve, reject) => {const timer = setTimeout(() => {resolve("提早后拿到这段文本");
        }, ms);

        // 如果有转运箱，就把 abort 函数给运出去
        if (transferBox) transferBox.abort = (message) => {clearTimeout(timer);
            reject({abort: true, message});
        };
    });
}

// 定义一个转运箱对象，留神作用域（所以定义在 IIFE 里面）const box = {};

(async () => {
    try {const s = await delayToDo(5000, box);
        console.log("不会输入这句", s);
    } catch (err) {console.log("出错", err);
    }
})();

// 1 秒后通过转运进去的 abort 中断延时操作
setTimeout(() => box.abort("超时中断"), 1000);

// 1 秒后会输入上面这行
// 出错 {abort: true, message: '超时中断'}

应用转运箱的操作，看起来和 Axios 的 CancelToken 很像。只不过 CancelToken 是把信号带到异步操作外面去，而转运箱是把中断函数带到里面来。AbortController 和 CanelToken 的原理差不多，古代环境 (Chrome 66+，Nodejs 15+) 都有 AbortController，无妨尝试用用这个业余工具类。

function delayToDo(ms, signal) {return new Promise((resolve, reject) => {const timer = setTimeout(() => resolve("提早后拿到这段文本"), ms);

        if (signal) {
            // 如果 AbortController 收回了中断信号，会触发 onabort 事件
            signal.onabort = () => {clearTimeout(timer);
                reject({abort: true, message: "timeout"});
            };
        }
    });
}

const abortController = new AbortController();
(async () => {
    try {const s = await delayToDo(5000, abortController.signal);
        console.log("不会输入这句", s);
    } catch (err) {console.log("出错", err);
    }
})();

setTimeout(() => abortController.abort(), 1000);

这段代码和下面那段其实没有多大区别，只不过应用了 AbortController 之后语义更明确一些。毕竟它是专门用来干“中断”这件事的。但遗憾的是 AbortController 的 abort() 办法不带任何参数，不能把中断音讯（起因）带进去。

AbortController 还在试验阶段，并不是很成熟，所以有一些不现实也很失常。然而这个原理说起来其实不难，无妨本人实现一个。

这段 JavaScript 代码应用 ESM 语法、Private field、Field declarations、Symbol 等。若不明确请查 MDN。

const ABORT = Symbol("abort");

export class MyAbortSingal {
    #onabort;
    aborted;
    reson;

    // 应用模块内未导出的 ABORT Symbol 来定义，目标有两个
    // 1) 防止被用户调用
    // 2) 给 MyAbort 调用（如果做成 private field，MyAbort 就不能拜访）[ABORT](reson) {
        this.reson = reson;
        this.aborted = true;
        if (this.#onabort) {this.#onabort(reson);
        }
    }

    // 容许设置 onabort，但不容许获取（也不须要获取）set onabort(fn) {if (typeof fn === "function") {this.#onabort = fn;}
    }
}

export class MyAbort {
    #signal;

    constructor() {this.#signal = new MyAbortSingal();
    }

    // 容许获取 signal，但不容许设置
    get signal() { return this.#signal;}

    abort(reson) {this.#signal[ABORT](reson);
    }
}

用 MyAbort 能够间接替换掉后面示例代码中的 AbortController。而且在调用 .abort() 的时候还能够传入起因，变动的代码如下：

import {MyAbort} from "./my-abort.js";

function delayToDo(ms, signal) {return new Promise((resolve, reject) => {
        ...
        reject({abort: true, message: signal.reson});
        ...    
    });
}

const abortController = new MyAbort();
...

setTimeout(() => abortController.abort("一秒超时"), 1000);

对于定时器和事件，次要是采纳了“登记”的伎俩来进行中断。但实际上这个粒度可能有点粗。

如果有一件事件，须要一直地去尝试，直到胜利为止。这种事件通常会写成一个死循环，直至达到目标才会跳出循环。如果不是 JavaScript，比方 Java 或者 C#，个别会开个新线程来干，而后在每次循环的时候都检查一下是否存在 abort 信号，如果有就中断。

JavaScript 是单线程，要写死循环就是真死。不过有就变通的方法 —— 应用 setInterval() 来周期性的解决，就像一个循环一样，一直地隔一段时间就去解决一次，直到应用 clearInterval() 来完结掉（就像是退出循环）。跟循环一产，在周期性解决的过程中，是能够判断 abort 信号的，就像这样：

function loop(signal) {
    const timer = setInterval(() => {if (signal.aborted) {clearInterval(timer);
                return;
            }
            // TODO 业务解决
        },
        200
    );
    signal.onabort = () => clearInterval(timer);
}

const ac = new AbortController();
loop(ac.signal);

你看，死循环并不是真死，还是要留中断接口的。

除了循环，还有一些异步操作也是很花工夫的。比如说，解决某个业务须要跟后端屡次交互：

通过用户输出的信息进行认证
拿到认证之后去获取用户根本信息
从用户信息的部门编号去拿部门信息
依据部门信息去获取本部门相干的数据

这里举例的业务操作有这么多步骤，其实是能够跟后端协商简化的，但它不在咱们明天探讨的范畴内。理论的业务中也的确会存在不少须要多个步骤来解决实现的状况。咱们当初要探讨的是怎么中断。先看看这个业务过程的示例代码：

async function longBusiness() {const auth = await remoteAuth();
    const userInfo = await fetchUserInfo(auth.token);
    const department = await fetchDepartment(userInfo.departmentId);
    const data = await fetchData(department);
    dealWithData();}

语句不多，但很耗时。如果一次交互须要花 1 秒，这个操作实现至多须要 4 秒。如果用户在第 2 秒的时候想中断，怎么办？

其实和下面解决 setInterval() 一样，适当插入对 abort 信号的查看就好：

async function sleep(ms) {return new Promise(resolve => setTimeout(() => {console.log(` 实现 ${ms} 工作 `);
        resolve();}, ms));
}

// 模仿异步函数
const remoteAuth = () => sleep(1000);
const fetchUserInfo = () => sleep(2000);
const fetchDepartment = () => sleep(3000);
const fetchData = () => sleep(4000);

async function longBusiness(signal) {
    try {const auth = await remoteAuth();
        checkAbort();
        const userInfo = await fetchUserInfo(auth?.token);
        checkAbort();
        const department = await fetchDepartment(userInfo?.departmentId);
        checkAbort();
        const data = await fetchData(department);
        checkAbort();
        // TODO 解决数据
    } catch (err) {if (err === signal) {console.log("中断退出");
            return;
        }
        // 其余状况是业务谬误，应该进行容错解决，或者抛出去给外层逻辑解决
        throw err;
    }

    function checkAbort() {if (signal.aborted) {
            // 抛出的性能在 catch 中查看进去就行，最好定义一个 AbortError
            throw signal;
        }
    }
}

const ac = new AbortController();
longBusiness(ac.signal);

setTimeout(() => {ac.abort();
}, 2000);

longBusiness() 在每一次执行了耗时的操作就进行一个 abort 信号查看。示例中如果查看到 abort 信息，就会抛出异样来中断程序。应用抛出异样的办法来中断程序会比拟不便，如果不喜爱也能够用 if 分支来解决，比方 if (signal.aborted) {return;}。

这段示例程序会实现两个耗时工作，因为申请中断的时候，第二个耗时工作正在进行中，要它完结之后才有下一次 abort 信息查看。

总的来说，中断并不难。然而咱们在写程序的时候，往往会忘掉对耗时程序进行可能须要的中断解决。必要的中断解决能够节约计算资源，晋升用户体验。有适合的业务场景无妨试试！

关于javascript:可以中断的异步操作

中断 Ajax 操作

jQuery 的 jqXHR 提供了 .abort()

中断 Axios 申请

中断定时器和事件

带出一个 abort() 函数

用转运箱对象把 abort() 运出来

应用 AbortController & AbortSignal

实现一个 MyAbort

更粗疏地中断

中断死循环

中断简单的多步骤异步操作

小结