Eine kurze Analyse des Array -Typsystems in JavaScript

Die vorherigen Wörter

Ein Array ist eine Reihe von Werten, die in der Reihenfolge angeordnet sind und im Verhältnis zu den Eigenschaftsnamen des Objekts nicht in Ordnung sind. Im Wesentlichen verwenden Arrays Zahlen als Suchschlüssel, während Objekte benutzerdefinierte Attributnamen haben. JavaScript hat keine realen assoziativen Arrays, aber Objekte können verwendet werden, um die Funktion von Associativ zu implementieren

Array () ist nur eine spezielle Art von Objekt (), dh eine Array () -Instanz ist im Grunde genommen eine Objekt () -Instanz mit zusätzlichen Funktionen. Arrays können alle Wertesorten enthalten, die jederzeit aktualisiert oder gelöscht werden können, und die Größe des Arrays wird dynamisch eingestellt.

Zusätzlich zu Objekten ist der Array -Array -Typ wahrscheinlich der am häufigsten verwendete Typ in JavaScript. Darüber hinaus unterscheiden sich Arrays in JavaScript von denen in den meisten anderen Sprachen. In diesem Artikel wird der Array -Array -Typ in JavaScript eingeführt

Erstellen Sie ein Array

Es gibt zwei Möglichkeiten, ein Array zu erstellen: Verwenden der wörtlichen Syntax und Verwendung von Array () Konstruktor

【Buchstäblich】

Die Verwendung von Array -Literalen ist der einfachste Weg, um ein Array zu erstellen. Separate Array -Elemente mit Kommas in quadratischen Klammern

 var leer = []; // Array ohne Elemente var primes = [2,3,5,7,11]; // Array mit 5 Werten Array

Obwohl JavaScript -Arrays sowohl Datenlisten als auch Arrays in anderen Sprachen geordnet sind, kann jedes Element von JavaScript -Arrays im Gegensatz zu anderen Sprachen jegliche Art von Daten enthalten

 var misc = [1.1, wahr, "a"]; // 3 Elemente verschiedener Typen

Die Werte in Array -Literalen müssen keine Konstanten sein, sie können jeder Ausdruck sein

 var base = 1024; var table = [Base, Base+1, Base+2, Base+3];

Es kann Objektliterale oder andere Array -Literale enthalten

 var b = [[1, {x: 1, y: 2}], [2, {x: 3, y: 4}]];

Wenn die Elemente des Arrays noch Arrays sind, wird ein mehrdimensionales Array gebildet

 var a = [1, 2], [3, 4]];

[Hinweis] Bei der Verwendung numerischer wörtlicher Notation wird der Array -Konstruktor nicht aufgerufen

【Konstruktor】

Es gibt drei Möglichkeiten, Konstruktoren anzurufen

【1】 Keine Parameter, erstellen Sie ein leeres Array

 // Diese Methode erstellt ein leeres Array ohne Elemente, das der direkten Menge des Array [] var a = new Array () entspricht;

【2】 Es gibt einen numerischen Parameter, der verwendet wird, um die Länge des Arrays anzugeben

 var a = neuarray (10); console.log (a); // [] console.log (a [0], a.Length); // undefined 10

[Hinweis] Wenn es einen anderen Parametertyp gibt, wird ein Array, das nur diejenigen dieses Wertes enthält, erstellt

 var a = new Array ('10 '); console.log (a); // [' 10 '] console.log (a [0], A.Length); // 10 1 1

【3】 Wenn mehrere Parameter vorliegen, werden die Parameter als spezifische Elemente des Arrays dargestellt

 var a = Neuarray (1,2,3); Konsole.log (a); // [1,2,3] console.log (a [0], a [1], a [2]); // 1 2 3 3 3

Bei Verwendung des Array () -Konstruktors kann der neue Bediener weggelassen werden

 var a1 = array (); var a2 = array (10); var a3 = array (1,2,3); console.log (a1, a2, a3); // [] [] [] [1,2,3]

Array Natur

Arrays sind eine Reihe von Werten, die in der Reihenfolge angeordnet sind. Im Wesentlichen sind Arrays spezielle Objekte.

 Typof [1, 2, 3] // "Objekt"

