Um eine JavaScript-Klasse mit einer öffentlichen Methode zu erstellen, würde ich Folgendes tun:

function Restaurant() {}

Restaurant.prototype.buy_food = function(){
   // something here
}

Restaurant.prototype.use_restroom = function(){
   // something here
}

Auf diese Weise können Benutzer meiner Klasse:

var restaurant = new Restaurant();
restaurant.buy_food();
restaurant.use_restroom();

Wie erstelle ich eine private Methode, die von den Methoden buy_foodund aufgerufen werden use_restroomkann, jedoch nicht extern von Benutzern der Klasse?

Mit anderen Worten, ich möchte, dass meine Methodenimplementierung Folgendes kann:

Restaurant.prototype.use_restroom = function() {
   this.private_stuff();
}

Das sollte aber nicht funktionieren:

var r = new Restaurant();
r.private_stuff();

Wie definiere ich private_stuffeine private Methode, damit beide zutreffen?

Ich habe Doug Crockfords Artikel einige Male gelesen, aber es scheint nicht, dass "private" Methoden von öffentlichen Methoden aufgerufen werden können und "privilegierte" Methoden extern aufgerufen werden können.

Sie können es tun, aber der Nachteil ist, dass es nicht Teil des Prototyps sein kann:

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

Verwenden der selbstaufrufenden Funktion und des Aufrufs

JavaScript verwendet Prototypen und verfügt nicht über Klassen (oder Methoden) wie objektorientierte Sprachen. Ein JavaScript-Entwickler muss in JavaScript denken.

Wikipedia-Zitat:

Im Gegensatz zu vielen objektorientierten Sprachen gibt es keinen Unterschied zwischen einer Funktionsdefinition und einer Methodendefinition. Die Unterscheidung erfolgt vielmehr während des Funktionsaufrufs; Wenn eine Funktion als Methode eines Objekts aufgerufen wird, ist das lokale Schlüsselwort this der Funktion für diesen Aufruf an dieses Objekt gebunden.

Lösung mit einer selbstaufrufenden Funktion und der Aufruffunktion zum Aufrufen der privaten "Methode":

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

Mit der Aufruffunktion können wir die private Funktion mit dem entsprechenden Kontext aufrufen ( this).

Einfacher mit Node.js.

Wenn Sie node.js verwenden , benötigen Sie das IIFE nicht, da Sie das Modulladesystem nutzen können :

function MyObject (foo) {
    this._foo = foo;
}

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

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

exports.MyObject = MyObject;

Laden Sie die Datei:

var MyObject = require('./MyObject').MyObject;

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

(experimentell) ES7 mit dem Bind Operator

Der Bindungsoperator ::ist ein ECMAScript- Vorschlag und wird in Babel implementiert ( Stufe 0 ).

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

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

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

Laden Sie die Datei:

import MyObject from './MyObject';

let myObject = new MyObject('bar');
myObject.publicFun();      // Returns '>>bar'
myObject.privateFun('>>'); // TypeError: myObject.privateFun is not a function

Sie können private Methoden wie folgt simulieren:

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

Weitere Informationen zu dieser Technik finden Sie hier: http://webreflection.blogspot.com/2008/04/natural-javascript-private-methods.html

In diesen Situationen, in denen Sie eine öffentliche API haben und private und öffentliche Methoden / Eigenschaften wünschen, verwende ich immer das Modulmuster. Dieses Muster wurde in der YUI-Bibliothek populär gemacht. Die Details finden Sie hier:

http://yuiblog.com/blog/2007/06/12/module-pattern/

Es ist wirklich einfach und für andere Entwickler leicht zu verstehen. Ein einfaches Beispiel:

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

Hier ist die Klasse, die ich erstellt habe, um zu verstehen, was Douglas Crockford auf seiner Website Private Members in JavaScript vorgeschlagen hat

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

}

Ich habe das heraufbeschworen: EDIT: Eigentlich hat sich jemand mit einer identischen Lösung verbunden. Duh!

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

