要创建一个带有公共方法的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的文章几次，但它似乎不像“私有”方法可以被公共方法调用，而“特权”方法可以被外部调用。
将所有代码包装在匿名函数中:然后，所有函数将是私有的，只有函数附加到窗口对象:
(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();
小提琴
2021年这里!
这个polyfill有效地隐藏了你的私有属性和方法，当你试图读取你的私有属性时返回undefined，当你试图执行你的私有方法时返回TypeError，从而有效地使它们对外部都是private，但让你通过使用你的公共方法访问它们。
如果你检查它，你会发现它很容易实现。在大多数情况下，你不需要做任何奇怪的事情，如使用代理对象，下划线函数(_myprivate)， getter或setter。都不是。唯一需要做的事情是在构造函数中放置一段类似的代码片段，目的是让您向外界公开您的公共接口。
((self) => ({
pubProp: self.pubProp,
// More public properties to export HERE
// ...
pubMethod: self.pubMethod.bind(self)
// More public mehods to export HERE
// Be sure bind each of them to self!!!
// ...
}))(self);
上面的代码就是魔术发生的地方。它是一个IIFE，返回一个对象，其中只包含您想要公开并绑定到第一次实例化的对象的上下文的属性和方法。
你仍然可以访问你的隐藏属性和方法，但只能通过你的公共方法，就像OOP应该做的那样。
将这部分代码视为module.exports
顺便说一句，这是没有使用最新的ECMAScript 2022 #添加到语言中。
'use strict';
class MyClass {
constructor(pubProp) {
let self = this;
self.pubProp = pubProp;
self.privProp = "I'm a private property!";
return ((self) => ({
pubProp: self.pubProp,
// More public properties to export HERE
// ...
pubMethod: self.pubMethod.bind(self)
// More public mehods to export HERE
// Be sure to bind each of them to self!!!
// ...
}))(self);
}
pubMethod() {
console.log("I'm a public method!");
console.log(this.pubProp);
return this.privMethod();
}
privMethod() {
console.log("I'm a private method!");
return this.privProp
}
}
const myObj = new MyClass("I'm a public property!");
console.log("***DUMPING MY NEW INSTANCE***");
console.dir(myObj);
console.log("");
console.log("***TESTING ACCESS TO PUBLIC PROPERTIES***");
console.log(myObj.pubProp);
console.log("");
console.log("***TESTING ACCESS TO PRIVATE PROPERTIES***");
console.log(myObj.privProp);
console.log("");
console.log("***TESTING ACCESS TO PUBLIC METHODS***");
console.log("1. pubMethod access pubProp ");
console.log("2. pubMethod calls privMethod");
console.log("3. privMethod access privProp");
console.log("")
console.log(myObj.pubMethod());
console.log("");
console.log("***TESTING ACCESS TO PRIVATE METHODS***");
console.log(myObj.privMethod());
看看我的主旨
老问题，但这是一个相当简单的任务，可以用核心JS正确解决…没有ES6的Class抽象。事实上，据我所知，类抽象甚至不能解决这个问题。
我们既可以使用老的构造函数，也可以使用Object.create()更好地完成这项工作。让我们先从构造函数开始。这本质上是一个与georgebrock的答案相似的解决方案，georgebrock的答案受到了批评，因为所有由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"));
现在显然我们不能从外部访问菜单，但我们可以很容易地重命名餐厅的name属性。
这也可以用object .create()来完成，在这种情况下，我们跳过构造函数，简单地像var rest = object .create(prototypeFactory(menu))那样做，然后像rest.name = name那样将name属性添加到rest对象。
以遵循Crockford私有或特权模式的任何解决方案为例。例如:
function Foo(x) {
var y = 5;
var bar = function() {
return y * x;
};
this.public = function(z) {
return bar() + x * z;
};
}
在任何情况下，如果攻击者在JS上下文中没有“执行”权，他就没有办法访问任何“公共”或“私有”字段或方法。如果攻击者有访问权限，他可以执行以下一行代码:
eval("Foo = " + Foo.toString().replace(
/{/, "{ this.eval = function(code) { return eval(code); }; "
));
注意，上面的代码对于所有构造函数类型-privacy都是通用的。这里的一些解决方案会失败，但应该清楚的是，几乎所有基于闭包的解决方案都可以通过不同的replace()参数像这样被破坏。
在此执行之后，任何用new Foo()创建的对象都将有一个eval方法，可以调用该方法来返回或更改构造函数闭包中定义的值或方法，例如:
f = new Foo(99);
f.eval("x");
f.eval("y");
f.eval("x = 8");
我能看到的唯一问题是，它不会工作的情况下，只有一个实例，它是在加载时创建的。但这样就没有理由真正定义原型了，在这种情况下，攻击者可以简单地重新创建对象，而不是构造函数，只要他有方法传递相同的参数(例如，它们是常量或从可用值计算出来的)。
在我看来，这使得Crockford的解决方案毫无用处。由于“隐私”很容易被打破，他的解决方案的缺点(可读性和可维护性降低，性能下降，内存增加)使得基于“无隐私”原型的方法成为更好的选择。
我通常使用前导下划线标记__private和_protected方法和字段(Perl风格)，但在JavaScript中拥有隐私的想法只是表明它是一种被误解的语言。
因此，除了Crockford的第一句话外，我不同意他的观点。
那么如何在JS中获得真正的隐私呢?将所有需要私有的东西放在服务器端，并使用JS进行AJAX调用。