Die Besonderheit eines Arrays spiegelt sich darin wider, dass seine Schlüsselnamen eine Reihe von Ganzzahlen (0, 1, 2…) sind, die in der Reihenfolge angeordnet sind. Da die Schlüsselnamen der Array -Mitglieder festgelegt sind, muss das Array für jedes Element keinen Schlüsselnamen angeben, aber jedes Mitglied des Objekts muss einen Schlüsselnamen angeben.

 var arr = ['a', 'b', 'c']; console.log (Object.Keys (arr)); // ["0", "1", "2"] var obj = {name1: 'a', name2: 'b', name3: 'c'};

Arrays sind spezielle Formen von Objekten. Der Zugriff auf Array -Elemente mit quadratischen Klammern ist wie der Zugriff auf Objekte Eigenschaften mit quadratischen Klammern.

Die JavaScript -Sprache sieht vor, dass die Schlüsselnamen von Objekten Zeichenfolgen sind, sodass die Schlüsselnamen von Arrays tatsächlich Saiten sind. Der Grund, warum es mit numerischen Werten gelesen werden kann

 o = {}; // Erstellen Sie ein gewöhnliches Objekt o [1] = "eins"; // Index es mit einer Ganzzahl // Der numerische Schlüsselname wird automatisch in eine Zeichenfolge var arr = ['a', 'b', 'c'] konvertiert; arr ['0'] // 'a'arr [0] //' a ''

Es ist jedoch notwendig, zwischen Array-Index- und Objektattributnamen zu unterscheiden: Alle Indizes sind Attributnamen, aber nur Integer-Attributnamen zwischen 0 ~ 232-2 (4294967294) sind Indizes

 var a = []; // index a ['1000'] = 'abc'; a [1000] // 'abc' // index a [1.00] = 6; a [1] // 6

[Anmerkung] Einzelne Werte können nicht als Bezeichner verwendet werden. Daher können Array -Mitglieder nur in quadratischen Klammern ausgedrückt werden

 var arr = [1, 2, 3]; arr [0]; // 1arr.0; // syntaxError

Ein Array kann unter Verwendung negativer oder Nichtteger-Zahlen indiziert werden. Da es jedoch nicht innerhalb des Bereichs von 0 ~ 2 bis zur Leistung von 32 -2 liegt, ist es nur der Attributname des Arrays, nicht der Index des Arrays. Das offensichtliche Merkmal ist, dass es nicht die Länge des Arrays ändert

 var a = [1,2,3]; // Attributname a [-1.23] = true; console.log (a.Length); // 3 // index a [10] = 5; console.log (a.Length); // 11 // Attributname a ['Abc'] = 'Testen'; console.log (a.Länge); // 11; // 11; // 11; // 11; // 11; // 11;

Spärliche Arrays

Ein spärliches Array ist ein Array, das diskontinuierliche Indizes ab 0 enthält.

【1】 Der direkteste Weg, um spärliche Arrays herzustellen

 var a = [1,2,3,4,5]; a [1]; console.log (a [1]); // undefinedconsole.log (1 in a); // false

【2】 Elementwerte können zwischen Commas von Arrays weggelassen werden, und es können spärliche Arrays erstellt werden, indem Elementwerte weggelassen werden.

 var a = [1, 3,4,5]; console.log (a [1]); // undefinedconsole.log (1 in a); // false

[Anmerkung] Es gibt eine Differenz zwischen dem ausgelassenen Elementwert und dem Elementwert, dessen Wert undefiniert ist.

 var a = [1, 3,4,5]; console.log (a [1]); // undefinedconsole.log (1 in a); // falsevar a = [1, undefined, 3,4,5]; console.log (a [1]); // undefinedConsole.log (1 in a);

Wenn Sie Kommas am Ende des Arrays verwenden, gibt es Unterschiede zwischen den Browsern. Das Komma wird vom Standardbrowser ignoriert, während der IE8-Browser am Ende einen undefinierten Wert hinzufügt

 // Standard-Browserausgabe [1,2], während der IE8-Browser-Ausgang [1,2, undefined] var a = [1,2,] Konsole.log (a); // Standard-Browserausgabe 2, während IE8-Browserausgabe 3var A = [,,]; console.log (A.Length);

