要使用公共方法创建JavaScript类，我会执行以下操作：
function Restaurant() {}
Restaurant.prototype.buy_food = function(){
// something here
}
Restaurant.prototype.use_restroom = function(){
// something here
}
这样我班级的用户可以：
var restaurant = new Restaurant();
restaurant.buy_food();
restaurant.use_restroom();
如何创建可由buy_food和use_restroom方法调用的私有方法，但不能由类用户在外部创建？
换句话说，我希望我的方法实现能够：
Restaurant.prototype.use_restroom = function() {
this.private_stuff();
}
但这不应该奏效：
var r = new Restaurant();
r.private_stuff();
如何将private_stuff定义为私有方法，以便这两者都成立？
我已经阅读了Doug Crockford's writeup几次但看起来似乎不能通过公共方法调用“私有”方法，并且可以在外部调用“特权”方法。
答案 0 :(得分：362)
你可以做到，但缺点是它不能成为原型的一部分：
function Restaurant() {
var myPrivateVar;
var private_stuff = function() { // Only visible inside Restaurant()
myPrivateVar = "I can set this here!";
}
this.use_restroom = function() { // use_restroom is visible to all
private_stuff();
}
this.buy_food = function() { // buy_food is visible to all
private_stuff();
}
}
答案 1 :(得分：159)
您可以模拟这样的私有方法：
function Restaurant() {
}
Restaurant.prototype = (function() {
var private_stuff = function() {
// Private code here
};
return {
constructor:Restaurant,
use_restroom:function() {
private_stuff();
}
};
})();
var r = new Restaurant();
// This will work:
r.use_restroom();
// This will cause an error:
r.private_stuff();
此处有关此技术的更多信息：http://webreflection.blogspot.com/2008/04/natural-javascript-private-methods.html
答案 2 :(得分：147)
JavaScript使用prototypes并且没有像面向对象语言那样的类（或方法）。 JavaScript开发人员需要用JavaScript思考。
维基百科报价：
与许多面向对象的语言不同，它们之间没有区别 函数定义和方法定义。相反，区别 在函数调用期间发生;当函数被调用为方法时 对象，函数的本地关键字绑定到该关键字 该调用的对象。
使用self invoking function和call function调用私有＆＃34;方法的解决方案＆＃34; ：
var MyObject = (function () {
// Constructor
function MyObject (foo) {
this._foo = foo;
}
function privateFun (prefix) {
return prefix + this._foo;
}
MyObject.prototype.publicFun = function () {
return privateFun.call(this, '>>');
}
return MyObject;
})();
var myObject = new MyObject('bar');
myObject.publicFun(); // Returns '>>bar'
myObject.privateFun('>>'); // ReferenceError: private is not defined
call function允许我们使用适当的上下文（this）调用私有函数。
如果您使用node.js，则不需要IIFE，因为您可以利用module loading system：
function MyObject (foo) {
this._foo = foo;
}
function privateFun (prefix) {
return prefix + this._foo;
}
MyObject.prototype.publicFun = function () {
return privateFun.call(this, '>>');
}
exports.MyObject = MyObject;
加载文件：
var MyObject = require('./MyObject').MyObject;
var myObject = new MyObject('bar');
myObject.publicFun(); // Returns '>>bar'
myObject.privateFun('>>'); // ReferenceError: private is not defined
绑定运算符::是ECMAScript proposal，并且是implemented in Babel（stage 0）。
export default class MyObject {
constructor (foo) {
this._foo = foo;
}
publicFun () {
return this::privateFun('>>');
}
}
function privateFun (prefix) {
return prefix + this._foo;
}
加载文件：
import MyObject from './MyObject';
let myObject = new MyObject('bar');
myObject.publicFun(); // Returns '>>bar'
myObject.privateFun('>>'); // TypeError: myObject.privateFun is not a function
答案 3 :(得分：35)
在这些情况下，如果你有一个公共API，并且你想要私有和公共方法/属性，我总是使用模块模式。这个模式在YUI库中很流行，详情可以在这里找到：
http://yuiblog.com/blog/2007/06/12/module-pattern/
这非常简单，其他开发人员也很容易理解。举个简单的例子：
var MYLIB = function() {
var aPrivateProperty = true;
var aPrivateMethod = function() {
// some code here...
};
return {
aPublicMethod : function() {
aPrivateMethod(); // okay
// some code here...
},
aPublicProperty : true
};
}();
MYLIB.aPrivateMethod() // not okay
MYLIB.aPublicMethod() // okay
答案 4 :(得分：20)
以下是我为了解道格拉斯·克罗克福德在其网站上提出的建议而创建的课程Private Members in JavaScript
function Employee(id, name) { //Constructor
//Public member variables
this.id = id;
this.name = name;
//Private member variables
var fName;
var lName;
var that = this;
//By convention, we create a private variable 'that'. This is used to
//make the object available to the private methods.
//Private function
function setFName(pfname) {
fName = pfname;
alert('setFName called');
}
//Privileged function
this.setLName = function (plName, pfname) {
lName = plName; //Has access to private variables
setFName(pfname); //Has access to private function
alert('setLName called ' + this.id); //Has access to member variables
}
//Another privileged member has access to both member variables and private variables
//Note access of this.dataOfBirth created by public member setDateOfBirth
this.toString = function () {
return 'toString called ' + this.id + ' ' + this.name + ' ' + fName + ' ' + lName + ' ' + this.dataOfBirth;
}
}
//Public function has access to member variable and can create on too but does not have access to private variable
Employee.prototype.setDateOfBirth = function (dob) {
alert('setDateOfBirth called ' + this.id);
this.dataOfBirth = dob; //Creates new public member note this is accessed by toString
//alert(fName); //Does not have access to private member
}
$(document).ready()
{
var employee = new Employee(5, 'Shyam'); //Create a new object and initialize it with constructor
employee.setLName('Bhaskar', 'Ram'); //Call privileged function
employee.setDateOfBirth('1/1/2000'); //Call public function
employee.id = 9; //Set up member value
//employee.setFName('Ram'); //can not call Private Privileged method
alert(employee.toString()); //See the changed object
}
答案 5 :(得分：13)
我想到了这个：编辑：实际上，有人已经链接到相同的解决方案。杜！
var Car = function() {
}
Car.prototype = (function() {
var hotWire = function() {
// Private code *with* access to public properties through 'this'
alert( this.drive() ); // Alerts 'Vroom!'
}
return {
steal: function() {
hotWire.call( this ); // Call a private method
},
drive: function() {
return 'Vroom!';
}
};
})();
var getAwayVechile = new Car();
hotWire(); // Not allowed
getAwayVechile.hotWire(); // Not allowed
getAwayVechile.steal(); // Alerts 'Vroom!'
答案 6 :(得分：10)
我认为这些问题一次又一次地出现，因为对闭包缺乏了解。 Сlosures是JS中最重要的事情。每个JS程序员都必须感受到它的本质。
1。首先，我们需要制作单独的范围（闭包）。
function () {
}
2. 在这方面，我们可以做任何我们想做的事。没有人会知道它。
function () {
var name,
secretSkills = {
pizza: function () { return new Pizza() },
sushi: function () { return new Sushi() }
}
function Restaurant(_name) {
name = _name
}
Restaurant.prototype.getFood = function (name) {
return name in secretSkills ? secretSkills[name]() : null
}
}
3。为了让全世界了解我们的餐厅课程， 我们必须从关闭中返回它。
var Restaurant = (function () {
// Restaurant definition
return Restaurant
})()
4. 最后，我们有：
var Restaurant = (function () {
var name,
secretSkills = {
pizza: function () { return new Pizza() },
sushi: function () { return new Sushi() }
}
function Restaurant(_name) {
name = _name
}
Restaurant.prototype.getFood = function (name) {
return name in secretSkills ? secretSkills[name]() : null
}
return Restaurant
})()
5. 此外，这种方法具有继承和模板的潜力
// Abstract class
function AbstractRestaurant(skills) {
var name
function Restaurant(_name) {
name = _name
}
Restaurant.prototype.getFood = function (name) {
return skills && name in skills ? skills[name]() : null
}
return Restaurant
}
// Concrete classes
SushiRestaurant = AbstractRestaurant({
sushi: function() { return new Sushi() }
})
PizzaRestaurant = AbstractRestaurant({
pizza: function() { return new Pizza() }
})
var r1 = new SushiRestaurant('Yo! Sushi'),
r2 = new PizzaRestaurant('Dominos Pizza')
r1.getFood('sushi')
r2.getFood('pizza')
我希望这可以帮助别人更好地理解这个主题
答案 7 :(得分：9)
就个人而言，我更喜欢以下模式在JavaScript中创建类：
var myClass = (function() {
// Private class properties go here
var blueprint = function() {
// Private instance properties go here
...
};
blueprint.prototype = {
// Public class properties go here
...
};
return {
// Public class properties go here
create : function() { return new blueprint(); }
...
};
})();
如您所见，它允许您定义类属性和实例属性，每个属性都可以是公共属性和私有属。
var Restaurant = function() {
var totalfoodcount = 0; // Private class property
var totalrestroomcount = 0; // Private class property
var Restaurant = function(name){
var foodcount = 0; // Private instance property
var restroomcount = 0; // Private instance property
this.name = name
this.incrementFoodCount = function() {
foodcount++;
totalfoodcount++;
this.printStatus();
};
this.incrementRestroomCount = function() {
restroomcount++;
totalrestroomcount++;
this.printStatus();
};
this.getRestroomCount = function() {
return restroomcount;
},
this.getFoodCount = function() {
return foodcount;
}
};
Restaurant.prototype = {
name : '',
buy_food : function(){
this.incrementFoodCount();
},
use_restroom : function(){
this.incrementRestroomCount();
},
getTotalRestroomCount : function() {
return totalrestroomcount;
},
getTotalFoodCount : function() {
return totalfoodcount;
},
printStatus : function() {
document.body.innerHTML
+= '<h3>Buying food at '+this.name+'</h3>'
+ '<ul>'
+ '<li>Restroom count at ' + this.name + ' : '+ this.getRestroomCount() + '</li>'
+ '<li>Food count at ' + this.name + ' : ' + this.getFoodCount() + '</li>'
+ '<li>Total restroom count : '+ this.getTotalRestroomCount() + '</li>'
+ '<li>Total food count : '+ this.getTotalFoodCount() + '</li>'
+ '</ul>';
}
};
return { // Singleton public properties
create : function(name) {
return new Restaurant(name);
},
printStatus : function() {
document.body.innerHTML
+= '<hr />'
+ '<h3>Overview</h3>'
+ '<ul>'
+ '<li>Total restroom count : '+ Restaurant.prototype.getTotalRestroomCount() + '</li>'
+ '<li>Total food count : '+ Restaurant.prototype.getTotalFoodCount() + '</li>'
+ '</ul>'
+ '<hr />';
}
};
}();
var Wendys = Restaurant.create("Wendy's");
var McDonalds = Restaurant.create("McDonald's");
var KFC = Restaurant.create("KFC");
var BurgerKing = Restaurant.create("Burger King");
Restaurant.printStatus();
Wendys.buy_food();
Wendys.use_restroom();
KFC.use_restroom();
KFC.use_restroom();
Wendys.use_restroom();
McDonalds.buy_food();
BurgerKing.buy_food();
Restaurant.printStatus();
BurgerKing.buy_food();
Wendys.use_restroom();
McDonalds.buy_food();
KFC.buy_food();
Wendys.buy_food();
BurgerKing.buy_food();
McDonalds.buy_food();
Restaurant.printStatus();
另见this Fiddle。
答案 8 :(得分：8)
所有这些关闭将花费你。确保测试速度影响，尤其是在IE中。您会发现最好使用命名约定。仍然有很多企业网站用户被迫使用IE6 ......
答案 9 :(得分：3)
采用Crockford的私有或特权模式之后的任何解决方案。例如：
function Foo(x) {
var y = 5;
var bar = function() {
return y * x;
};
this.public = function(z) {
return bar() + x * z;
};
}
在任何情况下，攻击者都没有＆＃34;执行＆＃34;在JS上下文中，他无法访问任何＆＃34; public＆＃34;或者＆＃34;私人＆＃34;领域或方法。如果攻击者确实具有该访问权限，则可以执行此单行程序：
eval("Foo = " + Foo.toString().replace(
/{/, "{ this.eval = function(code) { return eval(code); }; "
));
请注意，上述代码对所有构造函数类型的隐私都是通用的。它将失败，其中包含一些解决方案，但应该清楚的是，几乎所有基于闭包的解决方案都可以使用不同的replace()参数进行打破。
执行此操作后，使用new Foo()创建的任何对象都将具有eval方法，可以调用该方法来返回或更改构造函数闭包中定义的值或方法，例如：
f = new Foo(99);
f.eval("x");
f.eval("y");
f.eval("x = 8");
我能看到的唯一问题是它不会在只有一个实例并且在加载时创建的情况下工作。但是没有理由真正定义原型，在这种情况下，攻击者可以简单地重新创建对象而不是构造函数，只要他有办法传递相同的参数（例如，它们是常量或从可用值计算）。
在我看来，这几乎使得Crockford的解决方案毫无用处。因为＆＃34;隐私＆＃34;很容易打破他的解决方案的缺点（降低可读性和可维护性，降低性能，增加内存）使＆＃34;没有隐私＆＃34;基于原型的方法更好的选择。
我通常使用前导下划线来标记__private和_protected方法和字段（Perl样式），但在JavaScript中隐私的想法只是表明它是一种被误解的语言。
因此，除了第一句话外，我不同意Crockford 。
那么如何在JS中获得真正的隐私？在服务器端放置所有必需的私有内容并使用JS进行AJAX调用。
答案 10 :(得分：2)
这里有关于私人/公共方法/成员以及javascript中实例化的最热门程度：
这篇文章是：http://www.sefol.com/?p=1090
以下是示例：
var Person = (function () {
//Immediately returns an anonymous function which builds our modules
return function (name, location) {
alert("createPerson called with " + name);
var localPrivateVar = name;
var localPublicVar = "A public variable";
var localPublicFunction = function () {
alert("PUBLIC Func called, private var is :" + localPrivateVar)
};
var localPrivateFunction = function () {
alert("PRIVATE Func called ")
};
var setName = function (name) {
localPrivateVar = name;
}
return {
publicVar: localPublicVar,
location: location,
publicFunction: localPublicFunction,
setName: setName
}
}
})();
//Request a Person instance - should print "createPerson called with ben"
var x = Person("ben", "germany");
//Request a Person instance - should print "createPerson called with candide"
var y = Person("candide", "belgium");
//Prints "ben"
x.publicFunction();
//Prints "candide"
y.publicFunction();
//Now call a public function which sets the value of a private variable in the x instance
x.setName("Ben 2");
//Shouldn't have changed this : prints "candide"
y.publicFunction();
//Should have changed this : prints "Ben 2"
x.publicFunction();
答案 11 :(得分：2)
在大多数情况下，模块模式是正确的。但是如果你有数千个实例，那么类可以节省内存。如果保存内存是一个问题，并且您的对象包含少量私有数据，但具有许多公共函数，那么您希望所有公共函数都存在于.prototype中以节省内存。
这就是我提出的：
var MyClass = (function () {
var secret = {}; // You can only getPriv() if you know this
function MyClass() {
var that = this, priv = {
foo: 0 // ... and other private values
};
that.getPriv = function (proof) {
return (proof === secret) && priv;
};
}
MyClass.prototype.inc = function () {
var priv = this.getPriv(secret);
priv.foo += 1;
return priv.foo;
};
return MyClass;
}());
var x = new MyClass();
x.inc(); // 1
x.inc(); // 2
对象priv包含私有属性。它可以通过公共函数getPriv()访问，但是这个函数返回false，除非你将它传递给secret，这只在主闭包内知道。
答案 12 :(得分：2)
这个怎么样？
var Restaurant = (function() {
var _id = 0;
var privateVars = [];
function Restaurant(name) {
this.id = ++_id;
this.name = name;
privateVars[this.id] = {
cooked: []
};
}
Restaurant.prototype.cook = function (food) {
privateVars[this.id].cooked.push(food);
}
return Restaurant;
})();
在立即函数的范围之外，私有变量查找是不可能的。 没有重复的功能，节省了内存。
缺点是私有变量的查找很笨privateVars[this.id].cooked很难打字。还有一个额外的“id”变量。
答案 13 :(得分：2)
私有方法名称以井号#开头，并且只能在定义该类的类中仅进行访问。
class Restaurant {
// private method
#private_stuff() {
console.log("private stuff");
}
// public method
buy_food() {
this.#private_stuff();
}
};
const restaurant = new Restaurant();
restaurant.buy_food(); // "private stuff";
restaurant.private_stuff(); // Uncaught TypeError: restaurant.private_stuff is not a function
这是一个实验性建议。 ECMAScript 2021版本预计将于2021年6月发布。
答案 14 :(得分：2)
如果您希望公共功能的所有公共和私有函数能够访问私有函数，则可以使用以下对象的布局代码：
function MyObject(arg1, arg2, ...) {
//constructor code using constructor arguments...
//create/access public variables as
// this.var1 = foo;
//private variables
var v1;
var v2;
//private functions
function privateOne() {
}
function privateTwon() {
}
//public functions
MyObject.prototype.publicOne = function () {
};
MyObject.prototype.publicTwo = function () {
};
}
答案 15 :(得分：2)
模块模式的典范：The Revealing Module Pattern
对一个非常强大的模式的一个简洁的小扩展。
答案 16 :(得分：1)
将所有代码包装在匿名函数中：然后，所有函数都将是私有的，仅附加到window对象的函数：
(function(w,nameSpacePrivate){
w.Person=function(name){
this.name=name;
return this;
};
w.Person.prototype.profilePublic=function(){
return nameSpacePrivate.profile.call(this);
};
nameSpacePrivate.profile=function(){
return 'My name is '+this.name;
};
})(window,{});
使用此：
var abdennour=new Person('Abdennour');
abdennour.profilePublic();
答案 17 :(得分：1)
您现在可以使用es10 private methods进行此操作。您只需要在方法名称之前添加#。
class ClassWithPrivateMethod {
#privateMethod() {
return 'hello world';
}
getPrivateMessage() {
return #privateMethod();
}
}
答案 18 :(得分：1)
var TestClass = function( ) {
var privateProperty = 42;
function privateMethod( ) {
alert( "privateMethod, " + privateProperty );
}
this.public = {
constructor: TestClass,
publicProperty: 88,
publicMethod: function( ) {
alert( "publicMethod" );
privateMethod( );
}
};
};
TestClass.prototype = new TestClass( ).public;
var myTestClass = new TestClass( );
alert( myTestClass.publicProperty );
myTestClass.publicMethod( );
alert( myTestClass.privateMethod || "no privateMethod" );
与georgebrock相似，但不那么冗长（恕我直言） 这样做有什么问题吗？ （我没有在任何地方看到它）
编辑：我意识到这有点无用，因为每个独立的实例都有自己的公共方法副本，从而破坏了原型的使用。
答案 19 :(得分：0)
我知道这是一个老话题，但我试图找到一种方法来保持代码的“简单性”以实现可维护性目的并保持轻的内存负载。它带有这种模式。希望有帮助。
const PublicClass=function(priv,pub,ro){
let _priv=new PrivateClass(priv,pub,ro);
['publicMethod'].forEach(k=>this[k]=(...args)=>_priv[k](...args));
['publicVar'].forEach(k=>Object.defineProperty(this,k,{get:()=>_priv[k],set:v=>_priv[k]=v}));
['readOnlyVar'].forEach(k=>Object.defineProperty(this,k,{get:()=>_priv[k]}));
};
class PrivateClass{
constructor(priv,pub,ro){
this.privateVar=priv;
this.publicVar=pub;
this.readOnlyVar=ro;
}
publicMethod(arg1,arg2){
return this.privateMethod(arg1,arg2);
}
privateMethod(arg1,arg2){
return arg1+''+arg2;
}
}
// in node;
module.exports=PublicClass;
// in browser;
const PublicClass=(function(){
// code here
return PublicClass;
})();
旧浏览器的相同原理：
var PublicClass=function(priv,pub,ro){
var scope=this;
var _priv=new PrivateClass(priv,pub,ro);
['publicMethod'].forEach(function(k){
scope[k]=function(){return _priv[k].apply(_priv,arguments)};
});
['publicVar'].forEach(function(k){
Object.defineProperty(scope,k,{get:function(){return _priv[k]},set:function(v){_priv[k]=v}});
});
['readOnlyVar'].forEach(function(k){
Object.defineProperty(scope,k,{get:function(){return _priv[k]}});
});
};
var PrivateClass=function(priv,pub,ro){
this.privateVar=priv;
this.publicVar=pub;
this.readOnlyVar=ro;
};
PrivateClass.prototype.publicMethod=function(arg1,arg2){
return this.privateMethod(arg1,arg2);
};
PrivateClass.prototype.privateMethod=function(arg1,arg2){
return arg1+''+arg2;
};
为了减轻公共类的冗长和负载，将此模式应用于构造函数：
const AbstractPublicClass=function(instanciate,inherit){
let _priv=instanciate();
inherit.methods?.forEach(k=>this[k]=(...args)=>_priv[k](...args));
inherit.vars?.forEach(k=>Object.defineProperty(this,k,{get:()=>_priv[k],set:v=>_priv[k]=v}));
inherit.readonly?.forEach(k=>Object.defineProperty(this,k,{get:()=>_priv[k]}));
};
AbstractPublicClass.static=function(_pub,_priv,inherit){
inherit.methods?.forEach(k=>_pub[k]=(...args)=>_priv[k](...args));
inherit.vars?.forEach(k=>Object.defineProperty(_pub,k,{get:()=>_priv[k],set:v=>_priv[k]=v}));
inherit.readonly?.forEach(k=>Object.defineProperty(_pub,k,{get:()=>_priv[k]}));
};
使用：
// PrivateClass ...
PrivateClass.staticVar='zog';
PrivateClass.staticMethod=function(){return 'hello '+this.staticVar;};
const PublicClass=function(priv,pub,ro){
AbstractPublicClass.apply(this,[()=>new PrivateClass(priv,pub,ro),{
methods:['publicMethod'],
vars:['publicVar'],
readonly:['readOnlyVar']
}]);
};
AbstractPublicClass.static(PublicClass,PrivateClass,{
methods:['staticMethod'],
vars:['staticVar']
});
PS：这种方法的默认设置（大多数情况下可以忽略不计）是，与完全公开的情况相比，它只需要很小的计算负载。但只要你不使用它，它应该是可以的。
答案 20 :(得分：0)
请参阅this answer了解一个干净的＆amp;简单的“类”解决方案，具有私有和公共界面，支持合成
答案 21 :(得分：0)
我更喜欢将私有数据存储在关联的WeakMap中。这允许您将公共方法保留在它们所属的原型上。这似乎是处理大量对象的这个问题的最有效方法。
const data = new WeakMap();
function Foo(value) {
data.set(this, {value});
}
// public method accessing private value
Foo.prototype.accessValue = function() {
return data.get(this).value;
}
// private 'method' accessing private value
function accessValue(foo) {
return data.get(foo).value;
}
export {Foo};
答案 22 :(得分：0)
别那么冗长。它是Javascript。使用命名约定。
在es6类中工作了多年之后，我最近开始从事es5项目的工作（使用requireJS已经看起来很冗长）。我已经遍及这里提到的所有策略，基本上都归结为使用命名约定：
private这样的范围关键字。其他使用Javascript的开发人员将对此有所了解。因此，简单的命名约定已绰绰有余。带下划线前缀的简单命名约定解决了私有属性和私有方法的问题。 my-tooltip.js
define([
'tooltip'
],
function(
tooltip
){
function MyTooltip() {
// Later, if needed, we can remove the underscore on some
// of these (make public) and allow clients of our class
// to set them.
this._selector = "#my-tooltip"
this._template = 'Hello from inside my tooltip!';
this._initTooltip();
}
MyTooltip.prototype = {
constructor: MyTooltip,
_initTooltip: function () {
new tooltip.tooltip(this._selector, {
content: this._template,
closeOnClick: true,
closeButton: true
});
}
}
return {
init: function init() {
new MyTooltip(); // <-- Our constructor adds our tooltip to the DOM so not much we need to do after instantiation.
}
// You could instead return a new instantiation,
// if later you do more with this class.
/*
create: function create() {
return new MyTooltip();
}
*/
}
});
答案 23 :(得分：0)
一个丑陋的解决方案，但它可行：
record
答案 24 :(得分：0)
老问题，但这是一个相当简单的任务，可以正确用核心 JS 解决……没有 ES6 的类抽象。事实上，据我所知，类抽象甚至不能解决这个问题。
我们既可以使用旧的构造函数，也可以使用 Object.create() 更好地完成这项工作。让我们先使用构造函数。这本质上是与 georgebrock's answer 类似的解决方案，后者受到批评，因为 Restaurant 构造函数创建的所有餐厅都将具有相同的私有方法。我会努力克服这个限制。
function restaurantFactory(name,menu){
function Restaurant(name){
this.name = name;
}
function prototypeFactory(menu){
// This is a private function
function calculateBill(item){
return menu[item] || 0;
}
// This is the prototype to be
return { constructor: Restaurant
, askBill : function(...items){
var cost = items.reduce((total,item) => total + calculateBill(item) ,0)
return "Thank you for dining at " + this.name + ". Total is: " + cost + "\n"
}
, callWaiter : function(){
return "I have just called the waiter at " + this.name + "\n";
}
}
}
Restaurant.prototype = prototypeFactory(menu);
return new Restaurant(name,menu);
}
var menu = { water: 1
, coke : 2
, beer : 3
, beef : 15
, rice : 2
},
name = "Silver Scooop",
rest = restaurantFactory(name,menu);
console.log(rest.callWaiter());
console.log(rest.askBill("beer", "beef"));现在显然我们无法从外部访问 menu，但我们可以轻松地重命名餐厅的 name 属性。
这也可以用 Object.create() 来完成，在这种情况下，我们跳过构造函数，只需像 var rest = Object.create(prototypeFactory(menu)) 一样，然后像 {{1} 一样将 name 属性添加到 rest 对象}.
答案 25 :(得分：0)
这个问题已经有很多答案了，但没有什么符合我的需要。所以我提出了自己的解决方案，我希望它对某人有用：
function calledPrivate(){
var stack = new Error().stack.toString().split("\n");
function getClass(line){
var i = line.indexOf(" ");
var i2 = line.indexOf(".");
return line.substring(i,i2);
}
return getClass(stack[2])==getClass(stack[3]);
}
class Obj{
privateMethode(){
if(calledPrivate()){
console.log("your code goes here");
}
}
publicMethode(){
this.privateMethode();
}
}
var obj = new Obj();
obj.publicMethode(); //logs "your code goes here"
obj.privateMethode(); //does nothing
正如您所看到的，当在javascript中使用此类类时，此系统可以正常工作。据我所知，上面评论过的方法都没有。
答案 26 :(得分：0)
我知道这有点太晚但是这个怎么样？
var obj = function(){
var pr = "private";
var prt = Object.getPrototypeOf(this);
if(!prt.hasOwnProperty("showPrivate")){
prt.showPrivate = function(){
console.log(pr);
}
}
}
var i = new obj();
i.showPrivate();
console.log(i.hasOwnProperty("pr"));
答案 27 :(得分：0)
我创建了一个新工具，允许您在原型上拥有真正的私有方法 https://github.com/TremayneChrist/ProtectJS
示例：
var MyObject = (function () {
// Create the object
function MyObject() {}
// Add methods to the prototype
MyObject.prototype = {
// This is our public method
public: function () {
console.log('PUBLIC method has been called');
},
// This is our private method, using (_)
_private: function () {
console.log('PRIVATE method has been called');
}
}
return protect(MyObject);
})();
// Create an instance of the object
var mo = new MyObject();
// Call its methods
mo.public(); // Pass
mo._private(); // Fail
答案 28 :(得分：0)
Class({
Namespace:ABC,
Name:"ClassL2",
Bases:[ABC.ClassTop],
Private:{
m_var:2
},
Protected:{
proval:2,
fight:Property(function(){
this.m_var--;
console.log("ClassL2::fight (m_var)" +this.m_var);
},[Property.Type.Virtual])
},
Public:{
Fight:function(){
console.log("ClassL2::Fight (m_var)"+this.m_var);
this.fight();
}
}
});
答案 29 :(得分：0)
这就是我的成果：
需要一类you can find here的糖代码。还支持受保护，继承，虚拟，静态的东西......
;( function class_Restaurant( namespace )
{
'use strict';
if( namespace[ "Restaurant" ] ) return // protect against double inclusions
namespace.Restaurant = Restaurant
var Static = TidBits.OoJs.setupClass( namespace, "Restaurant" )
// constructor
//
function Restaurant()
{
this.toilets = 3
this.Private( private_stuff )
return this.Public( buy_food, use_restroom )
}
function private_stuff(){ console.log( "There are", this.toilets, "toilets available") }
function buy_food (){ return "food" }
function use_restroom (){ this.private_stuff() }
})( window )
var chinese = new Restaurant
console.log( chinese.buy_food() ); // output: food
console.log( chinese.use_restroom() ); // output: There are 3 toilets available
console.log( chinese.toilets ); // output: undefined
console.log( chinese.private_stuff() ); // output: undefined
// and throws: TypeError: Object #<Restaurant> has no method 'private_stuff'
答案 30 :(得分：0)
您必须在实际的构造函数周围放置一个闭包，您可以在其中定义私有方法。 要通过这些私有方法更改实例的数据，您必须将它们作为函数参数或通过使用.apply（this）调用此函数给它们“this”：
var Restaurant = (function(){
var private_buy_food = function(that){
that.data.soldFood = true;
}
var private_take_a_shit = function(){
this.data.isdirty = true;
}
// New Closure
function restaurant()
{
this.data = {
isdirty : false,
soldFood: false,
};
}
restaurant.prototype.buy_food = function()
{
private_buy_food(this);
}
restaurant.prototype.use_restroom = function()
{
private_take_a_shit.call(this);
}
return restaurant;
})()
// TEST:
var McDonalds = new Restaurant();
McDonalds.buy_food();
McDonalds.use_restroom();
console.log(McDonalds);
console.log(McDonalds.__proto__);
答案 31 :(得分：0)
一般情况下，我将私有Object _临时添加到对象中。 您必须在方法的“Power-constructor”中打开隐私。 如果你从原型中调用方法，你会的 能够覆盖原型方法
在“Power-constructor”中访问公共方法:( ctx是对象上下文）
ctx.test = GD.Fabric.open('test', GD.Test.prototype, ctx, _); // is a private object
现在我有这个openPrivacy：
GD.Fabric.openPrivacy = function(func, clss, ctx, _) {
return function() {
ctx._ = _;
var res = clss[func].apply(ctx, arguments);
ctx._ = null;
return res;
};
};
答案 32 :(得分：0)
由于每个人都在这里张贴自己的代码，我也会这样做......
我喜欢Crockford，因为他在Javascript中引入了真正的面向对象模式。但他也提出了一个新的误解，即“那个”。
那他为什么要用“那=这个”呢？它根本与私人功能无关。它与内在功能有关！
因为根据Crockford的说法，这是错误的代码：
Function Foo( ) {
this.bar = 0;
var foobar=function( ) {
alert(this.bar);
}
}
所以他建议这样做：
Function Foo( ) {
this.bar = 0;
that = this;
var foobar=function( ) {
alert(that.bar);
}
}
正如我所说，我很确定Crockford对此的解释是错误的（但他的代码肯定是正确的）。或者他只是在愚弄Javascript世界，知道谁在复制他的代码？我不知道......我不是浏览器的极客; D
修改
啊，这就是全部：What does 'var that = this;' mean in JavaScript?
所以Crockie对他的解释真的错了......但是他的代码是正确的，所以他仍然是个好人。 ：））
答案 33 :(得分：0)
私有函数无法使用模块模式访问公共变量