Qu'est-ce qu'un membre privé en Javascript

Les membres privés doivent être générés par le constructeur. Ce constructeur a trois variables d'instance privées : param, secret et self. Ils sont attachés à l'objet, mais ils ne sont pas accessibles de l'extérieur, ni par les méthodes publiques de l'objet. Ils ne sont visibles que par les membres privés.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

JavaScript est le langage le plus mal compris au monde. De nombreuses personnes pensent qu'il manque de fonctionnalités de masquage d'informations, de sorte que les objets ne peuvent pas avoir de variables et de méthodes d'instance privées. Mais c'est un malentendu. Les objets JavaScript peuvent également avoir des variables privées. Expliquons-le ci-dessous :

Objets

JavaScript concerne fondamentalement les objets. Le tableau est un objet, la fonction est un objet et l'objet ne sera pas mentionné. Alors, qu’est-ce qu’un objet ? Un objet est une collection de paires nom-valeur. Les noms sont des chaînes et les valeurs peuvent être des chaînes, des nombres, des booléens et des objets (y compris des tableaux et des fonctions). Les objets sont souvent implémentés sous forme de tables de hachage pour accéder rapidement aux valeurs.

Si une valeur est une fonction, nous pouvons la traiter comme une méthode. Lorsqu'une méthode sur un objet est appelée, la variable this est définie sur cet objet. Cette méthode vous permet d'accéder aux variables d'instance via cette variable.

L'objet est généré par le constructeur, qui est la fonction qui initialise l'objet. Les constructeurs fournissent des fonctionnalités que les classes d'autres langages fournissent, notamment des méthodes et des variables statiques.

Membres publics

Les membres de l'objet sont tous des membres publics publics. N'importe quelle fonction peut accéder, modifier ou supprimer ces membres. Il existe deux manières principales d'ajouter des membres à un nouvel objet :

Dans le constructeur

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

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

De cette façon, si nous construisons un nouvel objet

var myContainer = new Container('abc');

alors myContainer.member contiendra 'abc'.

Dans les prototypes

cette technique est généralement utilisée pour ajouter des méthodes publiques. Lorsqu'un membre est récupéré et n'est pas trouvé dans l'objet, il est obtenu à partir du membre prototype du constructeur de l'objet. Ce mécanisme prototype peut être utilisé pour implémenter l'héritage. Cela permet également d'économiser de la mémoire. Pour ajouter une méthode à tous les objets générés par un constructeur, ajoutez la fonction au prototype du constructeur :

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

De cette façon, nous pouvons appeler cette méthode

myContainer.stamp('def')

Elle renverra 'abcdef'.

Membres privés

Les membres privés sont générés par le constructeur. Les variables et paramètres var ordinaires du constructeur deviennent des membres privés.

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

Ce constructeur a trois variables d'instance privées : param, secret et self. Ils sont attachés à l'objet, mais ils ne sont pas accessibles de l'extérieur, ni par les méthodes publiques de l'objet. Ils ne sont visibles que par les membres privés. Les méthodes privées sont des fonctions à l’intérieur du constructeur.

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érifie la variable d'instance secrète. S'il est supérieur à 0, réduisez la taille du secret et renvoyez vrai. Sinon, il renvoie false . Cela limite l'objet à trois usages.

Par convention, nous donnons un paramètre self privé. Cela rend l'objet visible aux méthodes privées. Cette pratique est due à un bug dans la spécification du langage ECMAScript qui empêche sa définition correcte pour les fonctions internes.

Les méthodes privées ne peuvent pas être appelées par les méthodes publiques. Pour rendre les méthodes privées utiles, nous devons introduire une méthode privilégiée.

Membres privilégiés

Un privilégié Une méthode privilégiée peut accéder à des variables et des méthodes privées, alors qu'elle est visible par le domaine public. Vous pouvez également supprimer ou remplacer une méthode privilégiée, mais vous ne pouvez pas la modifier.

Les méthodes privilégiées sont attribuées dans le constructeur à l'aide de ceci.

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;
		}
	};
}

service est une méthode privilégiée. Les trois premiers appels renverront « abc ». Après cela, il renvoie null. La méthode privée dec appelée par le service, et dec accède à la variable secrète privée. Le service est visible par d'autres objets et méthodes, mais ne peut pas accéder directement aux membres privés.

Fermetures

La raison pour laquelle ce modèle de membres publics, privés et privilégiés fonctionne est que JavaScript a des fermetures. Cela signifie qu'une fonction interne peut toujours accéder aux variables et paramètres extérieurs à la fonction, même après le retour de la fonction externe. Il s’agit d’une fonctionnalité extrêmement puissante du langage. Aucun livre actuel sur la programmation JavaScript ne montre comment exploiter cette fonctionnalité. La plupart ne sont pas mentionnés.

Les membres privés et privilégiés ne peuvent être générés que lors de la construction de l'objet. Des membres publics peuvent être ajoutés à tout moment.

Mode

Public

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

Private

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

Notez qu'en fait l'instruction de fonction

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

est l'abréviation de l'instruction suivante, les deux sont identiques :

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

Privileged (Privileged

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

【Apprentissage recommandé : Tutoriel avancé javascript】

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!