Accès privé à des variables de membre du prototype des fonctions définies par l'

Non, il n'y a aucun moyen de le faire. Que serait essentiellement portée dans le sens inverse.

Méthodes définies à l'intérieur du constructeur ont accès aux variables privées parce que toutes les fonctions ont accès à de l'étendue dans laquelle ils ont été définis.

Les méthodes définies sur un prototype ne sont pas définis dans le champ d'application du constructeur, et n'auront pas accès à l'constructeur de variables locales.

Vous pouvez toujours avoir des variables privées, mais si vous voulez des méthodes définies dans le prototype d'y avoir accès, vous devez définir des accesseurs et mutateurs sur le this objet, dont le prototype des méthodes (avec tout le reste) sera ont accès. Par exemple:

function Person(name, secret) {
    //public
    this.name = name;

    //private
    var secret = secret;

    //public methods have access to private members
    this.setSecret = function(s) {
        secret = s;
    }

    this.getSecret = function() {
        return secret;
    }
}

//Must use getters/setters 
Person.prototype.spillSecret = function() { alert(this.getSecret()); };

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.

JS:

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

//getPrivate() is only created once and instanceof still works
console.log(a.getPrivate === b.getPrivate);
console.log(a instanceof SharedPrivateClass);
console.log(b instanceof SharedPrivateClass);

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.

JS:

