访问私人部件的变量，从原型的定义功能

Question

是否有任何方式使"私人"变量(这些定义在构造)，提供给原型的定义的方法？

TestClass = function(){
    var privateField = "hello";
    this.nonProtoHello = function(){alert(privateField)};
};
TestClass.prototype.prototypeHello = function(){alert(privateField)};

这个工作：

t.nonProtoHello()

但是，这并不:

t.prototypeHello()

我用来界定我的方法里面的构造，但我移动的距离，几个原因。

Answer 1

没有，有没有办法做到这一点。这将从根本上是相反的划定范围。

在构造函数中定义的方法可以访问私有变量，因为所有的功能可以访问它们被限定的范围。

在一个原型中定义的方法没有构造的范围内定义的，并且将不能访问到构造的局部变量。

您仍然可以有私有变量，但如果你想在原型定义的方法来访问它们，你应该定义this对象上的getter和setter，其原型方法（与其他内容一起）的将访问。例如：

function Person(name, secret) {
    // public
    this.name = name;

    // private
    var secret = secret;

    // public methods have access to private members
    this.setSecret = function(s) {
        secret = s;
    }

    this.getSecret = function() {
        return secret;
    }
}

// Must use getters/setters 
Person.prototype.spillSecret = function() { alert(this.getSecret()); };

Answer 2

更新：随着ES6，有一种更好的方法：

长话短说，你可以使用新的Symbol创建私有字段。点击 这里有一个很好的说明： https://curiosity-driven.org/private-properties-in-javascript

示例：

var Person = (function() {
    // Only Person can access nameSymbol
    var nameSymbol = Symbol('name');

    function Person(name) {
        this[nameSymbol] = name;
    }

    Person.prototype.getName = function() {
        return this[nameSymbol];
    };

    return Person;
}());

对于所有的现代浏览器与ES5：

您可以只使用瓶盖

构造对象最简单的方法是完全避免原型继承。 只要定义私有变量和公共职能的闭包内，并且所有的公共方法必须将私有变量的访问。

或者你可以只使用原型

在JavaScript中，原型继承是主要优化。它允许多个实例共享原型方法，而不是它自己的方法每个实例。结果 缺点是this是在仅的事情每一个原型函数被调用时间是不同的。结果 因此，任何私有字段必须通过this访问，这意味着他们将是公开的。所以，我们只是坚持命名约定_private领域。

不要打扰与原型混合瓶盖

我觉得你的不该与原型方法混合闭包变量。您应该使用一个或另一个。

当您使用的封闭件来访问专用变量，原型方法不能访问变量。所以，你必须关闭曝光在this，这意味着你公开暴露它这种或那种方式。有很少获得这种方法。

我该选择哪一个？

有关真正简单对象，只是使用带密封盖一个普通对象。

如果您需要原型继承 - 继承，性能等 - 然后用“_private”坚持命名约定，并且不与理会封

我不明白为什么JS开发商着急做出领域真正私有的。

Answer 3

当我读到这，这听起来像一个严峻的挑战，所以我决定想出一个办法。我想出了 CRAAAAZY ，但它完全有效。

首先，我试图立刻函数定义类，所以你可以访问一些功能的私有财产。这工作，并让你获得一些私人数据，但是，如果你尝试设置你很快就会发现，所有的对象都共享相同的值的私有数据。

var SharedPrivateClass = (function() { // use immediate function
    // our private data
    var private = "Default";

    // create the constructor
    function SharedPrivateClass() {}

    // add to the prototype
    SharedPrivateClass.prototype.getPrivate = function() {
        // It has access to private vars from the immediate function!
        return private;
    };

    SharedPrivateClass.prototype.setPrivate = function(value) {
        private = value;
    };

    return SharedPrivateClass;
})();

var a = new SharedPrivateClass();
console.log("a:", a.getPrivate()); // "a: Default"

var b = new SharedPrivateClass();
console.log("b:", b.getPrivate()); // "b: Default"

a.setPrivate("foo"); // a Sets private to "foo"
console.log("a:", a.getPrivate()); // "a: foo"
console.log("b:", b.getPrivate()); // oh no, b.getPrivate() is "foo"!

console.log(a.hasOwnProperty("getPrivate")); // false. belongs to the prototype
console.log(a.private); // undefined

// getPrivate() is only created once and instanceof still works
console.log(a.getPrivate === b.getPrivate);
console.log(a instanceof SharedPrivateClass);
console.log(b instanceof SharedPrivateClass);