有没有办法让“private”变量（在构造函数中定义）对使用原型定义的方法可用？
TestClass = function(){
var privateField = "hello";
this.nonProtoHello = function(){alert(privateField)};
};
TestClass.prototype.prototypeHello = function(){alert(privateField)};
这个有效：
t.nonProtoHello()
但这个不行：
t.prototypeHello()
我习惯在构造函数中定义我的方法，但出于几个原因而放弃了这种做法。
不行，无法做到这一点。这本质上就是反向作用域。
在构造函数内定义的方法可以访问私有变量，因为所有函数都可以访问它们所定义的作用域。
在原型上定义的方法并不在构造函数作用域内定义，因此不能访问构造函数的局部变量。
您仍然可以拥有私有变量，但如果您希望在原型上定义的方法能够访问它们，那么应该在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()); };
secret 作为 this 的属性。JavaScript 并不支持原型私有变量，因为原型与调用位置上下文绑定，而不是“创建位置”上下文。 - nicodemus13person.getSecret() 呢？ - Fahmi简而言之，您可以使用新的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;
}());
构建对象的最简单方法是完全避免原型继承。只需在闭包中定义私有变量和公共函数，所有公共方法将具有对变量的私有访问。
在JavaScript中，原型继承主要是一种优化。它允许多个实例共享原型方法，而不是每个实例都有自己的方法。
缺点是每次调用原型函数时，this 是唯一不同的。
因此，任何私有字段必须通过this访问，这意味着它们将是公共的。因此，我们只需为_private字段使用命名约定。
我认为你不应该将闭包变量与原型方法混合使用。你应该使用其中之一。
当你使用闭包访问私有变量时，原型方法无法访问该变量。因此，你必须将闭包暴露到this上，这意味着你以某种方式公开了它。这种方法几乎没有什么可获得的好处。
对于非常简单的对象，只需使用带有闭包的普通对象。
如果你需要原型继承--用于继承、性能等，请坚持使用“_private”命名约定，不要费心使用闭包。
我不明白为什么JS开发人员这么努力地使字段真正私有。
_private 命名约定仍然是最好的解决方案。 - crushSymbol保存在一个包含整个类的闭包中。这样，所有原型方法都可以使用该符号，但它永远不会暴露在类外部。 - Scott RippeyObject.getOwnPropertySymbols获取其符号。因此，这只是一种通过模糊化来实现的隐私保护。 - OrioltoString 推断符号的用途。这与 Java 或 C# 没有区别... 私有成员仍然可以通过反射访问，但通常会被强烈模糊化。这一切都加强了我的最终观点，“我不明白为什么 JS 开发人员要如此努力地使字段真正私有化。” - Scott Rippey阅读此文时，我觉得这听起来是一个艰巨的挑战，所以我决定想出一种方法。我想出了一种疯狂的方法，但它完全有效。
首先，我尝试在立即函数中定义类，这样你就可以访问该函数的一些私有属性。这个方法可以使您获取一些私有数据，但是，如果您尝试设置私有数据，您很快就会发现所有对象都将共享相同的值。
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);在很多情况下，这种方式是足够的，例如当你想要拥有像事件名称这样的常量值并在实例之间共享时。但本质上它们就像私有的静态变量。
如果你绝对需要从原型中定义的方法中访问私有命名空间中的变量，可以尝试使用这种模式。
var PrivateNamespaceClass = (function() { // immediate function
var instance = 0, // counts the number of instances
defaultName = "Default Name",
p = []; // an array of private objects
// create the constructor
function PrivateNamespaceClass() {
// Increment the instance count and save it to the instance.
// This will become your key to your private space.
this.i = instance++;
// Create a new object in the private space.
p[this.i] = {};
// Define properties or methods in the private space.
p[this.i].name = defaultName;
console.log("New instance " + this.i);
}
PrivateNamespaceClass.prototype.getPrivateName = function() {
// It has access to the private space and it's children!
return p[this.i].name;
};
PrivateNamespaceClass.prototype.setPrivateName = function(value) {
// Because you use the instance number assigned to the object (this.i)
// as a key, the values set will not change in other instances.
p[this.i].name = value;
return "Set " + p[this.i].name;
};
return PrivateNamespaceClass;
})();
var a = new PrivateNamespaceClass();
console.log(a.getPrivateName()); // Default Name
var b = new PrivateNamespaceClass();
console.log(b.getPrivateName()); // Default Name
console.log(a.setPrivateName("A"));
console.log(b.setPrivateName("B"));
console.log(a.getPrivateName()); // A
console.log(b.getPrivateName()); // B
// private objects are not accessible outside the PrivateNamespaceClass function
console.log(a.p);
// the prototype functions are not re-created for each instance
// and instanceof still works
console.log(a.getPrivateName === b.getPrivateName);
console.log(a instanceof PrivateNamespaceClass);
console.log(b instanceof PrivateNamespaceClass);我希望任何看到这种方法有错误的人都能提供建议。
i。因此它不是完全“透明”的，i仍然可能会被篡改。 - Scott RippeyPrivateNamespaceClass的新实例上，您都会创建一个新的闭包实例，这将创建内部函数和原型的新实例。 - crush请参考Doug Crockford的页面。您需要通过能够访问私有变量作用域的方法来间接地实现它。
另一个例子：
Incrementer = function(init) {
var counter = init || 0; // "counter" is a private variable
this._increment = function() { return counter++; }
this._set = function(x) { counter = x; }
}
Incrementer.prototype.increment = function() { return this._increment(); }
Incrementer.prototype.set = function(x) { return this._set(x); }
使用案例：
js>i = new Incrementer(100);
[object Object]
js>i.increment()
100
js>i.increment()
101
js>i.increment()
102
js>i.increment()
103
js>i.set(-44)
js>i.increment()
-44
js>i.increment()
-43
js>i.increment()
-42
set 暴露 _set？ 为什么不一开始就将其命名为 set？ - Scott Rippey我建议将“在构造函数中拥有原型分配”的做法描述为JavaScript反模式可能是一个不错的主意。仔细想想，这太冒险了。
实际上，在创建第二个对象（即b）时，您正在重新定义使用该原型的所有对象的原型函数。这将有效地重置示例a的值。如果您想要共享变量并且恰好提前创建了所有对象实例，则这样做可以起作用，但这感觉太冒险。
最近，我在编写的一些JavaScript中发现了一个错误，它源于这种反模式。 它试图为正在创建的特定对象设置拖放处理程序，但却为所有实例执行了此操作。 不好。
Doug Crockford的解决方案是最好的。
@Kai
那样做是行不通的。如果你这样做，
var t2 = new TestClass();
那么t2.prototypeHello将访问t的私有部分。
@AnglesCrimes
示例代码可以正常工作，但实际上它创建了一个所有实例共享的“静态”私有成员。这可能不是morgancodes寻找的解决方案。
到目前为止，我还没有找到一种简单而干净的方法来做到这一点，而不需要引入一个私有哈希和额外的清理函数。可以在一定程度上模拟私有成员函数：
(function() {
function Foo() { ... }
Foo.prototype.bar = function() {
privateFoo.call(this, blah);
};
function privateFoo(blah) {
// scoped to the instance by passing this to call
}
window.Foo = Foo;
}());
privateFoo 是完全私有的，因此在获取 new Foo() 时是不可见的。这里只有 bar() 是公共方法，它可以访问 privateFoo。你可以使用相同的机制来处理简单变量和对象，但是你需要始终记住，这些“私有变量”实际上是静态的，并且将被所有创建的对象共享。 - Philzen// Helper class to store private data.
function Data() {};
// Object constructor
function Point(x, y)
{
// container for private vars: all private vars go here
// we want x, y be changeable via methods only
var data = new Data;
data.x = x;
data.y = y;
...
}
// Prototype functions now have access to private instance data
Point.prototype.getX = function(data)
{
return data.x;
}
Point.prototype.getY = function(data)
{
return data.y;
}
...
在此阅读完整故事：
(function(key, global) {
// Creates a private data accessor function.
function _(pData) {
return function(aKey) {
return aKey === key && pData;
};
}
// Private data accessor verifier. Verifies by making sure that the string
// version of the function looks normal and that the toString function hasn't
// been modified. NOTE: Verification can be duped if the rogue code replaces
// Function.prototype.toString before this closure executes.
function $(me) {
if(me._ + '' == _asString && me._.toString === _toString) {
return me._(key);
}
}
var _asString = _({}) + '', _toString = _.toString;
// Creates a Person class.
var PersonPrototype = (global.Person = function(firstName, lastName) {
this._ = _({
firstName : firstName,
lastName : lastName
});
}).prototype;
PersonPrototype.getName = function() {
var pData = $(this);
return pData.firstName + ' ' + pData.lastName;
};
PersonPrototype.setFirstName = function(firstName) {
var pData = $(this);
pData.firstName = firstName;
return this;
};
PersonPrototype.setLastName = function(lastName) {
var pData = $(this);
pData.lastName = lastName;
return this;
};
})({}, this);
var chris = new Person('Chris', 'West');
alert(chris.setFirstName('Christopher').setLastName('Webber').getName());
这个例子来自于我的文章“原型函数和私有数据”，并在那里有更详细的解释。
this添加任何公共内容。 答案是使用“弱映射”模式。Person类有一个单一的弱映射，其中键是Person的实例，值是用于私有存储的普通对象。var Person = (function() {
var _ = weakMap();
// Now, _(this) returns an object, used for private storage.
var Person = function(first, last) {
// Assign private storage:
_(this).firstName = first;
_(this).lastName = last;
}
Person.prototype = {
fullName: function() {
// Retrieve private storage:
return _(this).firstName + _(this).lastName;
},
firstName: function() {
return _(this).firstName;
},
destroy: function() {
// Free up the private storage:
_(this, true);
}
};
return Person;
})();
function weakMap() {
var instances=[], values=[];
return function(instance, destroy) {
var index = instances.indexOf(instance);
if (destroy) {
// Delete the private state:
instances.splice(index, 1);
return values.splice(index, 1)[0];
} else if (index === -1) {
// Create the private state:
instances.push(instance);
values.push({});
return values[values.length - 1];
} else {
// Return the private state:
return values[index];
}
};
}
就像我说的那样，这确实是实现所有三个部分的唯一方法。
然而，有两个注意点。首先，这会影响性能 - 每次访问私有数据都是一个 O(n) 操作，其中 n 是实例的数量。所以如果你有大量的实例，就不要这样做。
其次，在完成一个实例后，必须调用 destroy 方法；否则，实例和数据将无法进行垃圾回收，导致内存泄漏。
这也正是为什么我的原始回答是："你不应该这样做"。
试一下吧！
function Potatoe(size) {
var _image = new Image();
_image.src = 'potatoe_'+size+'.png';
function getImage() {
if (getImage.caller == null || getImage.caller.owner != Potatoe.prototype)
throw new Error('This is a private property.');
return _image;
}
Object.defineProperty(this,'image',{
configurable: false,
enumerable: false,
get : getImage
});
Object.defineProperty(this,'size',{
writable: false,
configurable: false,
enumerable: true,
value : size
});
}
Potatoe.prototype.draw = function(ctx,x,y) {
//ctx.drawImage(this.image,x,y);
console.log(this.image);
}
Potatoe.prototype.draw.owner = Potatoe.prototype;
var pot = new Potatoe(32);
console.log('Potatoe size: '+pot.size);
try {
console.log('Potatoe image: '+pot.image);
} catch(e) {
console.log('Oops: '+e);
}
pot.draw();
caller，它是一个在严格模式下不允许的实现相关扩展。 - Oriol