var PrivateNamespaceClass = (function() { //immediate function
var instance = 0, //counts the number of instances
defaultName = "Default Name",  
p = []; //an array of private objects
//create 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
//private objects are not accessible outside the PrivateNamespaceClass function
console.log(a.p);
//the prototype functions are not re-created for each instance
//and instanceof still works
console.log(a.getPrivateName === b.getPrivateName);
console.log(a instanceof PrivateNamespaceClass);
console.log(b instanceof PrivateNamespaceClass);

J'aimerais un retour d'expérience de quelqu'un qui voit une erreur avec cette manière de faire.

Je suggère qu'elle serait probablement une bonne idée de décrire "avoir un prototype d'affectation dans un constructeur" Javascript anti-modèle. Pensez à ce sujet. Il est trop risqué.

Ce que vous êtes en train de faire, là, sur la création de la deuxième objet (c-b) est en train de redéfinir ce prototype de fonction pour tous les objets qui utilisent ce prototype. Cela aura pour effet de réinitialiser la valeur de l'objet a dans votre exemple. Il ne fonctionnera que si vous voulez une variable partagée et si vous arriver à créer toutes les instances de l'objet à l'avant, mais il est bien trop risqué.

J'ai trouvé un bug dans un peu de Javascript (je travaillais récemment que c'était pour cette raison exacte de l'anti-modèle. Il tente de mettre un glisser-déposer de gestionnaire de la particularité de l'objet en cours de création mais plutôt de le faire pour toutes les instances. Pas bonne.

Doug Crockford solution est la meilleure.

Oui, c'est possible. PPF modèle de conception juste résout ce problème.

PPF représente Privé Prototype des Fonctions. De base PPF résout ces problèmes:

1. Prototype des fonctions d'obtenir l'accès à des privés de données de l'instance.
2. Prototype les fonctions peuvent être privés.

Pour la première, tout:

1. Mettre toutes les variables d'instance, vous voulez être accessible à partir de prototypes de fonctions à l'intérieur d'une autre conteneur, et
2. Passer une référence au conteneur de données de tous les prototypes de fonctions en tant que paramètre.

C'est aussi simple que cela. Par exemple:

//Helper class to store private data.
function Data() {};
//Object constructor
function Point(x, y)
{
//container for private vars: all private vars go here
//we want x, y be changeable via methods only
var data = new Data;
data.x = x;
data.y = y;
...
}
//Prototype functions now have access to private instance data
Point.prototype.getX = function(data)
{
return data.x;
}
Point.prototype.getY = function(data)
{
return data.y;
}

...

Lisez l'histoire complète ici:

PPF Modèle de Conception

Dans le courant de JavaScript, je suis assez certain qu'il y a un et un seul moyen d'avoir privé de l'état, accessible à partir de prototype fonctions, sans rien ajouter public à this. La réponse est d'utiliser la "faiblesse de la carte" modèle.

Pour résumer: Le Person de classe a qu'une seule faiblesse de la carte, où les clés sont les instances de la Personne, et les valeurs sont des objets simples qui sont utilisés pour le stockage privé.

Ici, c'est un exemple: (jouer à http://jsfiddle.net/ScottRippey/BLNVr/)

var Person = (function() {
var _ = weakMap();
//Now, _(this) returns an object, used for private storage.
var Person = function(first, last) {
//Assign private storage:
_(this).firstName = first;
_(this).lastName = last;
}
Person.prototype = {
fullName: function() {
//Retrieve private storage:
return _(this).firstName + _(this).lastName;
},
firstName: function() {
return _(this).firstName;
},
destroy: function() {
//Free up the private storage:
_(this, true);
}
};
return Person;
})();
function weakMap() {
var instances=[], values=[];
return function(instance, destroy) {
var index = instances.indexOf(instance);
if (destroy) {
//Delete the private state:
instances.splice(index, 1);
return values.splice(index, 1)[0];
} else if (index === -1) {
//Create the private state:
instances.push(instance);
values.push({});
return values[values.length - 1];
} else {
//Return the private state:
return values[index];
}
};
}

Comme je l'ai dit, c'est vraiment la seule façon d'atteindre tous les 3 parties.

Il y a deux mises en garde, cependant. Tout d'abord, les coûts de cette représentation, chaque fois que vous accédez à des données privées, c'est un O(n) opération, où n est le nombre d'instances. Si vous ne voulez pas le faire si vous avez un grand nombre de cas.
Deuxièmement, lorsque vous en avez terminé avec une instance, vous devez appeler destroy; sinon, l'instance et les données ne seront pas nettoyés, et vous vous retrouverez avec une fuite de mémoire.

Et c'est pourquoi ma réponse originale à cette question, "Vous ne devriez pas", est quelque chose que j'aimerais tenir.

Essayer!

    function Potatoe(size) {
var _image = new Image();
_image.src = 'potatoe_'+size+'.png';
function getImage() {
if (getImage.caller == null || getImage.caller.owner != Potatoe.prototype)
throw new Error('This is a private property.');
return _image;
}
Object.defineProperty(this,'image',{
configurable: false,
enumerable: false,
get : getImage          
});
Object.defineProperty(this,'size',{
writable: false,
configurable: false,
enumerable: true,
value : size            
});
}
Potatoe.prototype.draw = function(ctx,x,y) {
//ctx.drawImage(this.image,x,y);
console.log(this.image);
}
Potatoe.prototype.draw.owner = Potatoe.prototype;
var pot = new Potatoe(32);
console.log('Potatoe size: '+pot.size);
try {
console.log('Potatoe image: '+pot.image);
} catch(e) {
console.log('Oops: '+e);
}
pot.draw();

Il y a un moyen très simple de faire ce

function SharedPrivate(){
var private = "secret";
this.constructor.prototype.getP = function(){return private}
this.constructor.prototype.setP = function(v){ private = v;}
}
var o1 = new SharedPrivate();
var o2 = new SharedPrivate();
console.log(o1.getP()); //secret
console.log(o2.getP()); //secret
o1.setP("Pentax Full Frame K1 is on sale..!");
console.log(o1.getP()); //Pentax Full Frame K1 is on sale..!
console.log(o2.getP()); //Pentax Full Frame K1 is on sale..!
o2.setP("And it's only for $1,795._");
console.log(o1.getP()); //And it's only for $1,795._

JavaScript prototypes sont d'or.

Voici quelque chose que je suis venu avec tout en essayant de trouver la plus simple solution de ce problème, peut-être il pourrait être utile à quelqu'un. Je suis nouveau sur le javascript, donc il pourrait bien y avoir quelques problèmes avec le code.

//pseudo-class definition scope
(function () {
//this is used to identify 'friend' functions defined within this scope,
//while not being able to forge valid parameter for GetContext() 
//to gain 'private' access from outside
var _scope = new (function () { })();
//-----------------------------------------------------------------
//pseudo-class definition
this.Something = function (x) {
//'private' members are wrapped into context object,
//it can be also created with a function
var _ctx = Object.seal({
//actual private members
Name: null,
Number: null,
Somefunc: function () {
console.log('Something(' + this.Name + ').Somefunc(): number = ' + this.Number);
}
});
//-----------------------------------------------------------------
//function below needs to be defined in every class
//to allow limited access from prototype
this.GetContext = function (scope) {
if (scope !== _scope) throw 'access';
return _ctx;
}
//-----------------------------------------------------------------
{
//initialization code, if any
_ctx.Name = (x !== 'undefined') ? x : 'default';
_ctx.Number = 0;
Object.freeze(this);
}
}
//-----------------------------------------------------------------
//prototype is defined only once
this.Something.prototype = Object.freeze({
//public accessors for 'private' field
get Number() { return this.GetContext(_scope).Number; },
set Number(v) { this.GetContext(_scope).Number = v; },
//public function making use of some private fields
Test: function () {
var _ctx = this.GetContext(_scope);
//access 'private' field
console.log('Something(' + _ctx.Name + ').Test(): ' + _ctx.Number);
//call 'private' func
_ctx.Somefunc();
}
});
//-----------------------------------------------------------------
//wrap is used to hide _scope value and group definitions
}).call(this);
function _A(cond) { if (cond !== true) throw new Error('assert failed'); }
//-----------------------------------------------------------------
function test_smth() {
console.clear();
var smth1 = new Something('first'),
smth2 = new Something('second');
//_A(false);
_A(smth1.Test === smth2.Test);
smth1.Number = 3;
smth2.Number = 5;
console.log('smth1.Number: ' + smth1.Number + ', smth2.Number: ' + smth2.Number);
smth1.Number = 2;
smth2.Number = 6;
smth1.Test();
smth2.Test();
try {
var ctx = smth1.GetContext();
} catch (err) {
console.log('error: ' + err);
}
}
test_smth();

var getParams = function(_func) {
res = _func.toString().split('function (')[1].split(')')[0].split(',')
return res
}
function TestClass(){
var private = {hidden: 'secret'}
//clever magic accessor thing goes here
if ( !(this instanceof arguments.callee) ) {
for (var key in arguments) {
if (typeof arguments[key] == 'function') {
var keys = getParams(arguments[key])
var params = []
for (var i = 0; i <= keys.length; i++) {
if (private[keys[i]] != undefined) {
params.push(private[keys[i]])
}
}
arguments[key].apply(null,params)
}
}
}
}
TestClass.prototype.test = function(){
var _hidden; //variable I want to get
TestClass(function(hidden) {_hidden = hidden}) //invoke magic to get
};
new TestClass().test()

Comment est-ce? À l'aide d'un accesseur privé. Seulement vous permet d'obtenir les variables mais pas pour les régler, dépend du cas d'utilisation.

A joué avec cela aujourd'hui et c'était la seule solution que j'ai pu trouver sans l'aide de Symboles. La meilleure chose à ce sujet est qu'il peut effectivement être tous totalement privé.

La solution est basée autour d'un domaine chargeur de module qui, fondamentalement, devient le médiateur pour un stockage privé de cache (à l'aide d'une faiblesse de la carte).

   const loader = (function() {
function ModuleLoader() {}
//Static, accessible only if truly needed through obj.constructor.modules
//Can also be made completely private by removing the ModuleLoader prefix.
ModuleLoader.modulesLoaded = 0;
ModuleLoader.modules = {}
ModuleLoader.prototype.define = function(moduleName, dModule) {
if (moduleName in ModuleLoader.modules) throw new Error('Error, duplicate module');
const module = ModuleLoader.modules[moduleName] = {}
module.context = {
__moduleName: moduleName,
exports: {}
}
//Weak map with instance as the key, when the created instance is garbage collected or goes out of scope this will be cleaned up.
module._private = {
private_sections: new WeakMap(),
instances: []
};
function private(action, instance) {
switch (action) {
case "create":
if (module._private.private_sections.has(instance)) throw new Error('Cannot create private store twice on the same instance! check calls to create.')
module._private.instances.push(instance);
module._private.private_sections.set(instance, {});
break;
case "delete":
const index = module._private.instances.indexOf(instance);
if (index == -1) throw new Error('Invalid state');
module._private.instances.slice(index, 1);
return module._private.private_sections.delete(instance);
break;
case "get":
return module._private.private_sections.get(instance);
break;
default:
throw new Error('Invalid action');
break;
}
}
dModule.call(module.context, private);
ModuleLoader.modulesLoaded++;
}
ModuleLoader.prototype.remove = function(moduleName) {
if (!moduleName in (ModuleLoader.modules)) return;
/*
Clean up as best we can.
*/
const module = ModuleLoader.modules[moduleName];
module.context.__moduleName = null;
module.context.exports = null;
module.cotext = null;
module._private.instances.forEach(function(instance) { module._private.private_sections.delete(instance) });
for (let i = 0; i < module._private.instances.length; i++) {
module._private.instances[i] = undefined;
}
module._private.instances = undefined;
module._private = null;
delete ModuleLoader.modules[moduleName];
ModuleLoader.modulesLoaded -= 1;
}
ModuleLoader.prototype.require = function(moduleName) {
if (!(moduleName in ModuleLoader.modules)) throw new Error('Module does not exist');
return ModuleLoader.modules[moduleName].context.exports;
}
return new ModuleLoader();
})();
loader.define('MyModule', function(private_store) {
function MyClass() {
//Creates the private storage facility. Called once in constructor.
private_store("create", this);
//Retrieve the private storage object from the storage facility.
private_store("get", this).no = 1;
}
MyClass.prototype.incrementPrivateVar = function() {
private_store("get", this).no += 1;
}
MyClass.prototype.getPrivateVar = function() {
return private_store("get", this).no;
}
this.exports = MyClass;
})
//Get whatever is exported from MyModule
const MyClass = loader.require('MyModule');
//Create a new instance of `MyClass`
const myClass = new MyClass();
//Create another instance of `MyClass`
const myClass2 = new MyClass();
//print out current private vars
console.log('pVar = ' + myClass.getPrivateVar())
console.log('pVar2 = ' + myClass2.getPrivateVar())
//Increment it
myClass.incrementPrivateVar()
//Print out to see if one affected the other or shared
console.log('pVar after increment = ' + myClass.getPrivateVar())
console.log('pVar after increment on other class = ' + myClass2.getPrivateVar())
//Clean up.
loader.remove('MyModule')

ES6 WeakMaps

À l'aide d'un modèle simple, basé à ES6 WeakMaps est possible d'obtenir des variables de membre privé, accessible depuis le prototype des fonctions.

Remarque : L'utilisation de WeakMaps garanties de sécurité contre les fuites de mémoire, en laissant le Garbage Collector d'identifier et d'ignorer des instances inutilisées.

JS:

//Create a private scope using an Immediately 
//Invoked Function Expression...
let Person = (function() {
//Create the WeakMap that will hold each  
//Instance collection's of private data
let privateData = new WeakMap();
//Declare the Constructor :
function Person(name) {
//Insert the private data in the WeakMap,
//using 'this' as a unique acces Key
privateData.set(this, { name: name });
}
//Declare a prototype method 
Person.prototype.getName = function() {
//Because 'privateData' is in the same 
//scope, it's contents can be retrieved...
//by using  again 'this' , as  the acces key 
return privateData.get(this).name;
};
//return the Constructor
return Person;
}());

Une explication plus détaillée de ce modèle peut être trouvé ici

Vous pouvez aussi essayer d'ajouter une méthode pas directement sur le prototype, mais sur la fonction de constructeur comme ceci:

var MyArray = function() {
var array = [];
this.add = MyArray.add.bind(null, array);
this.getAll = MyArray.getAll.bind(null, array);
}
MyArray.add = function(array, item) {
array.push(item);
}
MyArray.getAll = function(array) {
return array;
}
var myArray1 = new MyArray();
myArray1.add("some item 1");
console.log(myArray1.getAll()); //['some item 1']
var myArray2 = new MyArray();
myArray2.add("some item 2");
console.log(myArray2.getAll()); //['some item 2']
console.log(myArray1.getAll()); //['some item 2'] - FINE!

Vous pouvez utiliser un prototype d'affectation dans le constructeur de la définition.

La variable sera visible pour le prototype ajout de la méthode, mais de toutes les instances de l'fonctions auront accès à la même variable PARTAGÉE.

function A()
{
var sharedVar = 0;
this.local = "";
A.prototype.increment = function(lval)
{    
if (lval) this.local = lval;    
alert((++sharedVar) + " while this.p is still " + this.local);
}
}
var a = new A();
var b = new A();    
a.increment("I belong to a");
b.increment("I belong to b");
a.increment();
b.increment();

J'espère que cela peut être utile.