十一、函数柯里化 和ajax重连

函数柯里化：一个函数可以接收多个参数，反复被调用,被称为函数柯里化

 function currying() {
            const args = Array.prototype.slice.call(arguments)
            function inner() {
                args.push(...arguments)
                return inner
            }
            inner.__proto__[Symbol.toPrimitive] = inner.getValue = function() {
                return args.reduce((sum, cur) => sum + cur, 0)
            }
            return inner
        }
        // const res = currying(1,2,3,4)(6)(7,8)
        // const resVal = res.getValue()
        const resVal = currying(1,2,3,4)(6)(7,8)
        console.log(resVal + 0)

ajax重连： 实现ajax请求，自动在失败的时候重新连接。

        function request() {
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    const res = Math.random() // 0- 0.99999
                    if (res > 0.9) {
                        resolve(res)
                    } else {
                        reject(res)
                    }
                }, 10)
            })
        }

        function retry(fn, times = 0, delay = 1000) {
            return new Promise((resolve, reject) => {
                async function inner() {
                    try {
                        const res = await fn()
                        resolve(res)
                    } catch (err) {
                        times-- //剩余次数
                        console.log('失败，剩余次数:', times)
                        if (times <= 0) {
                            reject(err)
                        } else {
                            setTimeout(inner, delay)
                        }   
                    }
                }
                inner()
            })
        }

        // 函数设计
        retry(request, 3, 2000)
            .then(res => {
                console.log(res, '成功')
            })
            .catch(e => {
                console.log(e, '失败')
            })