以fetch为例详解如何消除js异步的传染性

// 接口请求
        async function getList() {
            return await fetch('/list.json').then(res => res.json())
        }
        async function task1() {
            return await getList()
        }
        async function task2() {
            return await task1()
        }
        async function task3() {
            return await task2()
        }
        // 执行task3。获取到了getList的返回值
        console.log(task3().then(res => console.log(res)));

function getList() {
            // 此处发送一个异步请求
            return fetch('/list.json')
        }
        function task1() {
            return getList()
        }
        function task2() {
            return task1()
        }
        function task3() {
            return task2()
        }
        /* 我们先写一个main函数  */
        function main() {
            const task3Run = task3()
            console.log(task3Run)
        }
        function run(fn) {
            /* 判断是否为promise函数 */
            const cache = []
            let i = 0
            const _originalFetch = window.fetch
            window.fetch = (...args) => {
                /* 发送请求，且报错 */
                /* 判断缓存如果存在，则交付缓存 */
                if (cache[i]) {
                    if (cache[i].status == 'fulfillled') {
                        return cache[i].data
                    } else if (cache[i].status == 'rejected') {
                        throw cache[i].err
                    }
                }
                const result = {
                    status: 'pending',
                    data: null,
                    err: null
                }
                cache[i++] = result
                const prom = _originalFetch(...args)
                    .then(res => res.json())
                    .then((resolve)=> {
                        result.status = 'fulfillled'
                        result.data = resolve
                    }, (inject) => {
                        result.status = 'rejected'
                        result.err = inject
                    })
                // 报错
                throw prom
            }
            try {
                fn()
            } catch (err) {
                if (err instanceof Promise) {
                    const reRun = () => {
                        i = 0;
                        fn()
                    }
                    err.then(reRun, reRun)
                }
            }
        }
        run(main)