Quand je lis cela, il sonnait comme un défi difficile j'ai donc décidé de trouver un moyen. Ce que je suis venu avec était SUIVANTES , mais il fonctionne tout à fait.
Tout d'abord, j'ai essayé la définition de la classe dans une mise en fonction immédiate donc, si vous voulez avoir accès à certaines des propriétés privées de la fonction. Cela fonctionne et vous permet d'obtenir certaines données privées, cependant, si vous essayez de définir les données privées que vous découvrirez bientôt que tous les objets partageront la même valeur.
var SharedPrivateClass = (function(){ // use immediate function
// our private data
var private = "Default";
// create the constructor
function SharedPrivateClass () {}
// add to the prototype
SharedPrivateClass.prototype.getPrivate = function () {
// It has access to private vars from the immediate function!
return private;
}
SharedPrivateClass.prototype.setPrivate = function (value) {
private = value;
}
return SharedPrivateClass;
})();
var a = new SharedPrivateClass();
console.log("a:", a.getPrivate()); // "a: Default"
var b = new SharedPrivateClass();
console.log("b:", b.getPrivate()); // "b: Default"
a.setPrivate("foo"); // a Sets private to 'foo'
console.log("a:", a.getPrivate()); // "a: foo"
console.log("b:", b.getPrivate()); // oh no, b.getPrivate() is 'foo'!
console.log(a.hasOwnProperty("getPrivate")); // false. belongs to the prototype
console.log(a.private); // undefined
Il y a beaucoup de cas où ce serait suffisant comme si vous vouliez ont des valeurs constantes, comme les noms d'événements qui seront partagées entre les instances. Mais, pour l'essentiel, ils agissent comme privé de variables statiques.
Si vous avez absolument besoin d'accéder à des variables dans un espace de noms privé à l'intérieur de vos méthodes définies dans le prototype, vous pouvez essayer ce modèle.
var PrivateNamespaceClass = (function(){ // immediate function
var instance = 0, // counts the number of instances
defaultName = "Default Name",
p = []; // an array of private objects
// careate the constructor
function PrivateNamespaceClass () {
// Increment the instance count and save it to the instance.
// This will become your key to your private space.
this.i = instance++;
// Create a new object in the private space.
p[this.i] = {};
// Define properties or methods in the private space.
p[this.i].name = defaultName;
console.log("New instance " + this.i);
}
PrivateNamespaceClass.prototype.getPrivateName = function () {
// It has access to the private space and it's children!
return p[this.i].name;
}
PrivateNamespaceClass.prototype.setPrivateName = function (value) {
// Because you use the instance number assigned to the object (this.i)
// as a key, the values set will not change in other instances.
p[this.i].name = value;
return "Set " + p[this.i].name;
}
return PrivateNamespaceClass;
})();
var a = new PrivateNamespaceClass();
console.log(a.getPrivateName()); // Default Name
var b = new PrivateNamespaceClass();
console.log(b.getPrivateName()); // Default Name
console.log(a.setPrivateName("A"));
console.log(b.setPrivateName("B"));
console.log(a.getPrivateName()); // A
console.log(b.getPrivateName()); // B
console.log(a.privateNamespace); // undefined
J'aimerais un retour d'expérience de quelqu'un qui voit une erreur avec cette manière de faire.
