深入JavaScript（3）闭包、所有函数的参数都是按值传递

LuyolG
133 阅读7分钟

1 闭包

MDN 对闭包的定义为：

闭包是指那些能够访问⾃由变量的函数。

那什么是⾃由变量呢？

⾃由变量是指在函数中使⽤的，但既不是函数参数也不是函数的局部变量的变量。

由此，我们可以看出闭包共有两部分组成

闭包 = 函数 + 函数能够访问的⾃由变量

var a = 1;

function foo() {
    console.log(a);
}

foo();

foo 函数可以访问变量 a，但是 a 既不是 foo 函数的局部变量，也不是 foo 函数的参数，所以 a 就是⾃由变量。

所以在《JavaScript权威指南》中就讲到：从技术的⻆度讲，所有的JavaScript函数都是闭包。

但是，这是理论上的闭包，其实还有⼀个实践⻆度上的闭包。

ECMAScript中，闭包指的是：

  1. 从理论⻆度：所有的函数。因为它们都在创建的时候就将上层上下⽂的数据保存起来了。哪怕是简

单的全局变量也是如此，因为函数中访问全局变量就相当于是在访问⾃由变量，这个时候使⽤最外

层的作⽤域；

  1. 从实践⻆度：以下函数才算是闭包：

    a. 即使创建它的上下⽂已经销毁，它仍然存在（⽐如，内部函数从⽗函数中返回）；

    b. 在代码中引⽤了⾃由变量；

接下来就来讲讲实践上的闭包。

1.1 分析

var scope = "global scope";
function checkscope() {
  var scope = "local scope";
  function f() {
    return scope;
  }
  return f;
}
var foo = checkscope();
foo();

先我们要分析⼀下这段代码中执⾏上下⽂栈和执⾏上下⽂的变化情况。

这⾥直接给出简要的执⾏过程：

  1. 进⼊全局代码，创建全局执⾏上下⽂，全局执⾏上下⽂压⼊执⾏上下⽂栈；

  2. 全局执⾏上下⽂初始化；

  3. 执⾏ checkscope 函数，创建 checkscope 函数执⾏上下⽂， checkscope 执⾏上下⽂

被压⼊执⾏上下⽂栈；

  1. checkscope 执⾏上下⽂初始化，创建变量对象、作⽤域链、this等；

  2. checkscope 函数执⾏完毕， checkscope 执⾏上下⽂从执⾏上下⽂栈中弹出；

  3. 执⾏ f 函数，创建 f 函数执⾏上下⽂，f 执⾏上下⽂被压⼊执⾏上下⽂栈；

  4. f 执⾏上下⽂初始化，创建变量对象、作⽤域链、this等；

  5. f 函数执⾏完毕，f 函数上下⽂从执⾏上下⽂栈中弹出；

了解到这个过程，我们应该思考⼀个问题：

  1. 当 f 函数执⾏的时候，checkscope 函数上下⽂已经被销毁了啊(即从执⾏上下⽂栈中被弹出)，怎么还会读取到 checkscope 作⽤域下的 scope 值呢？

当我们了解了具体的执⾏过程后，我们知道 f 执⾏上下⽂维护了⼀个作⽤域链：

fContext = {

Scope: [AO, checkscopeContext.AO, globalContext.VO],

}

因为这个作⽤域链，f 函数依然可以读取到 checkscopeContext.AO 的值，说明当 f 函数引⽤了checkscopeContext.AO 中的值的时候，即使 checkscopeContext 被销毁了，但是JavaScript 依然会让 checkscopeContext.AO 活在内存中，f 函数依然可以通过 f 函数的作⽤域链找到它，正是因为 JavaScript 做到了这⼀点，从⽽实现了闭包这个概念。

所以，让我们再看⼀遍实践⻆度上闭包的定义：

  1. 即使创建它的上下⽂已经销毁，它仍然存在（⽐如，内部函数从⽗函数中返回）；

  2. 在代码中引⽤了⾃由变量；

1.2 思考题

var data = [];
for (var i = 0; i < 3; i++) {
  data[i] = function () {
    console.log(i);
  };
}
data[0]();
data[1]();
data[2]();

答案是都是 3，让我们分析⼀下原因：

当执⾏到 data[0] 函数之前，此时全局上下⽂的 VO 为：

globalContext = {

    VO: {

        data: [...],

        i: 3

    }

}

当执⾏ data[0] 函数的时候，data[0] 函数的作⽤域链为：

data[0]Context = {

    Scope: [AO, globalContext.VO]

}

data[0]Context 的 AO 并没有 i 值，所以会从 globalContext.VO 中查找，i 为 3，所以打印的结果就

是 3。

data[1] 和 data[2] 是⼀样的道理。

所以改成闭包：

