Вы можете это сделать, но недостатком является то, что он не может быть частью прототипа:

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();
    }
}

Вы можете смоделировать частные методы следующим образом:

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

В этих ситуациях, когда у вас есть общедоступный 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

Апофеоз паттерна модуля: Выявление паттерна модуля

Небольшое аккуратное продолжение очень прочного узора.

Все это закрытие будет стоить вам. Убедитесь, что вы проверили влияние скорости, особенно в IE. Вы обнаружите, что лучше использовать соглашение об именах. Есть еще много корпоративных веб-пользователей, которые вынуждены использовать IE6 ...

Если вам нужен полный набор общедоступных и частных функций с возможностью для общедоступных функций доступ к частным функциям, разметьте код для объекта, подобного этому:

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 () {
  };
}

Я придумал это: Обновлено: На самом деле кто-то связался с идентичным решением. Ага!

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

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, но немного менее многословно (IMHO) Есть проблемы с тем, чтобы сделать это таким образом? (Нигде не видел)

edit: Я понял, что это бесполезно, поскольку каждый независимый экземпляр имеет свою собственную копию общедоступных методов, что подрывает использование прототипа.

Частные функции не могут получить доступ к общедоступным переменным с использованием шаблона модуля

Вот класс, который я создал, чтобы понять, что предложил Дуглас Крокфорд на своем сайте Частные члены в 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

}

Поскольку каждый размещал здесь свой код, я тоже сделаю это ...

Мне нравится Крокфорд, потому что он ввел в Javascript настоящие объектно-ориентированные шаблоны. Но он также придумал новое недоразумение, «то».

Так почему он использует «это = это»? Это вообще не имеет ничего общего с частными функциями. Это связано с внутренними функциями!

Потому что, по словам Крокфорда, это ошибочный код:

Function Foo( ) {
    this.bar = 0; 
    var foobar=function( ) {
        alert(this.bar);
    }
} 

Поэтому он предложил сделать следующее:

Function Foo( ) {
    this.bar = 0;
    that = this; 
    var foobar=function( ) {
        alert(that.bar);
    }
}

Итак, как я уже сказал, я совершенно уверен, что Крокфорд ошибался в своих объяснениях по поводу того и этого (но его код определенно верен). Или он просто обманул мир Javascript, чтобы узнать, кто копирует его код? Я не знаю ... Я не фанат браузеров; D

РЕДАКТИРОВАТЬ

Ах, вот в чем все суть: Что означает 'var that = this;' имеете в виду в JavaScript?

Итак, Кроки действительно ошибся в своем объяснении ... но правильно в своем коде, так что он все еще отличный парень. :))

В общем, я временно добавил к объекту частный объект _. Вы должны открыть приватность только в «Power-конструкторе» для метода. Если вы вызовете метод из прототипа, вы иметь возможность перезаписать метод-прототип

• Сделать общедоступный метод доступным в «Power-конструкторе»: (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;
      };
  };
  

Вы должны закрыть свою фактическую функцию-конструктор, где вы можете определить свои частные методы. Чтобы изменить данные экземпляров с помощью этих частных методов, вы должны передать им «this» вместе с ними либо в качестве аргумента функции, либо путем вызова этой функции с помощью .apply (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.info(McDonalds);
console.info(McDonalds.__proto__);

Я думаю, что такие вопросы возникают снова и снова из-за непонимания закрытий. Скрытность - это самое главное в 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')

Надеюсь, это поможет кому-то лучше понять эту тему

Вот что я разработал:

Требуется один класс кода сахара, который вы можете найти здесь. Также поддерживает защищенный, наследование, виртуальный, статический материал ...

;( 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.info( "There are", this.toilets, "toilets available") }

    function buy_food     (){ return "food"        }
    function use_restroom (){ this.private_stuff() }

})( window )


var chinese = new Restaurant

console.info( chinese.buy_food()      );  // output: food
console.info( chinese.use_restroom()  );  // output: There are 3 toilets available
console.info( chinese.toilets         );  // output: undefined
console.info( chinese.private_stuff() );  // output: undefined

// and throws: TypeError: Object #<Restaurant> has no method 'private_stuff'

Как насчет этого?

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.

Class({  
    Namespace:ABC,  
    Name:"ClassL2",  
    Bases:[ABC.ClassTop],  
    Private:{  
        m_var:2  
    },  
    Protected:{  
        proval:2,  
        fight:Property(function(){  
            this.m_var--;  
            console.info("ClassL2::fight (m_var)" +this.m_var);  
        },[Property.Type.Virtual])  
    },  
    Public:{  
        Fight:function(){  
            console.info("ClassL2::Fight (m_var)"+this.m_var);  
            this.fight();  
        }  
    }  
});  

https://github.com/nooning/JSClass

