`
yjandx3543
  • 浏览: 49924 次
  • 性别: Icon_minigender_1
  • 来自: 隐居山林
社区版块
存档分类
最新评论

其实闭包并不高深莫测

 
阅读更多

几年前，我还是一名高中生时，我的一个朋友向我讲述了闭包的概念。虽然我当时一点也不明白他想表达的内容，但他在向我讲述时却表现得非常高大上。对于当时的我来说，闭包看来是一个深不可测的魔法。即使 Google 后也不能解除我的疑惑。而所有我能查阅的科技文章，都为高中生所难以理解。

现在的我回想起高中编程时光，我都会不禁一笑。这是一篇试图用一些简单项目去解释闭包的文章，这会帮助我的学弟学妹们能轻易地驾驭强大的闭包。

计数事件

我们将从一个简单的问题开始。如果将闭包引入到该程序中，将能轻易解决这个问题。

我们为计数事件创建一个机制。该机制将有助于我们跟踪代码的执行，甚至去调试一些问题。例如，我会以下面的方式调用计数器：

 
 
 
 
JavaScript
 
1
2
3
increment();  // Number of events: 1
increment();  // Number of events: 2
increment();  // Number of events: 3

正如你所看到的上述案例，我们希望代码会在我们每次执行 increment() 函数时，会显示一条信息“Number of events: x”。下面以简单的方式实现该函数：

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
varcounter=0;
 
functionincrement(){
  counter=counter+1;
 
  console.log("Number of events: "+counter);
}

 

多个计数器

上述代码非常简单明确。然而，当我们引入第二个计数器时，就会很快遇到问题。当然，我们能实现两个单独的计数器机制，如下面的代码，但很明显有需要改进的地方：

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
varcounter1=0;
 
functionincrementCounter1(){
  counter1=counter1+1;
 
  console.log("Number of events: "+counter1);
}
 
varcounter2=0;
 
functionincrementCounter2(){
  counter2=counter2+1;
 
  console.log("Number of events: "+counter2);
}
 
incrementCounter1();  // Number of events: 1
incrementCounter2();  // Number of events: 1
incrementCounter1();  // Number of events: 2

上述代码出现了不必要的重复。明显地，这种解决办法并不适用于超过二或三个记数器的情况。我们需要想出更好的解决方案。

引入我们第一个闭包

在保持与上述例子相似的情况下，我们以某种方式引入新的计数器，该计数器捆绑了一个能自增的函数，而且没有大量重复的代码。下面尝试使用闭包：

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
10
11
functioncreateCounter(){
  varcounter=0;
 
  functionincrement(){
    counter=counter+1;
 
    console.log("Number of events: "+counter);
  }
 
  returnincrement;
}

让我们看看这是如何工作的。我们将创建两个计数器，并让它们跟踪两个独立的事件：

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
varcounter1=createCounter();
varcounter2=createCounter();
 
counter1();// Number of events: 1
counter1();// Number of events: 2
 
counter2();// Number of events: 1
 
counter1();// Number of events: 3

啊，这看起来有点复杂…然而，这实际上是非常简单的。我们只需将实现逻辑分成几个易于理解的块。下面就看看我们实现了什么：

    • 首先，创建了一个名为 counter 的局部变量。
  • 然后，创建了一个名为 increment 的局部函数，它能增加 counter 变量值。如果你从未接触过将函数作为数据来处理的函数式编程，这也许对你非常陌生。然而，这是非常常见的，而且只需要一些练习就能适应这一概念。

你应该注意到这一点，createCounter() 的实现与我们原先的计数器实现几乎一致。唯一不同的是它被包装或封装在一个函数体内。因此，这些构造器都被称为闭包。

现在是棘手的部分：

    • 在 createCounter() 的最后一步返回了局部函数 increment。请注意，这并不是返回调用函数的运行结果，而是函数本身。

这就意味着，当我们在这个代码段下面创建新的计数器时，实际上是生成新函数。

 
 
 
 
JavaScript
 
1
2
3
4
// fancyNewCounter is a function in this scope
// fancyNewCounter 是当前作用域的一个函数
 
varfancyNewCounter=createCounter();

这就是闭包生命周期的力量所在。每个生成的函数，都会保持在 createCounter() 所创建的 counter 变量的引用。在某种意义上，被返回的函数记住了它所被创建时的环境。

在这里需要提醒大家注意的是，内部变量 counter 都是独立存在于每个作用域！例如，如果我们创建两个计数器，那么它们都会在闭包体内会分配一个新的 counter 变量。我们观察以下代码：

每个计数器都会从 1 算起：

 
 
 
 
JavaScript
 
1
2
3
4
5
6
varcounter1=createCounter();
counter1();// Number of events: 1
counter1();// Number of events: 2
 
varcounter2=createCounter();
counter2();// Number of events: 1

第二个计数器并不会干扰第一个计数器的值：

 
 
 
 
JavaScript
 
1
counter1();// Number of events: 3

 

为我们的计数器命名

信息“Number of events: x” 是没问题的，但如果能描述每个计数事件的类型，那么这将会更好。如以下例子，我们为计数器添加名字：

 
 
 
 
JavaScript
 
1
2
3
4
5
6
varcatCounter=createCounter("cats");
vardogCounter=createCounter("dogs");
 
catCounter();// Number of cats: 1
catCounter();// Number of cats: 2
dogCounter();// Number of dogs: 1

我们仅需通过为闭包传递参数就能达到这种目的。

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
10
11
functioncreateCounter(counterName){
  varcounter=0;
 
  functionincrement(){
    counter=counter+1;
 
    console.log("Number of "+counterName+": "+counter);
  }
 
  returnincrement;
}

非常棒！请注意上述 createCounter() 函数的一个有趣行为。返回函数不仅记住了局部变量 counter，而且记住了传递进来的参数。

改善公用接口

我所说的公用接口是指，我们如何使用计数器。这并不单纯指，当被创建的计数器被调用时会增加值。

 
 
 
 
JavaScript
 
1
2
3
vardogCounter=createCounter("dogs");
 
dogCounter.increment();// Number of dogs: 1

让我们创建这样的一个实现：

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
10
11
functioncreateCounter(counterName){
  varcounter=0;
 
  functionincrement(){
    counter=counter+1;
 
    console.log("Number of "+counterName+": "+counter);
  };
 
  return{increment:increment};
}

在上述代码段，我们简单地返回一个对象，该对象包含了该闭包的所有功能。在某种意义下，我们能定义闭包能返回的一系列信息。

增加一个减量

现在，我们能非常简单地为我们的计数器引入减量（decrement）。

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
functioncreateCounter(counterName){
  varcounter=0;
 
  functionincrement(){
    counter=counter+1;
 
    console.log("Number of "+counterName+": "+counter);
  };
 
  functiondecrement(){
    counter=counter-1;
 
    console.log("Number of "+counterName+": "+counter);
  };
 
  return{
    increment:increment,
    decrement:decrement
  };
}
 
vardogsCounter=createCounter("dogs");
 
dogsCounter.increment();// Number of dogs: 1
dogsCounter.increment();// Number of dogs: 2
dogsCounter.decrement();// Number of dogs: 1

 

隐藏计数器行为

上述代码有两处冗余的代码行。没错，就是 console.log。如果能创建一个专门用于显示计数器值的函数将会更好。让我们调用 display 函数。

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
functioncreateCounter(counterName){
  varcounter=0;
 
  functiondisplay(){
    console.log("Number of "+counterName+": "+counter);
  }
 
  functionincrement(){
    counter=counter+1;
 
    display();
  };
 
  functiondecrement(){
    counter=counter-1;
 
    display();
  };
 
  return{
    increment:increment,
    decrement:decrement
  };
}
 
vardogsCounter=createCounter("dogs");
 
dogsCounter.increment();// Number of dogs: 1
dogsCounter.increment();// Number of dogs: 2
dogsCounter.decrement();// Number of dogs: 1

increment() 和 decrement() 函数看起来非常相似，然而这是大相径庭的。我们没有在结果对象返回计数值！这意味着以下代码将会调用失败：

 
 
 
 
JavaScript
 
1
2
3
vardogsCounter=createCounter("dogs");
 
dogsCounter.display();// ERROR !!!

我们让 display() 函数对外部来说是不可见的。它仅在 createCounter() 内可用。

抽象数据类型

正如你所见，我们通过闭包能非常简单地引入抽象数据类型。例如，让我们通过闭包实现一个 堆栈。

 
 
 
 
JavaScript
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
functioncreateStack(){
  varelements=[];
 
  return{
    push:function(el){elements.unshift(el);},
    pop:function(){returnelements.shift();}
  };
}
 
varstack=createStack();
 
stack.push(3);
stack.push(4);
stack.pop();// 4

注意：在 JavaScript 中，闭包并不是堆栈数据类型的最佳实现方式。用 Prototype 实现会对内存更友好（译者注：在当前对象实例找不会相应属性或方法时，会到相应实例共同引用的 Prototype 属性寻找相应属性或方法（如果在当前Prototype属性找不到时，会沿着当前原型链向上查找），而Prototype 上的属性或方法是公用的，而不像实例的属性或方法那样，各自单独创建属性或方法，从而节省更多的内存）。

闭包与面向对象编程

如果你具有 面向对象编程 的经历，那么你应该会注意到上述构造器看来非常像类、对象、实例值和私有/公有方法。

闭包与类相似，都会将一些能操作内部数据的函数联系在一起。因此，你能在任何地方像使用对象一样使用闭包。

结语

闭包是编程语言一个很棒的属性。当我们想在 JavaScript 创建“真正的”隐藏域，或者需要创建简单的构造器时，闭包这个属性是非常好用的。不过对于一般的类来说，闭包可能还是有点太重了。

分享到：
MYSQL遗忘密码解决方案备忘
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java闭包 Java闭包

    在2013年发布的 JavaSE8 中包含一个叫做 ...闭包允许我 们创建函数指针，并把它们作为参数传递。在这篇文章中，将粗略的看一遍Java8的特性，并介绍 Lambda表达式。而且将试着放一些样例程序来解释一些概念和语法。

    C语言实现三种闭包算法（传递，自反，对称闭包）

    在C语言中实现这些闭包通常涉及到数组或链表等数据结构，用于存储关系，并使用迭代或递归方法来构建闭包。以下是可能的实现策略： 1. **传递闭包**：可以使用二维数组表示关系，然后遍历数组的每一行和每一列，每次...

    关系闭包的计算

    本实验旨在通过编程实践的方式帮助学习者深入理解关系闭包的概念，并熟练掌握Warshall算法用于计算关系的自反闭包、对称闭包以及传递闭包。 #### 关键概念解释 1. **自反闭包**：给定集合A上的关系R，如果对于集合...

    计算NFA中ε闭包

    3. **ε闭包计算**：`E_closure`函数采用递归方式实现，对于每个状态，它会输出该状态的所有ε闭包状态，并递归地计算这些状态的ε闭包。 4. **主函数**：`main()`函数中调用了`input()`函数读取NFA描述信息，并...

    离散数学-关系，集合，求自反闭包，对称闭包，传递闭包

    离散数学-关系，集合，求自反闭包，对称闭包，传递闭包 离散数学-关系，集合，求自反闭包，对称闭包，传递闭包 离散数学-关系，集合，求自反闭包，对称闭包，传递闭包 离散数学-关系，集合，求自反闭包，对称闭包...

    求闭包 属性集闭包 函数依赖的闭包

    (即函数依赖是由用户自己定的，程序中不能假定某个具体的依赖)。 2. 函数依赖的形式是ABC, ABE这样的形式，为了简单起见，我们假定所有的属性都是用英文的大写字母表示，由A到Z。（提示，你可以让用户先输入依赖...

    Swift之闭包ClosureDemo

    闭包可以捕获并存储其所在上下文中的常量和变量，这称为“闭包捕获”。它可以是弱引用或无主引用，以防止循环引用导致内存泄漏。 Swift的闭包有两大特性：自动闭包和匿名函数。自动闭包是指当函数期望一个函数类型...

    数据库求属性集闭包&函数依赖闭包

    3） 计算属性集闭包的算法，在课件里有详细说明。方法很简单，但用文字描述很抽象。。。。不解释。。。 4） 计算函数依赖的闭包。此步骤不作要求，但要会方法。个人总结：将所有属性元素组成一个集合（域）记为R；...

    最符合菜鸟的闭包

    闭包是一种特殊的作用域，它允许函数访问并操作其外部作用域的变量，即使在外部函数执行完毕后仍然可以访问这些变量。 闭包的核心在于它可以记住外部函数（或称为词法环境）的状态，即使这个外部函数已经完成执行。...

    原子闭包系统, 原子闭包算子和原子全蕴含系统

    在预备知识中，文章对格论的基本概念进行了回顾，包括偏序集、格的覆盖关系、并不可约元、原子、余原子以及原子格等概念的定义。文章指出，格是具有最小元和最大元的偏序集，可以定义最小上界和最大下界，并指出格中...

    内存泄露，闭包 内存泄露，闭包 内存泄露，闭包

    内存泄露和闭包是两个关键概念，它们紧密关联并可能对程序性能产生重大影响。 内存泄露是指程序在不再需要某些数据时，未能释放这些数据所占用的内存。在JavaScript中，由于其自动垃圾回收（Garbage Collection, GC...

    Javascript 闭包完整解释

    **闭包**是一个非常重要的JavaScript概念，它指的是一个函数能够记住并访问其外部作用域中的变量的能力，即使该函数在其外部作用域之外被调用也是如此。具体来说，闭包是由函数及与其相关的引用环境组合而成的一个...

    ios-闭包传值.zip

    在iOS开发中，闭包（Closure）是一种强大的编程工具，它允许我们定义代码块并可以在程序的不同地方作为值传递。闭包可以捕获和存储它所在上下文中的常量和变量，这使得它们非常适合用于异步操作、回调函数或者封装一...

    js闭包个人理解

    当一个函数返回后，通常它的局部变量会被销毁，但闭包却允许这些局部变量继续存在并被访问。 #### 示例分析 在提供的文件中，给出了一段示例代码： ```javascript function a() { var i = 0; function b() { ...

    js闭包详细讲解

    **闭包**是JavaScript语言的一个重要特性，它使得函数可以访问并操作其外部作用域内的变量，即使该函数在其外部作用域之外被调用。要理解闭包，首先需要了解JavaScript的作用域规则。 ##### 1.1 作用域 在...

    用矩阵求自反闭包自反闭包

    在计算机科学和图论中，自反闭包是与关系理论相关的概念，特别是在布尔代数和图的子结构分析中。自反闭包是指给定一个关系R，将其扩展为包含所有起点到自身的元素对，即对于每一个元素a，都有(a, a)属于自反闭包。这...

    JS闭包可被利用的常见场景

    在JavaScript中，闭包是指一个函数能够访问并操作其定义时的作用域内的变量，即使该函数在其外部作用域被调用。以下将详细介绍两个常见场景中闭包的应用。 场景一：采用函数引用方式的 `setTimeout` 调用 在Web...

    Swift 中的闭包和 Objective-C 中的Block

    例如，`map`函数接受一个闭包作为参数，对数组中的每个元素应用该闭包并返回新数组： ```swift let numbers = [1, 2, 3, 4] let squaredNumbers = numbers.map({ $0 * $0 }) ``` 接下来，我们转向Objective-C的...

    二元关系的闭包运算

    在离散数学中，二元关系是一个非常基础且重要的概念，它描述了集合中的元素对之间的相互作用。二元关系的闭包运算则是研究这些关系...无论是理论探索还是实际应用，这一主题都是离散数学和相关领域中不可或缺的一部分。

    闭包作用域

    1. **数据封装**：通过闭包可以创建私有的变量或方法，这些变量和方法不能从外部直接访问，从而实现了数据的封装。 2. **模块化编程**：闭包可以用来创建自包含的模块，这些模块具有自己的作用域，不会与其他代码...

Magicbox
Global site tag (gtag.js) - Google Analytics