14Days-JS-Pra

// 一个接收三个参数的普通函数
function add(a, b, c) {
    return a + b + c
}

// 柯里化
function curry(func) {
    return function curried(...args) {
        if (func.length <= args.length) {
            // 当参数个数满足要求时，即可带着参数返回函数执行
            return func(...args)
        } else {
            // 参数不够时，返回带着部分参数的函数，继续接收参数
            return function(...nextArgs) {
                return curried(...args, ...nextArgs)
            }
        }
    }
}
const curried = curry(add)
console.log(curried(1)(2)(3)) // => 6

// 创建一个存放Promise对象的结构，使得可以复用这些Promise对象，减少了Promise创建/销毁开销

// 创建对象池
const promisePool = []

// 创建一个Promise
function asyncOperation() {
    return new Promise(res => {
        setTimeout(() => {
            return res('花1秒 创建了一个新的Promise')
        }, 1000)
    })
}

// 对象池拿出操作-如果已存在，从对象池拿出；如果不存在，新建一个
function getPromiseFromPool() {
    if (promisePool.length > 0) {
        return promisePool.pop()
    } else {
        return asyncOperation()
    }
}

// 对象池添加操作
function recyclePromise(promise) {
    promisePool.push(promise)
}

// 使用对象池操作
function performAsyncOperation() {
    const promise = getPromiseFromPool() // 拿出
    promise.then(res => {
        console.log(res) // 后续
        recyclePromise(promise) // 重新放入
    })
}

// 使用
performAsyncOperation()
performAsyncOperation()

var TimeLimitedCache = function() {
    this.map = new Map()
};

TimeLimitedCache.prototype.set = function(key, value, duration) {
    let existed = this.map.has(key)
    if (existed) {
        let temp = this.map.get(key)
        clearTimeout(temp.timer)
    }
    // 过期自动删除
    let timer = setTimeout(() => {
        this.map.delete(key)
    }, duration)
    // 添加/覆盖存储中的键值对
    this.map.set(key, {
        value: value,
        timer: timer
    })
    return existed
};

TimeLimitedCache.prototype.get = function(key) {
    let existed = this.map.has(key)
    if (existed) {
        return this.map.get(key).value
    } else {
        return -1
    }
};


TimeLimitedCache.prototype.count = function() {
    return this.map.size
};

/**
 * Your TimeLimitedCache object will be instantiated and called as such:
 * var obj = new TimeLimitedCache()
 * obj.set(1, 42, 1000); // false
 * obj.get(1) // 42
 * obj.count() // 1
 */

function throttled(fn, delay) {
    let timer = null
    let func = this
    return function(...args) {
        if (!timer) {
            timer = setTimeout(() => {
                fn.apply(func, args)
                timer = null
            }, delay)
        }
    }
}