javascript无法访问私有(private)属性

Question

我有以下代码，并且我不明白为什么在我重新声明get方法时无法访问私有(private)属性。

(function(w,d,a,undefined){
    var cfg = {
        currency: 'GBP',
        exponent: 2
    };
    var get = function () {
        return cfg;
    };
    a.init = function (settings) {
        for (var k in settings) {
            cfg[k] = settings[k];
        }
    };
    a.set = function (args) {
        get = args.get || get;
        //eval(args) //works but why??
    };
    a.get = function () {
        return get();
    };
})(window,document,window.fxc = {});

fxc.init({currency: 'EUR'});

// prints, Object { currency="EUR", exponent=2}
console.log(fxc.get());

fxc.set({get: function(msg){
    // cannot access private properties
    return cfg;
}});

// prints, undefined
console.log(fxc.get());

一段时间以来，我一直在尝试找到正确的方法来执行此操作，但是我似乎找不到正确的组合。我确实有 eval()，但是肯定不是正确的方法吗？希望有帮助。

Answer 1

没错部分原因是javascript没有私有(private)属性。您正在执行的操作不是声明私有(private)属性(property)。您正在使用一种设计模式，该模式使用闭包来模拟私有(private)属性。

封闭超出了范围。范围是指变量的生命周期，而对象属性是指变量的绑定(bind)。

因此，在讨论闭包之前，让我们简短讨论一下范围。

堆栈:

范围与堆栈框架有关(在计算机科学中，它称为“激活记录”，但大多数熟悉C或汇编语言的开发人员都将其更好地理解为堆栈框架)。范围是堆栈框架，类是对象。我的意思是，如果对象是类的实例，则堆栈框架是作用域的实例。

让我们以编排语言为例。在这种语言中，就像在javascript中一样，函数定义范围。让我们看一个示例代码:

var global_var

function b {
    var bb
}

function a {
    var aa
    b();
}

当我们阅读上面的代码时，我们说变量 aa在 a函数的作用域内，而变量 bb在 b函数的作用域内。请注意，我们不将其称为私有(private)变量。因为私有(private)变量的对立面是公共(public)变量，并且两者都引用绑定(bind)到对象的属性。相反，我们将 aa和 bb称为 local variables。局部变量的对立面是全局变量(不是公共(public)变量)。

现在，让我们看看调用 a会发生什么:
a()被调用，创建一个新的堆栈框架。在堆栈上为局部变量分配空间:

The stack:
 ┌────────┐
 │ var aa │ <── a's stack frame
 ╞════════╡
 ┆        ┆ <── caller's stack frame

a()调用 b()，创建一个新的堆栈框架。在堆栈上为局部变量分配空间:

The stack:
 ┌────────┐
 │ var bb │ <── b's stack frame
 ╞════════╡
 │ var aa │
 ╞════════╡
 ┆        ┆

在大多数编程语言中(包括javascript)，一个函数只能访问其自己的堆栈框架。因此， a()无法访问 b()中的局部变量，全局范围内的任何其他函数或代码也都无法访问 a()中的变量。唯一的异常(exception)是全局范围内的变量。从实现的 Angular 来看，这是通过在不属于堆栈的内存区域中分配全局变量来实现的。这通常称为堆。因此，为了完成图片，此时的内存如下所示:

The stack:     The heap:
 ┌────────┐   ┌────────────┐
 │ var bb │   │ global_var │
 ╞════════╡   │            │
 │ var aa │   └────────────┘
 ╞════════╡
 ┆        ┆

(作为附带说明，您还可以使用malloc()或new在函数内部的堆上分配变量)

现在 b()完成并返回，它的堆栈框架已从堆栈中删除:

The stack:     The heap:
 ┌────────┐   ┌────────────┐
 │ var aa │   │ global_var │
 ╞════════╡   │            │
 ┆        ┆   └────────────┘

当 a()完成时，其堆栈框架也会发生同样的情况。这就是如何通过将对象压入和弹出堆栈来自动分配和释放局部变量的方式。

关闭时间:

