在闭包内声明的类与没有闭包的标准类

Question

通常我使用基于原型的标准 OOP 方法，我的类看起来像这样

var std = function(){
   this.log = function(msg){ console.log("want to be private. " + msg) };
};

std.prototype = {
    logInfo: function(msg){
        this.log(msg);
    }
};

但在这种情况下，log 是公共方法，任何人都可以使用它。但我想将其设为私有，但仍可在原型中声明的方法中使用。为此，我们需要闭包。代码将更改为此

var closureStd = (function(){
var std = function(){};
var log = function(msg){ console.log("I'm really private, youhooo!" + msg) };

std.prototype = {
    logInfo: function(msg){
        log(msg);
    }
};

return std;
})();

所以我的问题是：std 和 closureStd 之间有什么区别？我需要付出什么代价才能从原型中调用私有方法？

Answer 1

std和closureStd有什么区别？

std 构造函数在每次调用时都会创建一个新方法，而 closureStd 不会。你应该成功了

function std(){}
std.prototype = {
    log: function(msg){ console.log("want to be private. " + msg) },
    logInfo: function(msg){ this.log(msg); }
};

当然（你已经知道）closureStd 中的log 函数存储在一个（私有）变量中，而在std 实例上，它可以从外部在每个实例（或在他们的原型上）。在闭包中，它是作用域链中的变量查找（可以假定为静态），而对于方法，它是对象（及其原型链）上的属性查找，它可能是动态的，但在现代引擎中同样优化。

从原型调用私有方法需要付出什么代价？

没有。模块模式常见且便宜，静态链中的变量查找非常快。我宁愿担心内存，因为您在构造函数方法中创建了如此多的方法实例。

Answer 2

我还制作了一些tests 来衡量性能（结果将在控制台中），我发现将类置于闭包中与将方法置于构造函数中相比表现出更好的性能。您还有继承选项。所以现在我没有看到缺点，当我需要私有方法时，我总是会在闭包中使用类。

Answer 3

请注意，link Bondye 提供的模块模式不包含私有 instance 属性。它适用于函数属性，因为函数不会因每个实例而改变，但对于值属性的工作有点不可预测，如下代码所示：

var module = (function () {
    // private variables and functions
    var foo = 'bar';
    // constructor
    var module = function (name) {
      // instance variables
      this.name=name;
    };
    // prototype
    module.prototype = {
        constructor: module,
        something: function () {
          // notice we're not using this.foo
          console.log("foo in "+this.name+" is:",foo);
          foo="new value";
        }
    };
    // return module
    return module;
})();

var m1 = new module("m1");
var m2 = new module("m2");
m1.something();// foo in m1 is: bar
m1.something();// foo in m1 is: new value
m2.something();// foo in m2 is: new value

正如您在最后一行代码中看到的那样，m1 和 m2 实例共享一个名为 foo 的私有变量（所有实例都将指向相同的值）。

我可以从 Bondye 发布的 other link 中看出，很难在 JavaScript 中模拟私有性，您可以考虑使用命名约定来指示属性是私有的。您可以使用 google 闭包编译器之类的东西并注释您的 JS 代码以指示私有；但是使用闭包编译器有它自己的缺点（除非与闭包编译器兼容并且代码必须采用某种格式才能在高级模式下编译，否则无法编译使用的库）。

另一种选择是完全抛弃原型（至少对于使用私有属性的所有内容）并将所有内容放在构造函数的主体中（或使用返回对象的函数）。

// function returning an object

function makeObj(name){
  // private vars:
  var foo =  "bar";
  return {
    name:name,
    something:function(){
      console.log("foo in "+this.name+" is:",foo);
      foo="new value";
    }
  }  
}
var m1=makeObj("m1");
var m2=makeObj("m2");
m1.something();// foo in m1 is: bar
m1.something();// foo in m1 is: new value
m2.something();// foo in m2 is: bar

// constructor with everything in the constructor's body:

function Obj(name){
  // private vars:
  var foo =  "bar";
  this.name=name;
  this.something=function(){
    console.log("foo in "+this.name+" is:",foo);
    foo="new value";
  }
}
Obj.prototype.someOtherFunction=function(){
  // anything here can't access the "private" variables
}
var m1=new Obj("m1");
var m2=new Obj("m2");
m1.something();// foo in m1 is: bar
m1.something();// foo in m1 is: new value
m2.something();// foo in m2 is: bar

使用私有实例值可能会遇到的另一个问题是它们只能在实例中访问。当你想克隆一个对象并在你的对象中定义一个克隆函数来创建一个新实例时，你必须编写公共访问器函数来设置私有值，因为你不能像Java private fields那样直接设置它们。

在此处使用构造函数的更多信息：Prototypical inheritance - writing up