SOURCE

// 高阶函数的应用

// 柯里化
// 简短的来说就是分步处理
function currying(fn) {
    return (...argu) => {
        let result = fn(argu)

        function _fn(...argu) {
            argu = argu.concat(result)
            result = fn(argu)
            _fn.toString = () => result

            return _fn
        }

        _fn()
        
        return _fn
    }
}

function _add(argu) {
    return argu.reduce((result, currentItem) => result + +currentItem, 0)
}
function _store(argu) {
    return argu.reduce((result, currentItem) => result * +currentItem, 1)
}

const add = currying(_add)
const store = currying(_store)

console.log(add(1)(2)(3))
console.log(add(1, 2)(3))
console.log(store(1, 2)(3)(4))

// 防抖
// 当持续触发事件时，一定时间段内没有再触发事件，事件处理函数才会执行一次，
// 如果设定的时间到来之前，又一次触发了事件，就重新开始延时
function debounce(cb, time) {
    let timeId = null

    return () => {
        if (timeId) clearTimeout(timeId)

        timeId = setTimeout(cb, time)
    }
}


// 节流
// 当持续触发事件时，保证一定时间段内只调用一次事件处理函数
function throttle(cb, time) {
    let preDate = new Date().getTime()

    return () => {
        const nowDate = new Date().getTime()
        if (nowDate - preDate >= time) {
            cb()
            preDate = nowDate
        }
    }
}