Für JavaScript -Typen kann es einfach zusammengefasst werden als: Im Vergleich zu stark typisierten Sprachen ist es eine schwache (lose) Sprache; Es gibt grundlegende Typen und Referenztypen, und sie sind der Unterschied, dass ein fester Speicherplatz im Stapelspeicher vorhanden ist und ein Zeiger auf den Implementierungsort im Stack -Speicher ohne festgelegte Speicherplatz gespeichert ist und ein Zeiger auf den Implementierungsort im Stack -Speicher gespeichert ist.
Viele Bücher auf dem Markt haben viel Platz zum Reden. In diesem Artikel wird über verschiedene Aspekte sprechen, die möglicherweise ein einfaches Verständnis von JavaScript haben, insbesondere die Arten von JavaScript. Wenn Sie es noch nicht verstehen, können Sie ein Buch über JavaScript abholen und erneut lesen.
1. Grundtypen und Referenztypen
1. Grundtyp: undefined/null/boolean/number/string
2. Referenztyp: Objekt/Array/Funktion/Datum/regexp/fehler/map/set…
Warum werden die Referenztypen nicht aufgezählt? Weil Sie nur so viel darüber wissen, sind zumindest in dem Artikel, über den ich gesprochen habe, genug. Andere können selten verwendet werden, und selbst diejenigen wie Map und Set werden nicht von allen Browsern unterstützt.
2. Urteil des JavaScript -Typs
In JavaScript gibt es zwei Operatoren, die zur Bestimmung der Typen verwendet werden können. Sie sind Typen und Instanz, aber der Kreis ist sehr klein, und sie sind nicht so gut darin, und sie sind notorisch unzuverlässig. Einige Situationen sind ebenfalls korrekt, aber in vielen Fällen sind sie unzuverlässig. Schauen Sie es sich einfach an und Sie werden wissen:
Die Codekopie lautet wie folgt:
// Wenn es zuverlässig ist:
Typof 'Sofish' // String
Neue String ('Sofish') Instanz von String // True
// Wenn es unzuverlässig ist:
typeof [] // Objekt
typeof null // Objekt
'Sofish' Instanz der String // Falsch
Viele JavaScript -Programmierer anfängern können schwören. Die meisten Menschen haben bereits Bibliotheken wie JQuery, wenn sie JS verwenden müssen. Sie haben sie alle verkapselt, damit Sie die Typen leicht erkennen können. Natürlich ist es nicht problematisch zu erkennen, da der Satz "in JavaScript, alles ein Objekt ist", wie in vielen Dokumenten erwähnt, und undefined ist eigentlich nur ein globales Attribut mit Nan und Infinity. Sie wissen es wahrscheinlich. Aber "Objekt" kann uns helfen:
Die Codekopie lautet wie folgt:
/* Objekttyp erkennen
* @param: obj {JavaScript -Objekt}
* @param: Geben Sie {String} JS -Typenname ab, beginnend mit Großbuchstaben
* @return: {boolean}
*/
Funktion ist (OBJ, Typ) {
return Object.Prototype.toString.call (OBJ) .Slice (8, -1) === Typ;
}
Auf diese Weise können wir die IS -Funktion verwenden, um uns zu helfen, das Typenurteil zu lösen, und diese einfache Funktion hat eine gute Kompatibilität und kann in Ihrem Projekt verwendet werden. Situation ist wie:
Die Codekopie lautet wie folgt:
IS ('Sofish', 'String') // wahr
ist (null, 'null') // true
IS (new set (), 'set') // true
8. Conversion JavaScript Type
In JavaScript kann die Art der Variablen (Eigenschaften) geändert werden. Das häufigste, was Sie sehen, ist die Konvertierung zwischen String und Zahl. Wie verwandle ich 1 + '2' in 12? Es ist notwendig, den + Operator hier zu verstehen, der ein mathematischer Operator und auch ein String -Bindestrich in JavaScript ist. Daher sehen Anfänger oft ein interessantes Phänomen. Bei Verwendung des + Zeichens ist die Berechnung manchmal nicht das, was sie wollen, aber die Verwendung des Zeichens kann immer die "richtige" Antwort erhalten.
Die Codekopie lautet wie folgt:
1 + '2' // '12' '
1 + ( + '2') // 3
1 - '2' // -1
Dies wird tatsächlich durch die doppelte Rolle von +verursacht. Im obigen Code können Sie feststellen, dass der zweite Ausdruck vor der String ein + -Signmark verwendet und seine Klasse dazu zwingt, in die Nummer konvertiert zu werden. In den meisten Fällen reicht es für das Verständnis von JavaScript -Typen in den meisten Fällen aus, um zu verstehen. + Spielt eine doppelte Rolle. Andere verständliche Klassen, ähnliche, können mit Zuordnung/Überlastung geändert werden und sogar Fehler einschließen:
Die Codekopie lautet wie folgt:
var err = neuer error ();
console.log (Errinstanceof -Fehler); // WAHR
Err = 'Sofish';
console.log (err); // 'Sofish'
4. JavaScript -Referenztypen
Dies ist ein schwieriger Punkt in diesem Artikel. Im Vergleich zu Grundtypen können Referenzen Eigenschaften und Methoden hinzufügen. Referenzen sind ähnliche Werte, die eine Referenz sind, die dem Wert eines Referenztyps einer Variablen zugewiesen wird, und sie verweisen auf denselben Wert, der im Heap -Speicher gespeichert ist. Variablen (Eigenschaften) können überladen werden, aber das Kopieren wird eine sehr interessante Sache sein, wir werden später ausführlich darüber sprechen.
1. Fügen Sie Eigenschaften und Methoden hinzu
Wir werden im folgenden Code sehen, dass wir angenommen werden, dass wir keinen Fehler einer grundlegenden ähnlichen Zuordnung melden, aber beim Abrufen ungültig ist:
Die Codekopie lautet wie folgt:
var arr = [1,2,3];
arr.hello = 'Welt';
console.log (arr.hello); // 'Welt'
var str = 'Sofish';
Str.hello = 'Welt';
console.log (Str.hello); // undefiniert
2. Betrieb der Verweise auf Typwerte
Da der Referenztyp im Stapelspeicher gespeichert ist, ist die Operation auf dem Wert alle Referenzen, wenn wir auf denselben ursprünglichen Wert verweisen. Ein Beispiel hierfür ist, dass die Neuzuweisung (kein direkter Betrieb auf dem Wert) ein Objekt wiederherstellt und den ursprünglichen Wert nicht ändert. Zum Beispiel:
Die Codekopie lautet wie folgt:
var arr = [1,2,3], sofish = arr;
Sofish.push ('Hallo Welt');
console.log (arr); // [1, 2, 3, 'Hallo Welt']
// Nicht-same-Typ
Sofish = ['kein Fisch']; // Wenn sich Sofish ähnlich ändert, wird der ursprüngliche Wert nicht geändert
console.log (arr); // [1, 2, 3, 'Hallo Welt']
3.. Kopieren von Referenztypwerten
Operationen zum ursprünglichen Wert wirken sich auf alle Referenzen aus, was nicht unbedingt das ist, was wir wollen. Manchmal müssen wir ein brandneues Objekt kopieren, ohne andere Referenzen beim Betrieb zu beeinflussen. Im Allgemeinen gibt es nur wenige spezifische Vorgänge wie Datum / Funktion / Regexp ... vor allem, weil Array und Objekt zusätzliche Elemente, Attribute usw. haben. Wir müssen also verstehen, wie Array und Objektobjekte kopieren.
3.1 Kopieren von Arrays
Im Array -Objekt gibt es die Slice -Methode, um ein abgefangenes Array zurückzugeben, und im ES5 -Filter usw. senden Sie auch ein neues Array zurück, sodass wir diese Methode verwenden können, um zu kopieren.
Die Codekopie lautet wie folgt:
var arr = [1, 2, 3];
var sofish = arr.lice ();
// Der Betrieb auf Neuarrays wirkt sich nicht auf das ursprüngliche Array aus
Sofish.push ('Hallo Welt');
console.log (arr); // [1, 2, 3]
3.2 Kopieren von Objekten
Beim Array -Kopieren verwenden wir die Slice -Methode. Tatsächlich können wir für Array und Objekt die für ... in der Schleife verwenden, um zu durchqueren und zu kopieren Werte zuweisen.
Die Codekopie lautet wie folgt:
var obj = {name: 'sofish'}, sofish = {}, p;
für (p in obj) sofish [p] = obj [p];
// Der Betrieb auf neuen Objekten wirkt sich nicht auf den ursprünglichen Wert aus
sofish.say = function () {};
console.log (obj); // {name: 'sofish'}
3.3 Schatten/Tiefkopie
Wie bei der obigen Operation nennen wir oft Shadow Copy. Sowohl Array als auch Objekt können jedoch mehrere Schichten (Dimensionalität) haben. Kopieren Sie wie diese nur den Wert der obersten Ebene. Array und Objekt in möglichen Werten zeigen immer noch auf das ursprüngliche Objekt. Zum Beispiel:
Die Codekopie lautet wie folgt:
var arr = [1, {bio: 'kein fisch'}], sofish = [], p;
für (p in arr) {
Sofish [p] = arr [p];
}
// Operationen auf Objekten `cat`, die in` sofish` enthalten sind, beeinflussen den ursprünglichen Wert
Sofish [1] .bio = 'hackbar';
console.log (arr); // [1, kat: {bio: 'hackable'}]
Wie mache ich das? Verwenden wir eine Copy () -Funktion, um dieses Problem zu lösen:
Die Codekopie lautet wie folgt:
/* Das Objekt kopieren
* @param: obj {JavaScript -Objekt} Originalobjekt
* @param: isdeep {boolean} ist eine tiefe Kopie
* @Return: {JavaScript -Objekt} Gibt ein neues Objekt zurück
*/
Funktionskopie (OBJ, ISDEEP) {
var ret = obj.lice? []: {}, p, prop;
// Verwenden Sie mit der IS -Funktion
if (! isdeep && is (obj, 'array') return obj.slice ();
für (p in obj) {
if (! obj.hasownProperty (p)) Weiter;
prop = obj [p];
ret [p] = (ist (prop, 'objekt') || ist (prop, 'array')?
Kopie (prop, isdeep): prop;
}
Rückkehr;
}
Auf diese Weise können wir ein Array oder Objekt über die Funktion von Kopie (OBJ, ISDEEP) kopieren. Sie können es testen:
Die Codekopie lautet wie folgt:
var arr = [1, {bio: 'kein fisch'}];
var sofish = copy (arr);
// Flache Kopie wirkt sich nicht auf den ursprünglichen Wert für den Betrieb der ersten Schicht aus, sondern wirkt sich auf die zweite Schicht aus
Sofish.push ('Katze');
console.log (arr); // [1, {bio: 'kein Fisch'}]
Sofish [1] .bio = 'Hallo Welt';
console.log (arr) // [1, {bio: 'Hallo Welt'}]
// Deep Copy wirkt sich nicht auf den ursprünglichen Wert aus
Sofish = Copy (arr, 1);
Sofish [1] .bio = 'foo oder bar';
console.log (arr); // [1, {Bio: 'Hallo Welt'}]
Das war's. Sie sollten im Grunde die schwierigeren Punkte über Typen verstehen. Natürlich ist die Replikation der problematischste Punkt. Zusätzlich zu Array und Objekt, für das häufig der Betrieb erforderlich ist, gibt es auch die Replikation von Datum/Funktion/Regexp.