private Funktionen in Object-Oriented JavaScript

Question

Wenn ich versuche, objektorientierten reinen JS mit privaten Methoden zu tun, ich die folgenden

(function(exports) { 

    var Foo = function(num) { 
    this.num = num 
    }; 

    var addTwo = function() { 
    this.num += 2; 
    }; 

    Foo.prototype.addFour = function() { 
    addTwo.call(this); 
    addTwo.call(this); 
    }; 

    exports.Foo = Foo; 

})(this); 

häufig tue Dann kann ich

var foo = new Foo(0); 
foo.addFour(); 
console.log(foo.num); // => 4 

Es tut fühlt sich sauber an und ermöglicht es mir, wirklich private Funktionen zu erstellen, anstatt ein Präfix _ zu verwenden, um anzuzeigen, dass eine Methode als privat behandelt werden sollte (aber tatsächlich nicht).

Damit kann ich wissen, welche Funktionen ich für Unit-Test benötige und welche nicht. Es hindert mich auch daran, versucht zu werden, Funktionen zu benutzen, die privat sein sollten. Aber ich sehe dieses Muster nicht woanders.

Warum also nicht andere dieses Muster verwenden und was tun sie stattdessen?

Answer 1

Viele Menschen tun das. Es ist etwas formal bekannt als Revealing Module Pattern.

---

Vorteile

• Reiniger Ansatz für Entwickler
• Unterstützen private Daten
• Weniger Unordnung im globalen Namespace
• Lokalisierung von Funktionen und Variablen durch Schließungen
• Die Syntax unserer Skripte sind noch mehr Nachteile istent
• Explizit definierte öffentliche Methoden und Variablen, die zu einer erhöhten Lesbarkeit führen

Nachteile

• Private Methoden sind unaccessible.
• Manche Leute sagen, dass dies zur Unfähigkeit der Komponententests führt, aber meistens, wenn Sie die Integrität einer Funktion in Frage stellen, sollte sie so konstruiert werden, dass der Nutzen dieser Funktion öffentlich sichtbar wird. damit ist es testbar. Angesichts der Anpassung des Modulmusters durch jQuery und deren alltäglichen Verwendung von QUnit zur Automatisierung des Testens ist dieser Aufzählungspunkt nicht wirklich relevant, wird aber dennoch zu Dokumentationszwecken aufgeführt.
• Private Methoden und Funktionen verlieren die Erweiterbarkeit, da sie nicht zugänglich sind (siehe meinen Kommentar im vorherigen Aufzählungspunkt).
• Es ist schwieriger, öffentliche Methoden und Variablen zu patchen, auf die sich etwas Privates bezieht.

Answer 2

Es gibt keine Zugriffsmodifikatoren (privat, geschützt, public) in JavaScript, aber Sie können Ihre Objekte so , dass einige Variablen und Methoden zugegriffen Won`t von außen erstellen.

var ExampleObject = function() { 
 
    var privateVariable = "I am Private Variable" // this variable can be accessed only in ExampleObject instance; 
 

 
    this.publicVariable = "I am Public Variable" // this way you can access variable from outside; 
 

 
    // NOW FOR METHODS 
 

 
    // this method only could be accessed inside instance of ExampleObject 
 
    var privateFunction = function() { 
 
    return "I am Private Function"; 
 
    } 
 

 
    // this method could be accessed outside and inside instance of ExampleObject 
 
    // also notice that this method can return private variables or functions of instance to outside of instance 
 
    this.publicFunction = function() { 
 
    alert(privateFunction()) 
 
    return privateVariable; 
 
    } 
 
} 
 

 
var instanceExample = new ExampleObject(); 
 
<!-- alert(instanceExample.privateFunction()) // will throw Uncaught TypeError: instanceExample.privateFunction is not a function --> 
 

 
alert(instanceExample.publicFunction())