Veuillez lire attentivement les commentaires pour plus de détails. Parlons ici moins de bêtises et téléchargeons le code.
La copie de code est la suivante:
<! Doctype html>
<html>
<adal>
<meta charset = "utf-8">
<Title> Test Document </Title>
<script type = "text / javascript">
// En substance, les propriétés et les méthodes sont les mêmes, et les méthodes sont des fonctions dont les propriétés sont de type référence.
// Un objet a 4 propriétés:
// 1, les attributs définis par le constructeur via ce mot-clé
// 2, les attributs définis par le constructeur via le mot clé var
// 3, propriétés ajoutées à l'objet prototype du constructeur
// 4, les attributs ajoutés dynamiquement par l'objet
// Propriétés publiques de l'instance: 1, 2, 3, 4 peut être accessible via les attributs définis par ce mot-clé
// Attributs privés de l'instance: 2 attributs définis par le mot-clé var. Accessible 2
// Partage des propriétés d'une instance: 3 attributs ajoutés via le prototype indiqué par l'instance. Accessible 1,3,4
// Propriétés statiques de l'instance: 4 propriétés ajoutées dynamiquement par l'objet. Accessible 1,3,4
//Résumer:
// Attributs d'instance: 1, public
// 2, privé
// 4, statique
// Prototype Attributs: 3, partager
// Ceci est défini comme un attribut privilégié. Tous accessibles
// var est défini comme une propriété privée.
// Les attributs ajoutés dynamiquement sont des attributs publics. Les propriétés privées ne sont pas accessibles
// L'attribut prototype pointé par l'objet d'instance est l'attribut prototype. Les attributs privés ne sont pas accessibles, avec une priorité plus faible que les attributs publics
// Les attributs d'instance sont principalement constitués d'attributs publics et d'attributs de privilège. Les deux sont accessibles par des propriétés externes et prototypes. La principale différence est de savoir si les attributs privés sont accessibles
// La priorité de l'attribut prototype est inférieure à celle de l'attribut d'instance. Peut être accessible en externe et des attributs d'instance (sauf les attributs privés)
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Propriétés publiques: Attributs exposés à l'environnement externe. C'est aussi un attribut de l'objet.
// Attributs privés: les attributs à l'intérieur des objets sont souvent inaccessibles. Il est seulement significatif de les considérer au niveau du constructeur.
// Propriétés statiques: propriétés ajoutées dynamiquement. C'est aussi un attribut de l'objet.
// Propriétés partagées: attributs partagés par toutes les instances générées par les constructeurs.
fonction user () {
// Propriétés publiques: attribue que chaque nouvel objet d'instance utilisateur a.
// est un attribut d'instance, et tous les attributs d'instance ne partagent pas la mémoire.
// accessible à l'extérieur.
this.name = 'byronvis';
// Méthode privilégiée: une méthode qui a été utilisée pour chaque nouvel objet d'instance utilisateur.
// est une méthode d'instance, toutes les méthodes d'instance ne partagent pas la mémoire.
// accessible à l'extérieur.
// Les propriétés publiques sont accessibles.
// Les propriétés privées sont accessibles.
this.sayName = function () {
alert (this.name);
alerte (this.school);
alerte (âge); // La déclaration variable sera automatiquement avancée.
alerte (this.sex);
};
// Attributs privés: non accessibles à l'extérieur.
// Cela n'a de sens que pour les constructeurs, pas pour les nouveaux objets d'instance utilisateur.
Var âge = 22;
// Méthode privée: non accessible à l'extérieur.
// Cela n'a de sens que pour les constructeurs, pas pour les nouveaux objets d'instance utilisateur.
function sayage () {
alerte (âge);
}
Sayage ();
}
// Attributs partagés: mémoire partagée.
User.prototype.school = 'zky';
// Méthodes communes: les attributs publics sont accessibles.
// mémoire partagée.
User.prototype.sayschool = function () {
alerte (this.school);
alert (this.name);
alerte (this.sex);
alerte (âge);
};
var obj = nouvel utilisateur ();
// Propriétés statiques: les propriétés d'instance sont-elles ajoutées dynamiquement.
obj.sex = 'man';
// Méthode statique: est la méthode d'instance ajoutée dynamiquement.
obj.saysex = function () {
alerte (this.sex);
alert (this.name);
alerte (this.school);
alerte (âge);
};
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//// prouve que les attributs définis par ce mot-clé sont essentiellement les mêmes que ceux ajoutés dynamiquement et peuvent être considérés comme des attributs publics des objets d'instance.
// Vérification: ce mot-clé définit les propriétés pour accéder aux propriétés ajoutées dynamiquement
// obj.sayName (); // true
// Vérification: les attributs ajoutés dynamiquement accèdent aux attributs définis par ce mot-clé
// obj.saysex (); // vrai
// Vérification: les propriétés publiques accèdent aux propriétés privées
// obj.sayName (); // true
obj.saysex (); // faux
// Vérification: les attributs partagés accèdent aux attributs privés
// obj.sayschool (); // faux
</cript>
</ head>
<body>
Documents de test
</docy>
</html>
Avez-vous compris l'exemple des attributs et des attributs prototypes? Cet article est très détaillé et recommandé à tout le monde. J'espère que ce sera utile à mes amis.