Résumé d'exemples de concepts de base tels que les objets, les membres publics et les membres privés en JavaScript

JavaScript est construit sur des objets. Les tableaux sont des objets, les fonctions sont des objets et les objets sont bien sûr des objets. Alors, qu’est-ce qu’un objet ? Un objet est une collection de paires nom-valeur. Les noms sont des chaînes, mais les valeurs peuvent être des chaînes, des nombres, des booléens ou des objets (y compris des tableaux et des fonctions). Les objets sont généralement implémentés à l'aide de tables de hachage afin que les valeurs puissent être récupérées rapidement.

Si la valeur est une fonction, on peut la traiter comme une "méthode". Lorsqu'une méthode de l'objet est exécutée, la variable this est définie sur l'objet lui-même. De cette façon, la méthode peut accéder à l’instance de l’objet via la variable this.

Les objets peuvent être créés via des "constructeurs". Un constructeur est une fonction qui contient un objet initialisé. Les constructeurs fournissent des caractéristiques et des fonctionnalités similaires à celles fournies par les « classes » dans d'autres langages, notamment des variables et des méthodes statiques.

Public

Tous les membres d'un objet sont des membres publics. N'importe quelle fonction peut accéder, modifier ou supprimer ces membres, et bien sûr peut ajouter de nouveaux membres. Il existe deux manières principales d'ajouter des membres à un objet :

Par le constructeur

Cette méthode est généralement utilisée pour initialiser les variables publiques d'une instance d'objet. La variable this du constructeur est utilisée pour ajouter des membres à l'objet :

function Container(param) {
  this.member = param;
}

Construire un nouvel objet :

var myContainer = new Container('abc');

Ensuite, la variable publique myContainer.member a la valeur ' abc'.

Par prototype

Cette méthode est généralement utilisée pour ajouter des méthodes publiques. Lorsque l'objet lui-même est recherché pour un membre mais n'est pas trouvé, le membre prototype du constructeur est utilisé. Ce mécanisme prototype implémente ce qu'on appelle « l'héritage » orienté objet et économise également de la mémoire. Pour ajouter une méthode à tous les objets créés à partir du même constructeur, il suffit d'ajouter une fonction au prototype du constructeur :

Container.prototype.stamp = function (string) {
  return this.member + string;
}

Ensuite on peut appeler cette méthode :

myContainer.stamp('def')

Renvoyer 'abcdef'.

Privé

Les membres privés sont créés par le constructeur. Habituellement, les variables et les paramètres de fonction déclarés avec var dans le constructeur deviennent des membres privés.

function Container(param) {
  this.member = param;
  var secret = 3;
  var self = this;
}

Ce constructeur crée trois variables d'instance privées : param, secret et self.

function Container(param) {
  function dec() {
   if (secret > 0) {
     secret -= 1;
     return true;
   } else {
     return false;
   }
  }

  this.member = param;
  var secret = 3;
  var self = this;
}

La méthode privée dec vérifiera la variable d'instance secrète. Si elle est supérieure à 0, la décrémentera de 1 et retournera vrai si elle est inférieure à 0, renverra false. Cela permet d'obtenir la fonction selon laquelle la fonction dec de l'objet créé par ce constructeur ne peut être utilisée que trois fois.

Par convention, on crée une variable privée self. Les méthodes privées peuvent accéder à l'objet lui-même. Mais ce n'est qu'une mesure provisoire, car il y a un bug dans la "Spécification du langage ECMAScript" qui provoque la définition de la variable this de la fonction interne sur une valeur incorrecte.

Privilégiés

Les méthodes privilégiées sont créées via ceci à l'intérieur du constructeur. Le

function Container(param) {
  function dec() {
   if (secret > 0) {
     secret -= 1;
     return true;
   } else {
     return false;
   }
  }

  this.member = param;
  var secret = 3;
  var self = this;

  this.service = function () {
   if (dec()) {
     return self.member;
   } else {
     return null;
   }
  };
}

le service est une méthode privilégiée. Les trois premiers appels à myContainer.service() renverront « abc », après quoi il renverra null. Le service accède à la variable privée secret en appelant la méthode privée dec. Pour les autres objets et méthodes, le service est accessible, mais les membres privés ne sont pas directement accessibles.

Fermetures

Ce modèle de membres publics, privés et privilégiés existe en raison d'un mécanisme intrinsèque de JavaScript : les fermetures. Cela signifie qu'une fonction interne peut toujours accéder aux variables et paramètres de sa fonction externe, même si la fonction externe est revenue. Il s'agit d'une fonctionnalité très puissante du langage JavaScript. Il n'existe aucun livre sur la programmation JavaScript qui montre comment en tirer parti, et ils n'en parlent même pas.

Les membres privés et privilégiés ne peuvent être créés que lors de l'initialisation de l'objet, tandis que les membres publics peuvent être ajoutés à tout moment.

Mode

Public

function Constructor(...) {
  this.membername = value;
}
Constructor.prototype.membername = value;

Privé

function Constructor(...) {
  var self = this;
  var membername = value;
  function membername(...) {...}
}

Remarque : Ce code :

function membername(...) {...}

En fait Il est l'abréviation du code suivant

var membername = function membername(...) {...};

privilège

function Constructor(...) {
  this.membername = function (...) {...};
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!