闭包在工厂函数与高阶函数中的应用 - 智猿学院-IT界的百科全书

好嘞，各位观众老爷们，欢迎来到“闭包漫谈”现场！我是今天的特邀讲解员——码农界的段子手，Bug界的清道夫。今天咱们要聊聊一个听起来高深莫测，用起来却妙趣横生的东西：闭包！

别一听“闭包”俩字就觉得头大，好像进了数学系考研现场。其实啊，闭包就像个贴心小棉袄，在你需要的时候默默提供温暖，在你迷茫的时候指点迷津。它不仅是JavaScript、Python等语言中的重要特性，更是理解函数式编程思想的一把金钥匙🔑。

今天，咱们就用大白话，结合生动形象的例子，把闭包这玩意儿扒个精光，重点看看它在工厂函数和高阶函数里是怎么大显身手的。准备好了吗？Let’s roll！

第一幕：闭包，你这磨人的小妖精！

首先，我们得搞清楚，闭包到底是个什么鬼？用官方一点的说法，闭包是指有权访问另一个函数作用域中的变量的函数。是不是觉得更懵了？没关系，咱换个说法。

想象一下，你是个房东，房子里住着一群变量租客。有一天，你把房子租给了一个函数，这个函数就像个二房东，它不仅自己住，还允许它的内部函数（也就是它的“儿子”、“女儿”）也住进来。

关键来了！当这个二房东函数搬走之后，房子里的某些变量租客（比如房租押金之类的）仍然被它的“儿子”、“女儿”惦记着。即使房东（也就是外层函数）已经把房子收回了，这些“儿子”、“女儿”仍然可以通过某种神秘的力量（也就是闭包）访问到那些变量。

这就是闭包！简单来说，就是函数记住了它出生时候的环境，即使那个环境已经消失了，它仍然能访问到那个环境里的变量。

举个栗子🌰：

function outerFunction(outerVar) {
  function innerFunction(innerVar) {
    console.log("outerVar:", outerVar);
    console.log("innerVar:", innerVar);
  }
  return innerFunction;
}

let myInnerFunction = outerFunction("Hello");
myInnerFunction("World"); // 输出：outerVar: Hello   innerVar: World

在这个例子里，innerFunction就是个闭包。即使outerFunction已经执行完毕，myInnerFunction仍然可以访问到outerVar的值。这就是闭包的魅力所在！它就像一个时光胶囊，把过去的信息保存了下来。

第二幕：工厂函数，批量生产的秘密武器！

接下来，我们来看看闭包在工厂函数里是怎么发挥作用的。

什么是工厂函数？简单来说，就是用来创建对象的函数。它就像一个工厂，你给它一些原材料，它就能帮你生产出你想要的产品。

闭包在工厂函数里的作用，就像是给每个产品打上独特的标记。每个产品都有自己的专属信息，互不干扰。

举个栗子🌰：

function createCounter() {
  let count = 0; // 私有变量

  return {
    increment: function() {
      count++;
      console.log("Count:", count);
    },
    decrement: function() {
      count--;
      console.log("Count:", count);
    },
    getCount: function() {
      return count;
    }
  };
}

let counter1 = createCounter();
let counter2 = createCounter();

counter1.increment(); // 输出：Count: 1
counter1.increment(); // 输出：Count: 2
counter2.increment(); // 输出：Count: 1
counter2.decrement(); // 输出：Count: 0

console.log("counter1 count:", counter1.getCount()); // 输出：counter1 count: 2
console.log("counter2 count:", counter2.getCount()); // 输出：counter2 count: 0

在这个例子里，createCounter就是一个工厂函数。它创建了两个计数器对象counter1和counter2。每个计数器对象都有自己的count变量，互不影响。

这是怎么做到的呢？秘密就在于闭包！increment、decrement和getCount这三个函数都是闭包，它们记住了createCounter函数执行时的环境，也就是count变量。因此，每个计数器对象都有自己独立的count变量。

如果没有闭包，所有的计数器对象都会共享同一个count变量，那就乱套了！想象一下，你去银行取钱，结果发现所有人的账户余额都是一样的，那还得了？😱

表格对比：有闭包 vs. 无闭包

特性	有闭包 (如上例)	无闭包 (共享变量)
数据隔离	每个对象拥有自己的私有变量，互不干扰	所有对象共享同一个变量，互相影响
可靠性	数据安全性高，避免意外修改	数据容易被意外修改，导致程序出错
灵活性	可以创建具有不同状态的对象	所有对象状态相同，缺乏灵活性
代码复杂度	稍微复杂，需要理解闭包的概念	简单易懂，但容易出现问题
适用场景	需要创建多个独立对象，并保持各自状态的场景	简单的、不需要数据隔离的场景

