Das Lesen dieses Artikels erfordert Programmiererfahrung in anderen Sprachen.
Einfache Typen in JavaScript umfassen:
1. Zahlen
2. String
3.. Boolean (wahr und falsch)
4. Null
5.undefiniert
Andere Typen sind Objekte (wir sollten nicht durch den Rückgabewert des Typs des Operators verwechselt werden) beispielsweise:
1. Funktion
2.Array
3. Reguläre Ausdrücke
4. Objekt (Objekte sind natürlich Objekte)
Objektbasis
In JavaScript sind Objekte Sammlungen von Eigenschaften (die Objekte sind assoziative Arrays). Jede Eigenschaft umfasst:
1. Der Attributname muss eine Zeichenfolge sein
2. Der Attributwert kann ein anderer Wert als nicht definiert sein
Erstellen Sie ein Objekt durch Objektliteral:
Die Codekopie lautet wie folgt:
// Erstellen Sie ein leeres Objekt über Objekt wörtlich {}
var leer_object = {};
Der Attributname und der Attributwert des Objekts:
Die Codekopie lautet wie folgt:
var stande = {
// "Erstname" ist der Attributname, und "Jerome" ist der Attributwert
"Erstname": "Jerome",
// "Last-Name" ist der Attributname, und "Howard" ist der Attributwert
"Last-Name": "Howard"
};
Wenn der Attributname eine rechtliche Kennung ist, können Anführungszeichen weggelassen werden:
Die Codekopie lautet wie folgt:
var flug = {
Fluggesellschaft: "Ozeanic",
Nummer: 815,
Abteilung: {
Iata: "Syd",
Zeit: "2004-09-22 14:55",
Stadt: "Sydney"
},
Ankunft: {
Iata: "lax",
Zeit: "2004-09-23 10:42",
Stadt: "Los Angeles"
}
};
Schauen wir uns das Beispiel des Zugriffs des Eigenschaft an:
Die Codekopie lautet wie folgt:
var besitzer = {name: "name5566"};
Besitzer.Name; // "name5566"
Besitzer ["Name"]; // "name5566"
Besitzer.Job; // undefiniert
besitzer.job = "codierer"; // oder Eigentümer ["Job"] = "Codierer";
Wenn der Attributname keine rechtliche Kennung ist, muss er in Zitate eingewickelt werden. Der Wert der nicht existierenden Eigenschaft ist undefiniert. Objekte werden eher mit Referenz als durch Wert übergeben:
Die Codekopie lautet wie folgt:
var x = {};
var besitzer = x;
Besitzer.Name = "name5566";
X.Name; // X.Name === "Name5566"
Hier beziehen sich x und der Besitzer auf dasselbe Objekt.
Die Attribute eines Objekts können mit dem Löschbetreiber gelöscht werden:
Die Codekopie lautet wie folgt:
obj.x löschen; // Löschen Sie das X -Attribut von Objekt OBJ
Prototyp des Objekts
Jedes Objekt ist mit einem Prototyp -Objekt verknüpft, und das Objekt kann Attribute aus dem Prototypobjekt erben. Wir erstellen ein Objekt über Objektliteral, dessen Prototyp -Objekt ein Objekt ist. Wenn wir ein Objekt erstellen, können wir das Prototypobjekt des Objekts festlegen (und dann die spezifische Einstellungsmethode diskutieren). Wenn Sie versuchen, ein Attribut eines Objekts zu erhalten (nicht zu ändern), wenn das Objekt nicht vorhanden ist, versucht JavaScript, das Attribut aus dem Prototyp -Objekt dieses Objekts zu erhalten. Wenn das Prototyp -Objekt kein solches Attribut vorhanden ist, schauen Sie dann aus dem Prototyp -Objekt des Prototyps dieses Prototyp -Objekts und so weiter nach. Prototyp -Prototyp -Objekt. Wenn wir das Attribut eines Objekts ändern, beeinflusst es im Vergleich zum Erhalt von Attributen das Prototyp -Objekt nicht.
Funktionelle Grundlagen
Funktionen sind auch Objekte in JavaScript, die mit der Funktion verknüpft sind. Die Funktion hat eine Eigenschaft namens Prototyp, und ihr Wert ist ein Objekt. Dieses Objekt hat einen Eigenschaftskonstruktor, und der Wert des Konstruktors ist diese Funktion:
Die Codekopie lautet wie folgt:
var f = function () {}
typeof f.Prototype; // 'Objekt'
typeof f.Prototype.Constructor; // 'Funktion'
F === F.Prototype.Constructor; // WAHR
Funktionen sind Objekte, Sie können Funktionen wie die Verwendung von Objekten verwenden. Als Randnotiz verfügt die Funktion über zwei versteckte Eigenschaften:
1. Der Kontext der Funktion
2. Funktionscode
Die Funktion wird wie folgt erstellt:
Die Codekopie lautet wie folgt:
var f = Funktion add (a, b) {
Return a + b;
}
console.log (f); // Ausgabe [Funktion: Hinzufügen]
Der Funktionsname nach der Schlüsselwortfunktion ist optional. Wir formulieren den Funktionsnamen hauptsächlich für mehrere Zwecke:
1. für einen rekursiven Anruf
2. Debugger, Entwicklungstools usw. werden verwendet, um Funktionen zu identifizieren
Oft brauchen wir keine Funktionsnamen und Funktionen ohne Funktionsnamen werden anonyme Funktionen bezeichnet. Eine Parameterliste ist in Klammern eingewickelt. JavaScript erfordert nicht die Übereinstimmung mit realen Parametern und formalen Parametern beispielsweise:
Die Codekopie lautet wie folgt:
var add = Funktion (a, b) {
Return a + b;
}
add (1, 2, 3); // Der tatsächliche Parameter und der formale Parameter stimmen nicht überein
Wenn es zu viele reale Parameter gibt, werden die überschüssigen realen Parameter ignoriert. Wenn es zu wenige reale Parameter gibt, ist der Wert der nicht zugewiesenen formalen Parameter undefiniert. Die Funktion muss einen Rückgabewert haben. Wenn der Rückgabewert nicht über die Rückgabeanweisung angegeben wird, ist der Funktionsrenditewert undefiniert.
Eine Funktion und die externen Variablen bilden einen Verschluss. Dies ist der Hauptcharme von JavaScript.
Funktionsaufrufe
Wenn jede Funktion aufgerufen wird, werden zwei zusätzliche Parameter empfangen:
1.Diese
2.Argumente
Der Wert davon hängt mit dem spezifischen Anrufmuster zusammen. In JavaScript gibt es vier Anrufmuster:
1. Methodenaufrufmodus. Wenn die Eigenschaft eines Objekts eine Funktion ist, wird sie als Methode bezeichnet. Wenn eine Methode durch OM (Args) aufgerufen wird, ist dies ein Objekt O (das ersichtlich ist, dass dies und o nur beim Aufrufen gebunden sind), zum Beispiel:
Die Codekopie lautet wie folgt:
var obj = {
Wert: 0,
Inkrement: Funktion (v) {
this.Value += (Typof v === 'Nummer'? V: 1);
}
};
obj.increment (); // this === obj
2. Funktionsaufrufmodus. Wenn eine Funktion nicht die Eigenschaft eines Objekts ist, wird sie als Funktion aufgerufen, und dies ist zum Beispiel an das globale Objekt gebunden:
Die Codekopie lautet wie folgt:
Message = 'Hallo Welt';
var p = function () {
console.log (this.message);
}
P(); // Ausgabe 'Hallo Welt'
Dieses Verhalten ist manchmal verwirrend, siehe ein Beispiel:
Die Codekopie lautet wie folgt:
obj = {
Wert: 0,
Inkrement: function () {
var helper = function () {
// 1 zum Wert im globalen Objekt 1 hinzufügen
this.Value += 1;
}
// Helfer wird als Funktion bezeichnet
// Daher ist dies ein globales Objekt
Helfer();
}
};
obj.increment (); // obj.value === 0
Die Ergebnisse, die wir erwarten, sollten sein:
Die Codekopie lautet wie folgt:
obj = {
Wert: 0,
Inkrement: function () {
var das = dies;
var helper = function () {
that.value += 1;
}
Helfer();
}
};
obj.increment (); // obj.value === 1
3.. Konstruktor -Anrufmodus. Funktionen, die das neue Präfix verwenden möchten, werden als Konstruktoren bezeichnet, z. B.:
Die Codekopie lautet wie folgt:
// Test wird als Konstruktor bezeichnet
var test = function (string) {
this.message = String;
}
var myTest = neuer Test ("Hallo Welt");
Eine Funktion kann mit neu aufgerufen werden (solche Funktionen beginnen normalerweise mit der Kapitalisierung). Nach dem Hinzufügen von Neuen wird ein mit der Prototyp -Eigenschaft dieser Funktion verknüpfter Objekt erstellt, und dieses Objekt im Konstruktor ist dieses Objekt.
4. Anwenden Sie den Anrufmodus an. Die Anwendenmethode der Funktion wird verwendet, um die Funktion mit zwei Parametern aufzurufen. Die erste ist dies und die zweite ist ein Array von Parametern, zum Beispiel:
Die Codekopie lautet wie folgt:
var add = Funktion (a, b) {
Return a + b;
}
var ret = add.apply (null, [3, 4]); // ret === 7
Wenn wir die Funktion aufrufen, können wir auf ein Array von Klassen zugreifen, das als Argumente (nicht reales Javascript-Array) bezeichnet wird und alle Argumente enthält, sodass wir Parameter mit variabler Länge implementieren können:
Die Codekopie lautet wie folgt:
var add = function () {
var sum = 0;
für (var i = 0; i <argumente.length; ++ i) {
Summe += Argumente [i];
}
Rückgabesumme;
}
add (1, 2, 3, 4);
abnormal
Lassen Sie uns nun über den Ausnahmebehandlungsmechanismus von JavaScript sprechen. Wir verwenden die Throw-Anweisung, um Ausnahmen zu werfen, und die Anweisung Try-Cache, um Ausnahmen zu fangen und zu handhaben:
Die Codekopie lautet wie folgt:
var add = Funktion (a, b) {
if (typeof a! == 'nummer' || typeof b! == 'number') {
// eine Ausnahme werfen
werfen {
Name: 'TypeError',
Nachricht: 'Bedürfnisse Zahlen hinzufügen'
};
}
Return a + b;
}
// Ausnahmen fangen und behandeln
versuchen {
add ("sieben");
// e ist das geworfene Ausnahmeobjekt
} catch (e) {
console.log (e.name + ':' + e.message);
}
Fügen Sie JavaScript -Typen Eigenschaften hinzu
Konstruktoren existieren in den meisten Typen in JavaScript:
1. Der Konstruktor des Objekts ist Objekt
2. Der Konstruktor des Arrays ist Array
3.. Der Konstruktor der Funktion ist Funktion
4. Der Konstruktor der String ist Zeichenfolge
5. Der Konstruktor der Nummer ist die Zahl
6. Der Konstruktor des Booleschen ist Booleschen
7. Der Konstruktor des regulären Ausdrucks ist Regexp
Wir können dem Prototyp des Konstruktors Eigenschaften (häufig Methoden hinzufügen) hinzufügen, damit diese Eigenschaft den zugehörigen Variablen zur Verfügung steht:
Die Codekopie lautet wie folgt:
Number.Prototype.integer = function () {
Mathematik zurückgeben [dies <0? 'Ceil': 'Boden'] (dies);
}
(1.1) .Integer (); // 1
Umfang
JavaScript muss durch Funktionen Bereiche erstellen:
Die Codekopie lautet wie folgt:
function () {
// ...
} ();
Hier wird eine anonyme Funktion erstellt und ausgeführt. Geltungsbereich zur Verbereitung von Variablen, die Sie nicht entlarvt werden möchten:
Die Codekopie lautet wie folgt:
var obj = function () {
// Wert ausblenden, kann nicht extern zugegriffen werden
var value = 0;
zurückkehren {
// Nur diese Methode kann den Wert ändern
Inkrement: function () {
Wert += 1;
},
// Nur diese Methode kann den Wert lesen
GetValue: function () {
Rückgabewert;
}
};
} ();
obj.increment ();
obj.getValue () === 1;
erben
Es gibt viele Möglichkeiten, die Vererbung in JavaScript zu implementieren.
Beim Erstellen eines Objekts können wir das dem Objekt zugeordnete Prototypobjekt einrichten, und wir tun dies:
Die Codekopie lautet wie folgt:
// Erstellen Sie ein Objekt O mit seinem Prototypobjekt {x: 1, y: 2}
var o = Object.create ({x: 1, y: 2});
Das Object.create -Methode ist in ECMASScript 5 definiert. Wenn Sie ECMascript 3 verwenden, können Sie selbst eine Erstellenmethode implementieren:
Die Codekopie lautet wie folgt:
// Wenn die Methode von Object.create nicht definiert ist
if (typeof Object.create! == 'Funktion') {
// Die Methode von Object.create erstellen
Object.create = Funktion (o) {
var f = function () {};
F.Prototyp = o;
// Erstellen Sie ein neues Objekt, das Prototypobjekt dieses Objekts ist O.
Neue f () zurückgeben;
};
}
Durch die Methode von Object.create führen wir prototypbasierte Vererbung durch: Ein neues Objekt erbt direkt die Eigenschaften eines alten Objekts (relativ zum klassenbasierten Vererbung, es besteht keine Notwendigkeit für die Existenz der Klasse hier, und das Objekt erbt direkt das Objekt). Beispiel:
Die Codekopie lautet wie folgt:
var myMammal = {
Name: 'Kräuter das Säugetier',
get_name: function () {
kehre diesen namennamen zurück;
},
sagt: function () {
Gibt dies zurück. || '';
}
};
// Erbe MyMammal
var mycat = Object.create (MyMammal);
mycat.name = 'Henrietta';
mycat.saying = 'miow';
mycat.purr = function (n) {
var i, s = '';
für (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
Rückkehr s;
};
mycat.get_name = function () {
return this.says () + '' + this.name + '' + this.says ();
};
Der obige Code ist einfach, aber er kann keine privaten Mitglieder schützen. Wir können den Modulmodus verwenden. Im Modulmodus wird von einer Funktion ein bestimmter Objekttyp erzeugt und verwendet das Funktionsbereich, um private Mitglieder vor externen Zugriff zu schützen:
Die Codekopie lautet wie folgt:
// Säugetierfunktion, verwendet, um Säugetierobjekte zu konstruieren
var mammal = function (spec) {
// Das ist das konstruierte Objekt
var das = {};
// Die öffentliche Methode get_name kann extern zugegriffen werden
that.get_name = function () {
// spec.name kann nicht direkt von außen zugegriffen werden
Rückgabespezifikation;
};
// öffentliche Methode sagt, kann extern zugegriffen werden
that.says = function () {
// Spec.Saying Kein direkter Zugriff auf extern
return spec.saying || '';
};
gib das zurück;
};
// Erstellen Sie ein Säugetierobjekt
var myMammal = Säugetier ({Name: 'Herb'});
// Katzenfunktion, verwendet, um ein Katzenobjekt zu konstruieren
var cat = function (spec) {
spec.saying = spec.saying || 'Miau';
// Katze erbt vom Säugetier, konstruieren also zuerst das Säugetierobjekt
var das = Säugetier (spec);
// öffentliche Methode purr hinzufügen
that.purr = function (n) {
var i, s = '';
für (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
Rückkehr s;
};
// Die öffentliche Methode GET_NAME ändern
that.get_name = function () {
Geben Sie das zurück.says () + '' + spec.name +
'' + that.says ();
gib das zurück;
};
};
// Katzenobjekt erstellen
var mycat = cat ({name: 'henrietta'});
Im Modulmodus wird die Vererbung durch Aufrufen des Konstruktors erreicht. Darüber hinaus können wir auch auf die Methoden der Elternklasse in der Unterklasse zugreifen:
Die Codekopie lautet wie folgt:
Object.Prototype.Superior = Funktion (Name) {
var das = this, method = this [name];
return function () {
Rückgabemethode.Apply (das, Argumente);
};
};
var coolcat = function (spec) {
// Erhalten Sie die Get_Name -Methode der Unterklasse
var that = cat (spec), super_get_name = that.superior ('get_name');
that.get_name = function (n) {
return 'wie' + super_get_name () + 'baby';
};
gib das zurück;
};