var data = [];
for (var i = 0; i < 3; i++) {
  data[i] = (function (i) {
    return function () {
      console.log(i);
    };
  })(i);
}
data[0]();
data[1]();
data[2]();

当执⾏到 data[0] 函数之前，此时全局上下⽂的 VO 为：

globalContext = {
    VO: {
        data: [...],
        i: 3
    }
}

跟没改之前⼀模⼀样。

当执⾏ data[0] 函数的时候，data[0] 函数的作⽤域链发⽣了改变：

data[0]Context = {
    Scope: [AO, 匿名函数Context.AO globalContext.VO]
}

匿名函数执⾏上下⽂的AO为：

匿名函数Context = {
    AO: {
        arguments: {
            0: 0,
            length: 1
        },
        i: 0
    }
}

data[0]Context 的 AO 并没有 i 值，所以会沿着作⽤域链从匿名函数 Context.AO 中查找，这时候就会找 i 为 0，找到了就不会往 globalContext.VO 中查找了，即使 globalContext.VO 也有 i 的值(值为3)，

所以打印的结果就是0。

data[1] 和 data[2] 是⼀样的道理。

2.参数按值传递

在《JavaScript高级程序设计》中提到传递参数：

ECMAScript中所有函数的参数都是按值传递的。

什么是按值传递呢？

把函数外部的值复制给函数内部的参数，就和把值从一个变量复制到另一个变量一样。

2.1.按值传递

var value = 1;
function foo(v) {
    v = 2;
    console.log(v); //2
}
foo(value);
console.log(value) // 1

很好理解，当传递 value 到函数 foo 中，相当于拷贝了一份 value，假设拷贝的这份叫 _value，函数中修改的都是 _value 的值，而不会影响原来的 value 值。

2.2.共享传递

拷贝虽然很好理解，但是当值是一个复杂的数据结构的时候，拷贝会产生性能上的问题。

这里提及一种：按引用传递。

所谓按引用传递，就是传递对象的引用，函数内部对参数的任何改变都会影响该对象的值，因为两者引用的是同一个对象。这里我简单理解为，传递的是：栈指向堆中对象的地址（指针）

var obj = {
    value: 1
};
function foo(o) {
    o.value = 2;
    console.log(o.value); //2
}
foo(obj);
console.log(obj.value) // 2

为什么《JavaScript高级程序设计》都说了 ECMAScript 中所有函数的参数都是按值传递的，那为什么能按"引用传递"成功呢？

var obj = {
    value: 1
};
function foo(o) {
    o = 2;
    console.log(o); //2
}
foo(obj);
console.log(obj.value) // 1

如果 JavaScript 采用的是引用传递，外层的值也会被修改，那这里如何解释？

这就要讲到第二种传递方式，叫按共享传递。

而共享传递是指，在传递对象的时候，传递的是地址索引。

所以修改 o.value，可以通过引用找到原值，但是直接修改 o，并不会修改原值。所以第二个和第三个例子其实都是按共享传递。

最后，你可以这样理解：

参数如果是基本类型是按值传递，如果是引用类型按共享传递。

但是因为拷贝副本也是一种值的拷贝，所以在JavaScript中也直接认为是按值传递了。

换句话说，函数传递参数 ，传递的是参数的拷贝：

  1. 指针拷贝，拷贝的是地址索引；
  2. 常规类型拷贝，拷贝的是值 ；

所以，一共是两种传递方式，按值传递和按共享传递。

2.3.总结

javascript中数据类型分为基本类型与引用类型：

  1. 基本类型值存储于栈内存中，传递的就是当前值，修改不会影响原有变量的值；
  2. 引用类型值其实也存于栈内存中，只是它的值是指向堆内存当中实际值的一个地址；索引引用传递传的值是栈内存当中的引用地址，当改变时，改变了堆内存当中的实际值；

所以针对上述的内容：

var value = 1;
function foo(v) {
    v = 2;
    console.log(v); //2
}
foo(value);
console.log(value) // 1

内存分布：

改变前：

栈内存堆内存
value1-
v1-

改变后：

栈内存堆内存
value1-
v2-
var obj = {
value: 1
};
function foo(o) {
    o.value = 2;
    console.log(o.value); //2
}
foo(obj);
console.log(obj.value) // 2

改变前：

栈内存堆内存
obj指针地址{value: 1}
o指针地址{value: 1}

改变后：

栈内存堆内存
obj指针地址{value: 2}
o指针地址{value: 2}
var obj = {
value: 1
};
function foo(o) {
    o = 2;
    console.log(o); //2
}
foo(obj);
console.log(obj.value) // 1

改变前：

栈内存堆内存
obj指针地址{value: 1}
o指针地址{value: 1}

改变后：

栈内存堆内存
obj指针地址{value: 2}
o2
avatar
文章
阅读
粉丝