闭包是更高级的堆栈框架。但是，尽管正常的堆栈框架会在函数返回后被删除，但是带有闭包的语言只会从堆栈中取消链接堆栈框架(或只是其中包含的对象)，同时只要有需要，便会一直引用堆栈框架。

现在，让我们看一下带有闭包的语言的示例代码:

function b {
    var bb
    return function {
        var cc
    }
}

function a {
    var aa
    return b()
}

现在让我们看看如果执行此操作会发生什么:

var c = a()

调用第一个函数 a()，依次调用 b()。创建堆栈框架并将其插入堆栈:

The stack:
 ┌────────┐
 │ var bb │
 ╞════════╡
 │ var aa │
 ╞════════╡
 │ var c  │
 ┆        ┆

函数 b()返回，因此它的堆栈框架从堆栈中弹出。但是，函数 b()返回一个匿名函数，该函数捕获闭包中的 bb。因此，我们弹出堆栈框架，但不要将其从内存中删除(直到对它的所有引用都已被完全垃圾回收):

The stack:             somewhere in RAM:
 ┌────────┐           ┌╶╶╶╶╶╶╶╶╶┐
 │ var aa │           ┆ var bb  ┆
 ╞════════╡           └╶╶╶╶╶╶╶╶╶┘
 │ var c  │
 ┆        ┆

现在， a()将函数返回到 c。因此，对 b()的调用的堆栈框架链接到变量 c。请注意，链接的是堆栈框架，而不是范围。这就像从类创建对象一样，是将对象分配给变量，而不是类:

The stack:             somewhere in RAM:
 ┌────────┐           ┌╶╶╶╶╶╶╶╶╶┐
 │ var c╶╶├╶╶╶╶╶╶╶╶╶╶╶┆ var bb  ┆
 ╞════════╡           └╶╶╶╶╶╶╶╶╶┘
 ┆        ┆

还要注意，由于我们实际上尚未调用函数 c()，因此变量 cc尚未分配到内存中的任何位置。在我们调用 c()之前，它目前只是一个作用域，还不是一个堆栈框架。

现在，当我们调用 c()时会发生什么？通常，将创建 c()的堆栈框架。但这一次有所不同:

The stack:
 ┌────────┬──────────┐
 │ var cc    var bb  │  <──── attached closure
 ╞════════╤──────────┘
 │ var c  │
 ┆        ┆

b()的堆栈框架附加到 c()的堆栈框架。因此，从函数 c()的 Angular 来看，它的堆栈还包含调用 b()函数时创建的所有变量(再次注意，不是函数b()中的变量而是调用函数b()时创建的变量-在其他情况下换句话说，不是b()的范围，而是调用b()时创建的堆栈框架。这意味着只有一个可能的函数b()，但是对b()的许多调用会创建许多堆栈框架)。

但是局部和全局变量的规则仍然适用。 b()中的所有变量都成为 c()的局部变量，而没有其他任何变量。名为 c()的函数无法访问它们。

这意味着当您在调用方的作用域中重新定义 c时，如下所示:

var c = function {/* new function */}

有时候是这样的:

                     somewhere in RAM:
                           ┌╶╶╶╶╶╶╶╶╶┐
                           ┆ var bb  ┆
                           └╶╶╶╶╶╶╶╶╶┘
The stack:
 ┌────────┐           ┌╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶┐
 │ var c╶╶├╶╶╶╶╶╶╶╶╶╶╶┆ /* new function */ ┆
 ╞════════╡           └╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶╶┘
 ┆        ┆

如您所见，由于对 b()所属的作用域无权访问，因此无法从对 c的调用中重新获得对堆栈框架的访问权限。

解决方法:

由于这是一个绑定(bind)(javascript称为上下文)问题，而不是范围问题，因此，解决方法是使用对象绑定(bind)存储 cfg对象。

不幸的是javascript没有私有(private)变量。因此，只能将其绑定(bind)为公共(public)变量。解决此问题的方法是使用Perl约定告诉其他程序员，除非他们自己修改实现本身，否则不要触摸该对象。该约定是用下划线开头的变量名称:

// WARNING: Private!
a._cfg = {
    currency: 'GBP',
    exponent: 2
};