异步管理的一些面试问题

1，最大并行请求数固定，比如2个，方案是记录当前并行的数量curcount，利用递归持续发出请求

 class asyncPromise {
            constructor() {
                this.maxcount = 2  // 最大数
                this.curcont = 0  // 当前请求数
                this.promiseArr = []
            }

            taskStart() {
                if (!this.promiseArr.length) {
                    return false
                }
                for (let i = 0; i < this.maxcount; i++) {
                    this.start()
                }
            }

            start() {
                if (this.curcont > this.maxcount) {
                    return false
                }
                console.log(this.curcont, '322')
                this.curcont++;
                let p = this.promiseArr.pop()
                p && p.then((res) => {
                    this.curcont--
                    this.start()  // 递归
                })
            }

            addPromise(p) {
                this.promiseArr.push(p)
            }
        }

2，点击事件用节流处理

 const synchronousFile = function (id) {
            console.log(id)
        }
        const proxySynchronousFile = (function () {
            let cache = [],
                timer = null
            return function (id) {
                cache.push(id)
                if (timer) {
                    return false
                }
                timer = setTimeout(() => {
                    synchronousFile(cache.join(','))
                    clearTimeout(timer)
                    timer = null
                    cache = []
                }, 2000)
            }
        })();

3, 实现一个allSettled

方案一是利用遍历，保存每个结果当请求结果时resolve

// 方案1
 1 Promise.allSettled = function (promiseArr) {
            return new Promise((resolve, reject) => {
                const len = promiseArr.length,
                    resArr = []
                for (let i = 0; i < len; i++) {
                    promiseArr[i].then((res) => {
                        resArr.push(res)
                        console.log(i, 'ddddddd')
                    }).catch((err) => {
                        resArr.push(err)
                    }).finally(() => {
                        if (len === i + 1) {
                            resolve(resArr)
                        }
                    })
                }
            })
        }

方案二是利用Promise.all，将Promise.all的运行的promise包一层，将其全部返回正确的onFulfilled状态

 const rejectHandler = reason => ({
            status: "rejected",
            reason
        })
        const resolveHandler = value => ({
            status: "fulfilled",
            value
        })
        Promise.allSettled = promises =>
            Promise.all(
                promises.map((promise) =>{
                   return  promise.then(resolveHandler, rejectHandler)
                })
                // 每个 promise 需要用 Promise.resolve 包裹下
                // 以防传递非 promise
            );

4, 异步请求缓存 ，方案利用了函数名的静态对象

 function ajax (name) {
       return new Promise((resolve, reject) =>{
           setTimeout(() => {
               resolve({name: name, age: '27'})
           }, 2000)
       })
   }
   function query (name) {
       const cache = query.cache || (query.cache = new Map())
       if (cache.has(name)) {
           console.log('走缓存了')
           return Promise.resolve(cache.get(name))
       }
       return ajax(name).then((res) => {
           cache.set(name, res)
           console.log(cache)
           return res
       })
   }
   query ('wayke').then((res) => {
       console.log(res)
   })