Ich denke, solche Fragen tauchen immer wieder auf, weil die Schließungen nicht verstanden wurden. Verschlüsse sind das Wichtigste in JS. Jeder JS-Programmierer muss die Essenz davon spüren.

1. Zunächst müssen wir einen separaten Geltungsbereich festlegen (Abschluss).

function () {

}

2. In diesem Bereich können wir tun, was wir wollen. Und niemand wird davon erfahren.

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. Damit die Welt etwas über unsere Restaurantklasse weiß, müssen wir sie von der Schließung zurückgeben.

var Restaurant = (function () {
    // Restaurant definition
    return Restaurant
})()

4. Am Ende haben wir:

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. Dieser Ansatz bietet auch Potenzial für Vererbung und Vorlagen

// 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')

Ich hoffe, das hilft jemandem, dieses Thema besser zu verstehen

Persönlich bevorzuge ich das folgende Muster zum Erstellen von Klassen in 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(); }
        ...
    };
})();

Wie Sie sehen, können Sie sowohl Klasseneigenschaften als auch Instanzeigenschaften definieren, von denen jede öffentlich und privat sein kann.

Demo

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

Siehe auch diese Geige .

All diese Schließung kostet Sie. Stellen Sie sicher, dass Sie die Auswirkungen auf die Geschwindigkeit insbesondere im Internet Explorer testen. Sie werden feststellen, dass Sie mit einer Namenskonvention besser dran sind. Es gibt immer noch viele Webbenutzer in Unternehmen, die gezwungen sind, IE6 zu verwenden ...

Sei nicht so wortreich. Es ist Javascript. Verwenden Sie eine Namenskonvention .

Nachdem ich jahrelang in es6-Klassen gearbeitet habe, habe ich kürzlich begonnen, an einem es5-Projekt zu arbeiten (mit requireJS, das bereits sehr ausführlich aussieht). Ich habe alle hier genannten Strategien immer wieder wiederholt und alles läuft im Grunde darauf hinaus, eine Namenskonvention zu verwenden :

1. Javascript hat keine Scope-Schlüsselwörter wie private. Andere Entwickler, die Javascript eingeben, wissen dies im Voraus. Daher ist eine einfache Namenskonvention mehr als ausreichend. Eine einfache Namenskonvention zum Präfixieren eines Unterstrichs löst das Problem sowohl privater Eigenschaften als auch privater Methoden.
2. Lassen Sie uns den Prototyp aus Geschwindigkeitsgründen nutzen, aber nicht ausführlicher. Lassen Sie uns versuchen, die es5 "Klasse" so genau wie möglich in anderen Backend-Sprachen zu betrachten (und jede Datei als Klasse zu behandeln, auch wenn wir keine Instanz zurückgeben müssen).
3. Lassen Sie uns mit einer realistischeren Modulsituation demonstrieren (wir werden alte es5- und alte requireJs verwenden).

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

Sie können dies jetzt mit privaten es10-Methoden tun . Sie müssen nur ein #vor dem Methodennamen einfügen.

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

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

Nehmen Sie eine der Lösungen, die Crockfords privatem oder privilegiertem Muster folgen . Zum Beispiel:

function Foo(x) {
    var y = 5;
    var bar = function() {
        return y * x;
    };

    this.public = function(z) {
        return bar() + x * z;
    };
}

In jedem Fall, in dem der Angreifer kein "Ausführungsrecht" im JS-Kontext hat, hat er keine Möglichkeit, auf "öffentliche" oder "private" Felder oder Methoden zuzugreifen. Falls der Angreifer diesen Zugriff hat, kann er diesen Einzeiler ausführen:

