function debounce_easy(func, waitTime){
    // 用于存储定时器
    let timeout;
    // 存储返回结果
    let result;
    return function(){
        let context = this;
        let args = arguments;
        // 如果定时器存在，就清除定时器
        clearTimeout(timeout);
        // 重新设置定时器
        timeout = setTimeout(function(){
            // 执行函数，将当前作用域绑定的this和参数传递过去
            result = func.apply(context, args);
        }, waitTime);
    }
}
// 单元测试
const debounced = debounce_easy(function (value) {
    console.log('debounce_easy:', value)
    ++callCount;
    return value;
}, 32);
// 这里等同于快速触发4次，只有最后一次生效 输出 debounce_easy: d
const results = [debounced('a'), debounced('b'), debounced('c'), debounced('d')];
let lodashResults = [lodashDebouce('a'), lodashDebouce('b'), lodashDebouce('c'), lodashDebouce('d')];
// callCount: 0
console.log('callCount:', callCount)
setTimeout(function () {
    // callCount: 1
    console.log('callCount:', callCount)
}, 160);

// 其实就是在定时器之前判断 leading和 timeout定期器是否不为空即可 关键代码如下
// 如果leading为true，就立即执行函数
if (leading) {
    // 如果定时器不存在，就执行函数，从而避免重复执行
    if (!timeout) {
        invokeFunc();
    }
}

/**
 * 取消防抖
 */
const cancel = function () {
    clearTimeout(timeout)
    lastArgs = lastThis = timeout = undefined
}

function throttle(func, wait, leading = true){
    return debounce(func, wait, {
        leading,
        trailing: true,
        'maxWait': wait // 超时时间和控制时间一致就可以了
    })
}

function throttle_eazy(func, wait) {
    let timer = null;
    let lastInvokeTime = 0;
    return function () {
        const context = this;
        const args = arguments;
        function invokeFunc() {
            func.apply(context, args);
            lastInvokeTime = Date.now();
            timer = null;
        }
        wait = +wait || 0;
        // 计算剩余时间
        let remainTime = wait;
        // 如果上次执行时间大于0，说明已经执行过了，计算剩余时间
        if(lastInvokeTime > 0){
            remainTime = wait - (Date.now() - lastInvokeTime);
        }
        // 如果剩余时间小于等于0，说明可以执行了，重置上次执行时间
        if (remainTime <= 0) {
            invokeFunc();
            return;
        }
        // 如果已经开始计时，说明已经有定时器了，直接返回
        if (timer) {
            return;
        }
        // 否则，开始计时
        timer = setTimeout(() => {
            invokeFunc();
        }, remainTime);
    }
}
// 单元测试
; (function () {
    let count = 0;
    const throttled = throttle(() => {
        count++;
        console.log('hello', count);
    }, 200);
    for (let i = 1; i <= 20; i++) {
        setTimeout(() => {
            console.log('触发i~', i * 100)
            throttled();
        }, 100 * i);
    }
    setTimeout(() => {
        // 正确输出10
        console.log(count);
    }, 2200);
})()

const changeInput = throttle((value: string)=>{
  console.log(value);
}, 1000, {
  leading: false,
  trailing: false,
})
// 上述防抖函数将不会按照我们所设想的每隔1秒触发，而是会出现各种异常情况
// 如果触发频率够高可能会执行，如果触发频率低于1秒则不会执行
// 因为leading和trailing都设置为false
// lodash源码没有针对这一情况进行处理，解决方案是 throttle不支持trailing参数设置即可，默认为true