嘿，老兄，今天咱们聊点儿有意思的——JavaScript 的闭包和高阶函数。

闭包到底是个啥玩意儿？

先说说闭包的概念。

闭包就是内部函数还Neng访问外部函数的变量，即使外部函数Yi经执行完了。

说实话，这听起来有点抽象，咱们来个Zui经典的例子。

function createCounter {
    let count = 0; // 私有变量
    return function  {
        count++;
        return count;
    };
}
const counter = createCounter;
console.log); // 1
console.log); // 2

你kan，count 本该在 createCounter 执行完后被销毁，可是返回的内部函数把它“锁”住了。

那为什么要用闭包呢？

Ke以模拟私有属性，数据不容易被外部随意改动。

Ke以保存状态，让函数记住上一次的运行结果。

配合异步回调，用来捕获当时的上下文。

举个常见的坑：

for  {
    setTimeout => console.log, 100);
}
// 打印：3,3,3

这时Ru果把 var 换成 let，或者用 IIFE 包一层，就Neng得到期望的 0、1、2。

高阶函数是什么？

高阶函数顾名思义，就是“Neng干别的事”的函数。

满足以下任意条件即可：

接受一个或多个函数作为参数。

返回一个新函数。

Neng够对传进来的函数进行“装饰”，比如加日志、限流之类。

常见的高阶函数有 .map, .filter, .reduce, .forEach …… 哈哈，这些dou是数组方法，但底层dou是把回调交给你处理的典型高阶函数。

.map 和 .filter 简单演示

const nums = ;
const doubled = nums.map; // 
const evens   = nums.filter; // 
console.log;

kan，这里传进去的是匿名箭头函数，.map/.filter 本身就是高阶函数。

.reduce——玩转累积计算

const sum = nums.reduce => acc + cur, 0); // 10
console.log;

Curry、partial、compose…这些名字听起来像甜点，其实dou是“把多个小功Neng组合成大功Neng”的技巧，也算是高级点儿的高阶函数字段。

闭包和高阶函数怎么搭配出花样？

AOP在前端里经常用闭包实现，比如下面这个防抖和节流。

.debounce —— 防止抖动触发

function debounce {
    let timer = null;
    return function  {
        clearTimeout;
        timer = setTimeout => fn.apply, delay);
    };
}
window.addEventListener => console.log, 300));

# 小提醒：这里返回的新函数形成了闭包，把 timer 持久化住了不然每次dou新建计时器根本防不了抖啊！哈哈哈，懂吧？

.throttle —— 限速执行

function throttle {
    let lastTime = 0;
    return function  {
        const now = Date.now;
        if  {
            lastTime = now;
            fn.apply;
        }
    };
}
window.addEventListener => console.log, 200));

# 小技巧：这里用到了时间戳变量，同样被闭包锁住以免每次dou重新算起点。

.curry——柯里化，让多参变单参链式调用

function curry {
    return function curried {
        if  {
            return fn;
        }
        return  => curried;
    };
}
function add{return a+b+c;}
const curriedAdd = curry;
console.log); //6
console.log); //6

# 咱就是说这玩意儿在写 Redux reducer 或者 compose pipeline 时超好用。懂得dou懂，不懂别慌，我后面会细聊。

SOTD：实战案例——自定义日志装饰器

function withLog {
    return function  {
        console.log;
        const result = fn.apply;
        console.log;
        return result;
    };
}
function sum{return a+b;}
const loggedSum = withLog;
loggedSum; // 控制台会kan到前后日志

# 不对不对，我差点忘了这其实也是闭包，因为内部保存了原始 a,b,c...`fn` 的引用。这样就Neng在任何地方给任意函数加日志，简直是代码复用神器呀！哈哈哈~

SOTD：记忆化提升性Neng

function memoize{
    const cache={};
    return function{
        const key=JSON.stringify;
        ifreturn cache;
        const res=fn.apply;
        cache=res;
        return res;
    };
}
function fib{
    ifreturn n;
    return fib+fib;
}
const fastFib=memoize;
console.log); // 秒级返回

# 小心点，这里用了闭包保存 `cache` 对象，一旦 `fastFib` 被创建，它就一直带着这个缓存走遍全局。省下的大量递归开销，你懂的～

end——一句话

说白了闭包是 JavaScript 把「作用域」变成「持久容器」的魔法；而高阶函数则是让我们Ke以把这些魔法包装、组合、复用的一套工具箱。 所以当你写出一个Neng够接收/返回另一个函数并且借助闭包保持状态的小玩意儿时你Yi经踏上了「高级前端」的大道啦。 别忘了多练、多想、多调试——代码不是死板教材，它是一种思维方式。 保持好奇心，保持热情，下次再聊别的话题吧~ 祝编码愉快！😊

---