eval("Foo = " + Foo.toString().replace(
    /{/, "{ this.eval = function(code) { return eval(code); }; "
));

Beachten Sie, dass der obige Code für alle Konstruktortyp-Datenschutzdaten generisch ist. Bei einigen der hier aufgeführten Lösungen wird dies fehlschlagen, aber es sollte klar sein, dass so gut wie alle auf Verschlüssen basierenden Lösungen auf unterschiedliche Weise auf diese Weise beschädigt werden könnenreplace() Parametern auf beschädigt werden können.

Nachdem dies ausgeführt wurde, verfügt jedes mit erstellte Objekt new Foo()über eine evalMethode, die aufgerufen werden kann, um Werte oder Methoden zurückzugeben oder zu ändern, die im Abschluss des Konstruktors definiert sind, z.

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

Das einzige Problem, das ich dabei sehen kann, ist, dass es in Fällen, in denen es nur eine Instanz gibt und die beim Laden erstellt wird, nicht funktioniert. Es gibt jedoch keinen Grund, einen Prototyp tatsächlich zu definieren. In diesem Fall kann der Angreifer das Objekt anstelle des Konstruktors einfach neu erstellen, solange er die Möglichkeit hat, dieselben Parameter zu übergeben (z. B. sind sie konstant oder werden aus verfügbaren Werten berechnet).

Meiner Meinung nach macht dies Crockfords Lösung ziemlich nutzlos.Da die "Privatsphäre" leicht verletzt werden kann, sind die Nachteile seiner Lösung (verminderte Lesbarkeit und Wartbarkeit, verminderte Leistung, mehr Speicher) die prototypbasierte Methode "keine Privatsphäre" die bessere Wahl.

Normalerweise verwende ich führende Unterstriche zum Markieren __privateund für _protectedMethoden und Felder (Perl-Stil), aber die Idee, Datenschutz in JavaScript zu haben, zeigt nur, dass es sich um eine missverstandene Sprache handelt.

Daher bin ich mit Crockford bis auf seinen ersten Satz nicht einverstanden .

Wie erhalten Sie echte Privatsphäre in JS? Stellen Sie alles, was erforderlich ist, um privat zu sein, auf die Serverseite und verwenden Sie JS, um AJAX-Aufrufe auszuführen.

Die Apotheose des Modulmusters: Das aufschlussreiche Modulmuster

Eine nette kleine Erweiterung zu einem sehr robusten Muster.

Wenn Sie alle öffentlichen und privaten Funktionen mit der Möglichkeit für öffentliche Funktionen nutzen möchten, auf private Funktionen zuzugreifen, geben Sie den Layoutcode für ein Objekt wie das folgende ein:

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

Ähnlich wie Georgebrock, aber etwas weniger ausführlich (IMHO) Haben Sie Probleme damit? (Ich habe es nirgendwo gesehen)

edit: Mir wurde klar, dass dies irgendwie nutzlos ist, da jede unabhängige Instanziierung eine eigene Kopie der öffentlichen Methoden hat, was die Verwendung des Prototyps untergräbt.

Folgendes hat mir bisher am besten gefallen in Bezug auf private / öffentliche Methoden / Mitglieder und Instanziierung in Javascript:

Hier ist der Artikel: http://www.sefol.com/?p=1090

und hier ist das Beispiel:

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/

Das Modulmuster ist in den meisten Fällen richtig. Wenn Sie jedoch Tausende von Instanzen haben, sparen Klassen Speicher. Wenn das Speichern von Speicher ein Problem darstellt und Ihre Objekte eine kleine Menge privater Daten enthalten, aber viele öffentliche Funktionen haben, möchten Sie, dass alle öffentlichen Funktionen im Prototyp gespeichert werden, um Speicher zu sparen.

Das habe ich mir ausgedacht:

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

Das Objekt priventhält private Eigenschaften. Der Zugriff ist über die öffentliche Funktion möglich getPriv(). Diese Funktion wird jedoch zurückgegeben, falsesofern Sie sie nicht übergeben. secretDies ist nur innerhalb des Hauptabschlusses bekannt.

Was ist damit?

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;

})();

Die Suche nach privaten Variablen ist außerhalb des Bereichs der unmittelbaren Funktion nicht möglich. Es gibt keine doppelten Funktionen, wodurch Speicherplatz gespart wird.

Der Nachteil ist, dass die Suche nach privaten Variablen klobig privateVars[this.id].cookedist und lächerlich zu tippen ist. Es gibt auch eine zusätzliche "id" -Variable.

