我想到了这个:编辑:实际上，有人已经链接到一个相同的解决方案。咄!

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!'

老问题，但这是一个相当简单的任务，可以用核心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对象。

一般来说，我将私有Object _临时添加到对象中。 您必须在该方法的“Power-constructor”中显式地打开隐私。 如果您从原型中调用该方法，您将会 能够覆盖原型方法

使一个公共方法在"Power-constructor"中可访问:(ctx是对象上下文) ctx。test = GD.Fabric。(“测试”,GD.Test开放。原型，ctx， _);//是私有对象 现在我有这个openPrivacy: GD.Fabric.openPrivacy = function(func, clss, ctx， _) { 返回函数(){ ctx。_ = _; Var res = clss[func]。应用(ctx、参数); ctx。_ = null; 返回res; }; };

ES2021 / ES12 -私有方法

私有方法名以哈希前缀#开头，并且只能在定义它的类内部访问。

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

我知道有点晚了，但是这样怎么样?

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"));

以遵循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调用。