Arrays, die spärlich genug sind, sind in der Umsetzung normalerweise langsamer als dichte Arrays und haben eine höhere Speicherauslastung, und die Zeit, Elemente in einem solchen Array nachzuschlagen

Arraylänge

Jedes Array hat ein Längenattribut, das dieses Attribut ist, das es von herkömmlichen JavaScript -Objekten unterscheidet. Für dichte (dh Nicht-Parse-) Arrays repräsentiert der Längenattributwert die Anzahl der Elemente im Array, und sein Wert ist 1 größer als der größte Index im Array.

 [] .Length // => 0: Das Array hat keine Elemente ['A', 'B', 'C']. Länge // => 3: Der maximale Index beträgt 2 und die Länge beträgt 3

Wenn ein Array ein spärliches Array ist, ist der Längenattributwert größer als die Anzahl der Elemente. In ähnlicher Weise ist sein Wert 1 größer als der größte Index im Array

 [,,].Länge; //3(Array(10)).Length;

Die Besonderheit der Arrays spiegelt sich hauptsächlich darin wider, dass die Länge des Arrays dynamisch eingestellt werden kann:

【1】 Wenn Sie einem Array -Element einen Wert zuweisen und der Index I größer oder gleich der Länge des vorhandenen Arrays ist, wird der Wert des Längenattributs auf i+1 gesetzt

 var arr = ['a', 'b']; arr.length // 2arr [2] = 'c'; arr.length // 3arr [9] = 'd'; arr.length // 10arr [1000] = 'e'; arr.Length // 1001

【2 °

 a = [1,2,3,4,5]; // aus dem Array von 5 Elementen A.Length = 3; // jetzt ist a ist [1,2,3] A.Length = 0; // Alle Elemente löschen. a ist [] a.länge = 5; // Die Länge beträgt 5, aber es gibt keine Elemente, genau wie neu

Array (5)

[Hinweis] Ein effektiver Weg, um das Array zu löschen, besteht darin, die Länge Eigenschaft auf 0 einzustellen

 var arr = ['a', 'b', 'c']; arr.length = 0; arr // []

【3】 Stellen Sie den Längenattributwert des Arrays so ein, dass es größer ist als seine Stromlänge. Tatsächlich fügt dies dem Array keine neuen Elemente hinzu, sondern schafft nur einen leeren Bereich am Ende des Arrays

 var a = ['a'];

Wenn die Länge auf einen illegalen Wert festgelegt wird (d. H. Einen Wert außerhalb des Bereichs 0--232-2), meldet JavaScript einen Fehler

 // Negativen Wert setzen []. Länge = -1 // Dauerror: Ungültige Arraylänge // Die Anzahl der Array -Elemente ist größer oder gleich 2 bis zur Leistung von 32 []. Länge = Math.Pow (2,32) // RangeRor: Ungültige Arraylänge // Set String []. Länge = 'Abc' // Bereich: Ungültige Arraylänge: Ungültige Arraylänge: Ungültige Arraylänge.

Da ein Array im Wesentlichen ein Objekt ist, können Sie dem Array Attribute hinzufügen, dies hat jedoch keinen Einfluss auf den Wert des Längenattributs

 var a = []; a ['p'] = 'abc'; console.log (A.Length); // 0a [2.1] = 'ABC'; console.log (A.Length); // 0

Array Traversal

Die häufigste Möglichkeit, die Array -Elemente für die Schleife zu durchqueren

 var a = [1, 2, 3]; für (var i = 0; i <a.length; i ++) {console.log (a [i]);}

Natürlich können Sie auch eine Weile Schleife verwenden

 var a = [1, 2, 3]; var i = 0; while (i <a.Length) {console.log (a [i]); i ++;} var l = A.Length; while (l-) {console.log (a [l]);};

Wenn das Array jedoch ein spärliches Array ist, verwenden Sie eine für die Schleife und Sie müssen einige Bedingungen hinzufügen

 // Nicht existierendes Element überspringen var a = [1 ,,, 2]; für (var i = 0; i <a.länge; i ++) {if (! (I in a)) Fortsetzung; Konsole.log (a [i]);}