Я создал новый инструмент, который позволит вам иметь настоящие частные методы на прототипе. 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.info('PUBLIC method has been called');
    },

    // This is our private method, using (_)
    _private: function () {
      console.info('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

Использование функции автоматического вызова и вызова

JavaScript использует прототипы и не имеет классов (или методов в этом отношении), таких как объектно-ориентированные языки. Разработчику JavaScript нужно думать на JavaScript.

Цитата из Википедии:

Unlike many object-oriented languages, there is no distinction between a function definition and a method definition. Rather, the distinction occurs during function calling; when a function is called as a method of an object, the function's local this keyword is bound to that object for that invocation.

Решение с использованием самозапускающаяся функция и функция вызова для вызова частного «метода»:

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

функция вызова позволяет нам вызывать частную функцию с соответствующим контекстом (this).

Проще с Node.js

Если вы используете Node.js, вам не нужен IIFE, потому что вы можете воспользоваться преимуществами система загрузки модулей:

function MyObject(foo) {
  this._foo = foo;
}
    
function privateFun(prefix) {
  return prefix + this._foo;
}

MyObject.prototype.publicFun = function () {
  return privateFun.call(this, ">>");
}
    
module.exports= MyObject;

Загрузите файл:

var MyObject = require("./MyObject");
    
var myObject = new MyObject("bar");
myObject.publicFun();      // Returns ">>bar"
myObject.privateFun(">>"); // ReferenceError: private is not defined

(новинка!) Собственные частные методы в будущих версиях JavaScript

Предложение TC39 частные методы и геттеры / сеттеры для классов JavaScript - это этап 3. Это означает, что в ближайшее время JavaScript будет реализовывать частные методы изначально!

Обратите внимание, что Поля частного класса JavaScript уже существует в современных версиях JavaScript.

Вот пример того, как это используется:

class MyObject {

  // Private field
  #foo;
    
  constructor(foo) {
    this.#foo = foo;
  }

  #privateFun(prefix) {
   return prefix + this.#foo;
  }
    
  publicFun() {
    return this.#privateFun(">>");
  }

}

Вам может понадобиться Транспилятор / компилятор JavaScript для запуска этого кода на старых движках JavaScript.

PS: Если вам интересно, почему префикс #, прочитайте это.

(устарело) ES7 с оператором привязки

Предупреждение: предложение оператора связывания TC39 почти не работает https://github.com/tc39/proposal-bind-operator/issues/53#issuecomment-374271822

Оператор связывания :: - это ECMAScript предложение и реализовано в Babel (этап 0).

export default class MyObject {
  constructor (foo) {
    this._foo = foo;
  }

  publicFun () {
    return this::privateFun(">>");
  }
}

function privateFun (prefix) {
  return prefix + this._foo;
}

Возьмите любое из решений, соответствующих шаблону Крокфорда частный или привилегированный. Например:

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

Обратите внимание, что приведенный выше код является общим для всех типов конструкторов конфиденциальности. Это не сработает с некоторыми решениями здесь, но должно быть ясно, что практически все решения на основе замыканий могут быть сломаны таким образом с другими параметрами replace().

После этого любой объект, созданный с помощью new Foo(), будет иметь метод eval, который можно будет вызвать для возврата или изменения значений или методов, определенных в закрытии конструктора, например:

f = new Foo(99);
f.eval("x");
f.eval("y");
f.eval("x = 8");

Единственная проблема, которую я вижу в этом, заключается в том, что он не будет работать в случаях, когда есть только один экземпляр, и он создается при загрузке. Но тогда нет причин для фактического определения прототипа, и в этом случае злоумышленник может просто воссоздать объект вместо конструктора, если у него есть способ передачи тех же параметров (например, они являются постоянными или вычисляются из доступных значений).

На мой взгляд, это в значительной степени делает решение Крокфорда бесполезным. Поскольку «конфиденциальность» легко нарушается, недостатки его решения (снижение читабельности и ремонтопригодности, снижение производительности, увеличение памяти) делают метод, основанный на прототипе «без конфиденциальности», лучшим выбором.

Я обычно использую ведущие подчеркивания для обозначения методов и полей __private и _protected (стиль Perl), но идея обеспечения конфиденциальности в JavaScript просто показывает, насколько это неправильно понимаемый язык.

Поэтому я не согласен с Crockford, кроме его первого предложения.

Итак, как получить настоящую конфиденциальность в JS? Поместите все, что требуется для приватности на стороне сервера, и используйте JS для выполнения вызовов AJAX.

Вот что мне больше всего понравилось в отношении частных / общедоступных методов / членов и создания экземпляров в 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();

JSFiddle: http://jsfiddle.net/northkildonan/kopj3dt3/1/

Я знаю, что уже слишком поздно, но как насчет этого?

var obj = function(){
    var pr = "private";
    var prt = Object.getPrototypeOf(this);
    if (!prt.hasOwnProperty("showPrivate")){
        prt.showPrivate = function(){
            console.info(pr);
        }
    }    
}

var i = new obj();
i.showPrivate();
console.info(i.hasOwnProperty("pr"));

Шаблон модуля правильный в большинстве случаев. Но если у вас тысячи экземпляров, классы экономят память. Если экономия памяти вызывает беспокойство и ваши объекты содержат небольшой объем личных данных, но имеют много общедоступных функций, тогда вам нужно, чтобы все общедоступные функции находились в .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, и это известно только внутри основного замыкания.

Оберните весь код в анонимную функцию: тогда все функции будут закрытыми, ТОЛЬКО функции, прикрепленные к объекту 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();

FIDDLE

На этот вопрос уже есть много ответов, но мне ничего не подошло. Итак, я придумал собственное решение, надеюсь, оно кому-то пригодится:

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.info("your code goes here");
        }
    }
    publicMethode(){
        this.privateMethode();
    }
}

