Classes JavaScript et portée variable

Je suis relativement nouveau à JS et je vais avoir correctement des questions de l'émulation de la programmation orientée objet principes.

Je suppose que j'ai deux questions. Question la première est en ce qui concerne les nombreuses façons de déclarer des variables.

Dire que j'ai une classe:

function clazz(a)
{
    this.b = 2;
    var c = 3;
    this.prototype.d = 4; //or clazz.prototype.d = 4?
}

var myClazz = new clazz(1);

Suis-je correct dans les évaluations suivantes:

a est une variable privée qui est l'instance spécifique (c'est à dire les différentes instances de clazz sera unique et indépendant des variables 'a'). Il peut être consulté à partir de clazz comme: 'a'.

b est une variable publique est en instance spécifique. Il peut être consulté à partir de clazz comme cela.b' et de l'extérieur clazz comme " myClazz.b'.

c est une variable privée qui est statique, ou une classe spécifique (c'est à dire les différentes instances de clazz partagent la même " c " de la variable). Il peut être consulté à partir de n'importe quelle instance de clazz que 'c' et les changements dans l'instance de clazz sont reflétées dans toutes les instances de clazz.

d est une variable publique est statique/classe spécifique. Il peut être consulté à partir de n'importe où par l'intermédiaire du 'clazz.le prototype.d' ou 'myClazz.le prototype.d'.

L'ensemble du problème que j'ai avec ma compréhension de la variable système est qu'il n'y a pas de façon de déclarer une variable privée qui n'est PAS statique (c'est à dire une version unique pour chaque instance de la classe).

La deuxième question est à l'égard de différents types de déclarations de classe.

J'ai été en utilisant:

var MySingleton = new function() {...};

pour créer des singletons. Est-ce correct? Je suis également pas sûr de l'effet de la "nouvelle" mot-clé à cette situation ainsi que l'ajout () la fonction accolades à la fin de la déclaration de la manière suivante:

var MySingleton = new function() {...}();

J'ai été en utilisant ce modèle de déclarer une classe et puis instancier les instances de cette classe:

function myClass() {...};
var classA = new myClass();
var classB = new myClass();

Est-ce la bonne méthode?

source d'informationauteur Cmc

  1. 18

    Vous êtes bon pour a et b:

    a est un argument, disponible uniquement dans le champ d'application de la fonction constructeur.

    best une variable d'instance publique, disponible sur toutes les instances créées avec la fonction constructeur.

    c est une variable privée, accessible uniquement au sein de la fonction constructeur.

    La d déclaration n'est pas valide, car le prototype objet est destiné à être utilisé uniquement sur les fonctions constructeurcomme Clazz.prototype.d = 3;si vous le faire de cette façon, la variable sera partagé, mais vous pouvez affecter une valeur à une instance spécifique, et la valeur par défaut sera l'ombre (par le biais de la chaîne de prototype).

    Pour "variables privées", vous pouvez utiliser de la façon dont vous déclarer cpar exemple:

    function Clazz(){
    var c = 3; //private variable

    this.privilegedMethod = function () {
      alert(c);
    };
}

    Privilégié les méthodes sont publiques, mais elles peuvent avoir accès "privé", les variables déclarées à l'intérieur de la fonction constructeur.

    Pour la création de singletons, le plus simple est peut-être d'utiliser un objet littéral, comme:

    var myInstance = {
  method1: function () {
    //...
  },
  method2: function () {
    //...
  }
};

    Et si vous voulez privé des membres de votre instance du singleton, vous pouvez:

    var myInstance = (function() {
  var privateVar = '';

  function privateMethod () {
    //...
  }

  return { //public interface
    publicMethod1: function () {
      //all private members are accesible here
    },
    publicMethod2: function () {
    }
  };
})();

    Ce qui a été appelé le motif de module, il permet d'encapsuler les membres privés sur un objet, en prenant avantage de l'utilisation de fermetures.

    Plus d'infos:

    Edit: Sur la syntaxe de poste:

    var mySingleton = new (function() {
  //...
})();

    À l'aide de la new opérateur, vous devez déclarer et utiliser dans une étape un "anonyme en fonction constructeur", ce qui va générer une nouvelle instance de l'objet, il est valide, mais personnellement, je préfère le "module" modèle de l'approche, de créer ma propre instance de l'objet (et éviter new).

    Aussi, la lecture new function () {}je pense que c'est pas vraiment intuitif et peut créer de la confusion, si vous ne comprenez pas bien comment le new opérateur fonctionne.

    Sur les parenthèses, ils sont facultatifs, le new opérateur appelle la fonction constructeur sans paramètres, si vous n'avez pas les ajouter (voir ECMA-26211.2.2).

  2. 3

    OK, permet de passer en revue ce:

    1. 'a' est un argument passé au constructeur de votre classe. Il existe uniquement pour la durée de l'invocation du constructeur. Cela signifie que vous devriez probablement stocker sa valeur quelque part.

    2. 'b' est un public membre de l'instance. Il est l'instance spécifique (bien que, depuis que vous êtes de l'affectation de la valeur dans le constructeur, toutes les instances d'abord avoir la même valeur pour 'b').

    3. 'c' est un privé, membre de l'instance. Il sera, cependant, ne seront accessibles qu'à l'intérieur de votre constructeur depuis qu'il est défini dans ce champ d'activité. Sauf si vous vous référez à partir d'une fermeture à l'intérieur de votre fonction constructeur, son destin sera similaire à celle de " a " ci-dessus.

    4. 'd' est un public membre de l'instance. Chaque instance de votre classe ont un membre " d " avec la valeur 4 au départ. À noter toutefois que l'attribution d'une référence de type object pour un prototype d'un membre de votre classe (tels que 'd') va faire de chaque membre de l'instance " d " font référence au même objet. Exemple:

      MyClass.prototype.d = { prop1: 'val1', prop2: 'val2' };        
var a = new MyClass();
var b = new MyClass();        
a.d.prop1 = 'foo'; //is the same as: b.d.prop1 = 'foo';

    5. Les membres statiques de la classe sont définies à l'aide de:

      function MyClass()
{
  //...
}    
MyClass.staticMemeber = 'I am a static member';

      Vous ne devriez probablement pas traiter MyClass.prototype comme lieu de vos membres statiques/méthodes.Tout assignés à une des classes prototype est à son tour un membre de chacune de ses instances.

    6. Lorsque ()'s sont attachés à une définition de fonction (à droite après le bloc), la fonction est exécutée. Que signifie:

      var myFunc = function() { alert('blah'); }();

      aboutirait à rien de plus qu'un appel de méthode. Le code suivant:

       var MySingleton = new function() {...}();

      signifie "utiliser la valeur de retour de la fonction() est le constructeur de MySingleton'.