Sie können auch für/in Schleifen verwenden, um spärliche Arrays zu verarbeiten. Die Schleife weist der Schleifenvariable jeweils einen aufzählbaren Attributnamen (einschließlich Array -Index) zu. Der nicht existierende Index wird nicht durchquert

 var a = [1 ,,, 2]; für (var i in a) {console.log (a [i]);}

Da die für/in der Schleife ererbte Attributnamen aufzählen kann, wie z. B. Methoden, die zu Array.Prototyp hinzugefügt wurden. Aus diesem Grund sollten für/in Schleifen nicht in Arrays verwendet werden, es sei denn

 var a = [1 ,,, 2]; ab = 'b'; für (var i in a) {console.log (a [i]); // 1 2 'b'} // überspringen ivar a = [1 ,,, 2]; ab = 'b'; für (var i in a) {if (String (math.floor (math.abs Weiter; console.log (a [i]); // 1 2}

Die JavaScript -Spezifikation ermöglicht es für/in Schleifen, die Eigenschaften eines Objekts in verschiedenen Ordnungen zu durchqueren. Normalerweise befindet sich die Durchführung von Array -Elementen in der Aufstieg, kann jedoch nicht so garantiert wie dieses sind. Insbesondere wenn ein Array sowohl Objektattribute als auch Array -Elemente hat, sind die zurückgegebenen Attributnamen wahrscheinlich in der Reihenfolge, in der sie erstellt wurden, und nicht in der Reihenfolge der numerischen Größe. Wenn der Algorithmus von der Reihenfolge der Traversal abhängt, ist es am besten, nicht für/in zu verwenden, sondern regulär für Schleifen zu verwenden

Klassenarray

Objekte mit Längenattributen und entsprechenden nicht negativen Ganzzahlattributen werden als Array-ähnliche Objekte bezeichnet

 // Klassenarray -Demonstration var a = {}; var i = 0; while (i <10) {a [i] = i*i; i ++;} A.Length = i; var total = 0; für (var j = 0; j <A.Length; j ++) {total+= a [j];};}

Es gibt drei gemeinsame Klassenarray -Objekte:

【1】 Argumente Objekt

 // Argumente Objektfunktion args () {Rückgabeargumente} var arraylike = args ('a', 'b'); arraylike [0] // 'a'arraylike.length // 2Array -Like -Instanz von Array // false

【2】 Objekt, das nach DOM -Methode zurückgegeben wurde (z. B. document.GetElementsByTagName () Methoden)

 // DOM -Element var elts = document.GetElementsByTagName ('H3'); ELTS.Length // 3ELTS INSTANCEOF Array // Falsch

【3】 String

 // String 'ABC' [1] // 'b''Abc'.length // 3'abc' Instanz von Array // Falsch

[Hinweis] Zeichenfolgen sind unveränderliche Werte. Wenn sie also als Arrays betrachtet werden, sind sie schreibgeschützt. Zum Beispiel werden Push (), Sort (), Reverse (), Splice () und andere Array -Methoden das Array ändern. Sie sind in der Zeichenfolge ungültig und melden einen Fehler

 var str = 'abc'; array.prototype.foreach.call (str, function (chr) {console.log (chr); // abc}); array.prototype.splesplice

Die Slice -Methode eines Arrays verwandelt das Klassenarray -Objekt in ein reales Array

 var arr = array.prototype.slice.call (arrayähnlich);

JavaScript -Array -Methoden sind speziell als allgemein definiert, sodass sie nicht nur für reale Arrays, sondern auch für Klassenarray -Objekte korrekt funktionieren. In ECMascript5 sind alle Array -Methoden allgemein. In ECMascript3 sind auch alle Methoden mit Ausnahme von toString () und Tolocalestring () häufig

 var a = {'0': 'a', '1': 'b', '2': 'c', Länge: 3}; array.prototype.join.call (a, '+'); // 'a+b+c'array.p rototype.slice.call (a, 0); // ['a', 'b', 'c'] array.prototype.map.call (a, function (x) {return X.ToUppercase ();}); // ['A', 'B', 'C']]