Allega dinamicamente una funzione per concedere l'accesso alle variabili private

Question

Sto cercando di assegnare dinamicamente un callback a un mio oggetto, non riesco a trovare un modo per farlo garantendo a questa funzione l'accesso alle variabili private.Di seguito ho elencato il codice pertinente con i commenti in cui mi sono imbattuto in muri.

Fabbrica di oggetti

function makeObj ( o ) {
                function F() {}
                F.prototype = o;
                return new F();
            }

Modulo

var MODULE = (function(){
   var myMod = {},
       privateVar = "I'm private";
   return myMod;
})();

Vari tentativi

---

myMod.someDynamicFunc = function someDynamicFunc(){
    //privateVar === undefined;
    alert( privateVar );
}
myMod.someDynamicFunc();

---

myMod.prototype.someDynamicFunc = function someDynamicFunc(){
    //ERROR: Cannot set property 'someDynamicFunc' of undefined
    alert(privateVar);
}
myMod.someDynamicFunc();

---

In questo tentativo ho provato a creare un setter nell'oggetto module...inutilmente.

var MODULE = (function(){
       var myMod = {},
           privateVar = "I'm private";

           myMod.setDynamicFunction = function ( func ){
              if(func !== undefined && typeof func === "function"){
                //Uncaught TypeError: 
                //         Cannot read property 'dynamicFunction' of undefined
                myMod.prototype.dynamicFunction = func;
                //also tried myMod.dynamicFunction = func;
              }
           }
       return myMod;
    })();

var myModule = makeObject( MODULE );

myModule.setDynamicFunction(function(){
   alert(privateVar);
});

myModule.dynamicFunction();

---

Sto semplicemente usando JavaScript in modo sbagliato?Mi piacerebbe davvero poter assegnare callback dopo l'avvio dell'oggetto.È possibile?

Answer 1

Non è possibile accedere alla variabile privata attraverso una serie funzione di callback in modo dinamico (dato che non può essere una chiusura se è attaccato più tardi), ma è possibile impostare un sistema con il quale si sarebbe in grado di accedere alla variabile:

var MODULE = (function(){
   var myMod = {},
       privateVar = "I'm private";

   myMod.callback = function(fn) {fn(privateVar);};

   return myMod;
})();

var someDynamicFunc = function(param) {alert(param);};
myMod.callback(someDynamicFunc);

Naturalmente, questo rende non davvero privato, dal momento che chiunque potrebbe farlo. Non vedo come sarebbe possibile a tutti per voi di avere una variabile "privato" a cui si accede tramite le funzioni collegate in modo dinamico, senza che nessuno funzioni altro dinamicamente collegati ad avere lo stesso privilegio (rendendo così non è veramente privata).

Answer 2

Immagino che tu non abbia capito esattamente come funzionano le chiusure.

Le chiusure significano che gli ambiti Sempre avere accesso all'ambito esterno che erano definito In.

function Counter(start) {
    var count = start;


    return {
        increment: function() { // has access to the outer scope
            count++;
        },

        get: function() {
            return count;
        }
    }
}

var foo = new Counter(4);
foo.increment();
foo.get(); // 5

Ritorna l'esempio precedente due chiusure, sia la funzione increment così come get mantenere un riferimento a count variabile definita nel costruttore.

Uno non può accesso count dall'esterno l'unico modo per interagire con esso è tramite le due funzioni “chiuse”.

Ricorda, le chiusure funzionano mantenendo un riferimento ai loro ambiti esterni, così come fa quanto segue non lavoro:

var foo = new Counter(4);
foo.hack = function() { // is not getting defined in the same scope that the original count was
    count = 1337;
};

Questo sarà non modificare la variabile count quello è all'interno Counter Da foo.hack era non definito in quell'ambito, invece, creerà o sovrascriverà la variabile globale count.