第三幕：高阶函数，函数界的变形金刚！

接下来，我们再来看看闭包在高阶函数里是怎么玩转的。

什么是高阶函数？简单来说，就是可以接受函数作为参数，或者返回函数的函数。它就像一个变形金刚，可以根据你的需求变幻出各种形态。

闭包在高阶函数里的作用，就像是给变形金刚加上各种插件。你可以通过闭包来定制高阶函数的行为，让它更加灵活多变。

举个栗子🌰：

function multiplier(factor) {
  return function(number) {
    return number * factor;
  };
}

let double = multiplier(2);
let triple = multiplier(3);

console.log(double(5)); // 输出：10
console.log(triple(5)); // 输出：15

在这个例子里，multiplier就是一个高阶函数。它接受一个参数factor，并返回一个函数。返回的函数也是一个闭包，它可以访问到multiplier函数执行时的factor变量。

通过multiplier函数，我们可以轻松地创建出各种乘法函数，比如double（乘以2）和triple（乘以3）。这就是高阶函数的威力！它可以让你编写更加通用和灵活的代码。

再来一个更高级的例子，利用闭包实现一个简单的节流函数：

function throttle(func, delay) {
  let timeoutId;
  let lastExecTime = 0;

  return function(...args) {
    const now = Date.now();

    if (!timeoutId) { // 第一次执行
      func.apply(this, args);
      lastExecTime = now;
      timeoutId = null; // 执行后立即清除 timeoutId
    } else {
      const timeSinceLastExec = now - lastExecTime;

      if (timeSinceLastExec >= delay) {
        func.apply(this, args);
        lastExecTime = now;
        timeoutId = null;  // 执行后立即清除 timeoutId
      } else {
        // 延迟执行
        clearTimeout(timeoutId); // 清除之前的定时器，保证在 delay 时间内只执行一次
        timeoutId = setTimeout(() => {
          func.apply(this, args);
          lastExecTime = Date.now(); // 更新 lastExecTime
          timeoutId = null;  // 执行后立即清除 timeoutId
        }, delay - timeSinceLastExec);
      }
    }
  };
}

function logEvent() {
  console.log("Event triggered at:", Date.now());
}

const throttledLogEvent = throttle(logEvent, 200);

// 模拟快速触发事件
for (let i = 0; i < 10; i++) {
  setTimeout(throttledLogEvent, i * 50);
}

在这个例子中，throttle函数返回的函数是一个闭包，它记住了timeoutId和lastExecTime这两个变量，从而实现了节流的功能。节流函数保证了某个函数在一定时间内最多只执行一次，防止过度调用。

第四幕：闭包的注意事项，防踩坑指南！

闭包虽然好用，但也要注意一些坑，否则一不小心就会掉进去。

内存泄漏： 如果闭包引用了大量的外部变量，并且这些闭包长期存在，可能会导致内存泄漏。因为这些变量会一直被保存在内存中，无法被垃圾回收。
变量共享： 在循环中使用闭包时，要特别注意变量共享的问题。如果闭包引用的是循环变量，可能会导致所有闭包都访问到循环的最终值。

避免踩坑的建议：

尽量减少闭包引用的外部变量。
及时释放不再使用的闭包。
在循环中使用闭包时，可以使用立即执行函数表达式（IIFE）来创建独立的变量作用域。

第五幕：总结，闭包的价值！

总而言之，闭包是一种强大的编程技术，它可以让你编写更加灵活、模块化和可维护的代码。它在工厂函数和高阶函数中都有着广泛的应用，可以帮助你解决各种复杂的编程问题。

掌握闭包，就像拥有了一把瑞士军刀，可以应对各种编程挑战。所以，赶紧行动起来，好好学习闭包吧！

最后的彩蛋：表情包总结！

闭包： 🤨 (看起来有点神秘，但其实很实用)
工厂函数： 🏭 (批量生产，效率杠杠的)
高阶函数： 🤖 (变形金刚，灵活多变)
内存泄漏： 😱 (一不小心就崩溃)

希望今天的讲解能让你对闭包有更深入的了解。如果你觉得有所收获，请点个赞，分享给你的朋友们吧！我们下期再见！ 👋

发表回复 取消回复

发表回复取消回复