Bitte lesen Sie die Kommentare sorgfältig für Details. Lassen Sie uns hier weniger Unsinn sprechen und den Code einfach hochladen.
Die Codekopie lautet wie folgt:
<! DocType html>
<html>
<kopf>
<meta charset = "utf-8">
<title> Testdokument </title>
<script type = "text/javaScript">
// Im Wesentlichen sind die Eigenschaften und Methoden gleich und die Methoden sind Funktionen, deren Eigenschaften Referenztyp sind.
// Ein Objekt hat 4 Eigenschaften:
// 1, die vom Konstruktor über dieses Schlüsselwort definierten Attribute
// 2, die vom Konstruktor über das VAR -Schlüsselwort definierten Attribute
// 3, Eigenschaften, die dem Prototypobjekt des Konstruktors hinzugefügt wurden
// 4, die Attribute, die vom Objekt dynamisch hinzugefügt werden
// Öffentliche Eigenschaften der Instanz: 1, 2, 3, 4 kann über die von diesem Schlüsselwort definierten Attribute zugegriffen werden
// Private Attribute der Instanz: 2 Attribute, die durch das Schlüsselwort var definiert sind. Zugänglich 2
// Eigenschaften einer Instanz teilen: 3 Attribute, auf die durch die Instanz hingewiesen wird. Zugänglich 1,3,4
// statische Eigenschaften der Instanz: 4 Eigenschaften, die vom Objekt dynamisch hinzugefügt wurden. Zugänglich 1,3,4
//Zusammenfassen:
// Instanzattribute: 1, öffentlich
// 2, privat
// 4, statisch
// Prototypattribute: 3, teilen
// Dies wird als privilegiertes Attribut definiert. Alles zugänglich
// var wird als Privateigentum definiert.
// Die dynamischen Attribute sind öffentliche Attribute. Private Eigenschaften sind nicht zugänglich
// Das vom Instanzobjekt gezeigte Prototypattribut ist das Prototyp -Attribut. Private Attribute sind nicht zugänglich, mit niedrigerer Priorität als öffentliche Attribute
// Instanzattribute bestehen hauptsächlich aus öffentlichen Attributen und Berechtigungsattributen. Beide können durch externe und Prototypeigenschaften zugegriffen werden. Der Hauptunterschied besteht darin, ob private Attribute zugänglich sind
// Die Vorrang des Prototypsattributs ist niedriger als das des Instanzattributs. Kann auf externe und Instanzattribute zugegriffen werden (außer privaten Attributen)
// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// öffentliche Eigenschaften: Attribute, die der externen Umgebung ausgesetzt sind. Es ist auch ein Attribut des Objekts.
// Private Attribute: Attribute in Objekten sind oft unzugänglich. Es ist nur sinnvoll, sie auf Konstruktorebene zu betrachten.
// Statische Eigenschaften: Dynamisch hinzugefügte Eigenschaften. Es ist auch ein Attribut des Objekts.
// Shared Properties: Attribute, die von allen von Konstruktoren generierten Instanzen gemeinsam genutzt werden.
Funktion user () {
// öffentliche Eigenschaften: Attribute, die jedes neue Benutzerinstanzobjekt hat.
// ist ein Instanzattribut, und alle Instanzattribute teilen keinen Speicher.
// extern zugänglich.
this.name = 'byronvis';
// Privilegierte Methode: Eine Methode, die für jedes neue Benutzerinstanzobjekt verwendet wurde.
// ist eine Instanzmethode, alle Instanzmethoden teilen keinen Speicher.
// extern zugänglich.
// öffentliche Eigenschaften sind zugänglich.
// private Eigenschaften sind zugänglich.
this.sayname = function () {
alarm (this.name);
alarm (this.school);
Alert (Alter); // Variable Deklaration wird automatisch fortgeschritten.
alarm (this.sex);
};
// Private Attribute: Nicht extern zugänglich.
// Es ist für Konstruktoren nur sinnvoll, nicht für neue Benutzerinstanzobjekte.
var Alter = 22;
// Private Methode: Nicht extern zugänglich.
// Es ist für Konstruktoren nur sinnvoll, nicht für neue Benutzerinstanzobjekte.
Funktion Sayage () {
Alarm (Alter);
}
sayage ();
}
// Shared Attribute: Shared Memory.
User.Prototype.school = 'Zky';
// Häufige Methoden: Zu öffentliche Attribute können zugegriffen werden.
// Shared Memory.
User.Prototype.sayschool = function () {
alarm (this.school);
alarm (this.name);
alarm (this.sex);
Alarm (Alter);
};
var obj = neuer user ();
// Statische Eigenschaften: Ist die Instanzeigenschaften dynamisch hinzugefügt.
obj.sex = 'man';
// Statische Methode: Ist die Instanzmethode dynamisch hinzugefügt.
obj.saysex = function () {
alarm (this.sex);
alarm (this.name);
alarm (this.school);
Alarm (Alter);
};
// -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//// beweisen, dass die durch dieses Schlüsselwort definierten Attribute im Wesentlichen die gleichen sind, die dynamisch hinzugefügt werden und als öffentliche Attribute von Instanzobjekten angesehen werden können.
// Überprüfung: Dieses Schlüsselwort definiert Eigenschaften zum Zugriff auf dynamisch hinzugefügte Eigenschaften
// obj.sayname (); // true
// Überprüfung: Dynamisch hinzugefügt Attribute Zugriff auf die durch dieses Schlüsselwort definierten Attribute
// obj.saysex (); // true
// Überprüfung: öffentliche Immobilien Zugriff auf private Eigenschaften
// obj.sayname (); // true
obj.saysex (); // false
// Überprüfung: Freigegebene Attribute Zugriff auf private Attribute
// obj.sayschool (); // false
</script>
</head>
<body>
Testdokumente
</body>
</html>
Haben Sie die Beispielattribute und Prototyp -Attribute verstanden? Dieser Artikel ist sehr detailliert und für alle empfohlen. Ich hoffe, es wird für meine Freunde hilfreich sein.