Comment créer des membres publics et privés?

Question

Je suis un peu confus, comment puis-je créer des membres publics et privés.

jusqu'à présent Mon modèle de code est comme:

(function()){ 
    var _blah = 1; 

    someFunction = function() { 
    alert(_blah); 
    }; 

    someOtherFunction = function() { 
    someFunction(); 
    } 
}(); 

Answer 1

Vous pouvez utiliser le Yahoo Module Pattern:

myModule = function() { 

    //"private" variables: 
    var myPrivateVar = "I can be accessed only from within myModule." 

    //"private" method: 
    var myPrivateMethod = function() { 
     console.log("I can be accessed only from within myModule"); 
    } 

    return { 
     myPublicProperty: "I'm accessible as myModule.myPublicProperty." 

     myPublicMethod: function() { 
      console.log("I'm accessible as myModule.myPublicMethod."); 

      //Within myProject, I can access "private" vars and methods: 
      console.log(myPrivateVar); 
      console.log(myPrivateMethod()); 
     } 
    }; 
}(); 

Vous définissez vos membres privés où myPrivateVar et myPrivateMethod sont définis, et vos membres publics où myPublicProperty et myPublicMethod sont définis.

Vous pouvez simplement accéder aux propriétés et méthodes comme suit:

myModule.myPublicMethod(); // Works 
myModule.myPublicProperty; // Works 
myModule.myPrivateMethod(); // Doesn't work - private 
myModule.myPrivateVar;  // Doesn't work - private 

Answer 2

Vous n'avez pas.You can rely on convention, en ajoutant _ à vos attributs privés, puis en ne les touchant pas avec du code qui ne devrait pas l'utiliser.

ou vous pouvez use the function scope to create variables qui ne peut pas être accédé de l'extérieur.

Answer 3

Javascript ne pas vrai députés. Vous devez abuser de la portée si vous avez vraiment besoin de confidentialité.

Answer 4

En javascript, chaque membre est public. Moyen le plus populaire de déclarer le domaine privé est d'utiliser le signe de soulignement dans son nom, juste pour rendre les autres conscients que ce domaine privé:

a = {} 
a._privateStuff = "foo" 

L'autre façon de cacher la variable utilise les champs d'application en javascript :

function MyFoo { 
    var privateVar = 123; 
    this.getPrivateVar = function() { 
     return privateVar; 
    } 
} 

var foo = new MyFoo(); 

foo.privateVar // Not available! 
foo.getPrivateVar() // Returns the value 

Voici l'article qui explique cette technique dans les détails:

http://javascript.crockford.com/private.html

Answer 5

J'espère que cette URL s Olve votre problème ... voir que ...

http://robertnyman.com/2008/10/14/javascript-how-to-get-private-privileged-public-and-static-members-properties-and-methods/

Answer 6

Trois choses:

1. IIFEs:
   Il semble que vous avez besoin de rafraîchir vos connaissances au sujet de ce modèle . Jetez un oeil à this poste avant d'utiliser à nouveau un IIFE.

2. mondiale contre publique public sûr:
   Skipping var mot-clé avec someFunction et someOtherFunction conduit à l'enregistrement de ces objets de fonction dans la portée globale, à savoir, ces fonctions peuvent être appelées et réaffectés de partout dans le code. Cela pourrait conduire à de sérieux bugs car le code devient plus gros. Au lieu de cela, comme Daniel suggéré, utilisez le modèle de module. Bien que vous pouvez utiliser d'autres méthodes comme Constructeurs, Objet.create(), etc, mais c'est assez simple à implémenter.

   /* create a module which returns an object containing methods to expose. */ 
   var someModule = (function() { 
       var _blah = 1; 
        return { 
        someFunction: function() {}, 
        someOtherFunction: function() {} 
        }; 
   })(); 
   /* access someFunction through someModule */ 
   someModule.someFunction(); 
   // ... 
   // .... 
   /* after 500+ lines in this IIFE */ 
   /* what if this happens */ 
   someFunction = function() { 
       console.log("Global variables rock."); 
   }; 
   /* Fortunately, this does not interfere with someModule.someFunction */ 
   

3. Convention et la portée combinées:
   Nous ne pouvons pas attendre de tous les développeurs de suivre le trait de soulignement ou la convention de capitalisation. Et si l'un d'entre eux oublie d'implémenter cette technique? Au lieu de se contenter de la convention (_private, GLOBAL) et de la portée (fonction de portée), nous pouvons combiner les deux. Cela aide à maintenir la cohérence dans le style de codage et assure une sécurité adéquate des membres. Donc, si la prochaine fois que quelqu'un oublie de capitaliser ses globals, la console (en mode strict) peut empêcher le monde de se terminer.