Wickeln Sie den gesamten Code in die anonyme Funktion: Dann sind alle Funktionen privat und NUR mit Funktionen verbunden window Objekt :

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

Benutze das :

  var abdennour=new Person('Abdennour');
  abdennour.profilePublic();

GEIGE

Ich bevorzuge es, private Daten in einem zugehörigen zu speichern WeakMap. Auf diese Weise können Sie Ihre öffentlichen Methoden auf dem Prototyp belassen, zu dem sie gehören. Dies scheint der effizienteste Weg zu sein, um dieses Problem für eine große Anzahl von Objekten zu lösen.

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

Private Funktionen können nicht über das Modulmuster auf die öffentlichen Variablen zugreifen

Da jeder hier seinen eigenen Code gepostet hat, werde ich das auch tun ...

Ich mag Crockford, weil er echte objektorientierte Muster in Javascript eingeführt hat. Aber er hatte auch ein neues Missverständnis, das "das".

Warum benutzt er "das = das"? Es hat überhaupt nichts mit privaten Funktionen zu tun. Es hat mit inneren Funktionen zu tun!

Denn laut Crockford ist dies ein fehlerhafter Code:

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

Also schlug er Folgendes vor:

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

Wie gesagt, ich bin mir ziemlich sicher, dass Crockford seine Erklärung zu diesem und jenem falsch war (aber sein Code ist sicherlich korrekt). Oder hat er nur die Javascript-Welt zum Narren gehalten, um zu wissen, wer seinen Code kopiert? Ich weiß nicht ... Ich bin kein Browser-Geek; D.

BEARBEITEN

Ah, darum geht es: Was bedeutet 'var that = this'? meine in JavaScript?

Also war Crockie wirklich falsch mit seiner Erklärung ... aber richtig mit seinem Code, also ist er immer noch ein großartiger Kerl. :))

Im Allgemeinen habe ich das private Objekt _ vorübergehend zum Objekt hinzugefügt. Sie müssen den Datenschutz exklusiv im "Power-Konstruktor" für die Methode öffnen. Wenn Sie die Methode vom Prototyp aus aufrufen, können Sie die Prototypmethode überschreiben

• Machen Sie eine öffentliche Methode im "Power-Konstruktor" zugänglich: (ctx ist der Objektkontext)

  ctx.test = GD.Fabric.open('test', GD.Test.prototype, ctx, _); // is a private object

• Jetzt habe ich diese openPrivacy:

  GD.Fabric.openPrivacy = function(func, clss, ctx, _) {
      return function() {
          ctx._ = _;
          var res = clss[func].apply(ctx, arguments);
          ctx._ = null;
          return res;
      };
  };

Das habe ich herausgefunden:

Benötigt eine Klasse von Zuckercode, die Sie hier finden können . Unterstützt auch geschützte, vererbbare, virtuelle, statische ...

;( 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'

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

https://github.com/nooning/JSClass

Ich habe ein neues Tool erstellt, mit dem Sie echte private Methoden für den Prototyp https://github.com/TremayneChrist/ProtectJS verwenden können

Beispiel:

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

Sie müssen Ihre eigentliche Konstruktorfunktion schließen, um Ihre privaten Methoden zu definieren. Um Daten der Instanzen durch diese privaten Methoden zu ändern, müssen Sie ihnen "dies" geben, entweder als Funktionsargument oder indem Sie diese Funktion mit .apply (this) aufrufen:

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

Ich weiß, dass es etwas zu spät ist, aber wie wäre es damit?

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

Es gibt bereits viele Antworten auf diese Frage, aber nichts entsprach meinen Bedürfnissen. Also habe ich meine eigene Lösung gefunden, ich hoffe, sie ist für jemanden nützlich:

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

Wie Sie sehen können, funktioniert dieses System, wenn diese Art von Klassen in Javascript verwendet wird. Soweit ich herausgefunden habe, hat keine der oben kommentierten Methoden dies getan.

In dieser Antwort finden Sie eine saubere und einfache "Klassen" -Lösung mit einer privaten und öffentlichen Schnittstelle und Unterstützung für die Komposition