var obj = new Obj();
obj.publicMethode(); //logs "your code goes here"
obj.privateMethode(); //does nothing

Как видите, эта система работает при использовании этого типа классов в javascript. Насколько я понял, ни один из методов, прокомментированных выше, не работал.

Лично я предпочитаю следующий шаблон для создания классов в 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();

См. Также эта рабочий пример.

Я предпочитаю хранить личные данные в связанном 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};

Не будь таким многословным. Это Javascript. Используйте Соглашение об именовании.

После нескольких лет работы в классах es6 я недавно начал работу над проектом es5 (используя requireJS, который уже выглядит очень многословно). Я много раз повторял все упомянутые здесь стратегии, и все в основном сводится к использовать соглашение об именах:

1. В Javascript нет таких ключевых слов, как private. Другие разработчики, использующие Javascript, знают об этом заранее. Поэтому простого соглашения об именах более чем достаточно. Простое соглашение об именах с префиксом с подчеркиванием решает проблему как частных свойств, так и частных методов.
2. Давайте воспользуемся прототипом из соображений скорости, но не будем вдаваться в подробности. Давайте постараемся, чтобы «класс» es5 выглядел как можно ближе к тому, что мы могли бы ожидать в других языках программирования (и рассматривать каждый файл как класс, даже если нам не нужно возвращать экземпляр).
3. Давайте продемонстрируем более реалистичную ситуацию с модулем (мы будем использовать старый es5 и старый requireJs).

мой-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();
            }
            */
        }
    });

Теперь вы можете сделать это с помощью es10 частные методы. Вам просто нужно добавить # перед именем метода.

class ClassWithPrivateMethod {
  #privateMethod() {
    return 'hello world';
  }

  getPrivateMessage() {
    return #privateMethod();
  }
}

Уродливое решение, но оно работает:

function Class(cb) {
    const self = {};

    const constructor = (fn) => {
        func = fn;    
    };

    const addPrivate = (fnName, obj) => {
        self[fnName] = obj;
    }

    const addPublic = (fnName, obj) => {
        this[fnName] = obj;
        self[fnName] = obj;
        func.prototype[fnName] = obj;
    }
    
    cb(constructor, addPrivate, addPublic, self);
    return func;
}

const test = new Class((constructor, private, public, self) => {
    constructor(function (test) {
        console.info(test)
    });
    public('test', 'yay');
    private('qwe', 'nay');
    private('no', () => {
        return 'hello'
    })
    public('asd', () => {
        return 'this is public'
    })
    public('hello', () => {
        return self.qwe + self.no() + self.asd()
    })
})
const asd = new test('qweqwe');
console.info(asd.hello());

ES2021 / ES12 - Частные методы

Имена частных методов начинаются с префикса #, и к ним можно получить доступ Только внутри класса, в котором он определен.

class Restaurant {

  // private method
  #private_stuff() {
    console.info("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 года.

Старый вопрос, но это довольно простая задача, которую можно решить правильно с помощью основного JS ... без абстракции класса ES6. На самом деле, насколько я могу судить, абстракция класса даже не решает эту проблему.

Мы можем выполнить эту работу как с помощью старой доброй функции конструктора, так и даже лучше с помощью Object.create(). Сначала займемся конструктором. По сути, это будет решение, аналогичное ответ джорджброка, которое подвергается критике, потому что все рестораны, созданные конструктором 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.info(rest.callWaiter());
console.info(rest.askBill("beer", "beef"));

Теперь очевидно, что мы не можем получить доступ к menu извне, но мы можем легко переименовать свойство name ресторана.

Это также можно сделать с помощью Object.create(), и в этом случае мы пропускаем функцию конструктора и просто делаем как var rest = Object.create(prototypeFactory(menu)), а затем добавляем свойство name к объекту rest, например, rest.name = name.