Neuarray ()
Neuanlage (Len)
Neuarray ([Item0, [Item1, [Item2, ...]]]]
Methoden zur Verwendung von Array -Objekten:
var objarray = new Array ();
objarray.concact ([item1 [, item2 [, ...]] ----------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------- und Rückkehr, Das ursprüngliche Array ist nicht betroffen.
arr.concact ("d", "e");
Gibt ein Array mit den Buchstabenelementen von "a" zu "e" zurück. Und arr selbst ist nicht betroffen.
Objarray.Join (Trennzeichen) ------------------------------------------------------------------------------------------------------------------------------------------------------------ -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---- )Dasselbe.
objarray.pop () -------- In Laiendaten soll das letzte Element des Arrays auftauchen. In Kombination mit der folgenden Push -Methode ist es möglich, Arrays als Stapel zu verwenden. Die POP -Methode gibt den Wert des letzten Elements des Arrays zurück und subtrahiert das Längenattribut um 1, dh das letzte Element geht unmittelbar nach der Rückkehr verloren.
objarray.push ([value1 [, value2 [, ...]]]) ------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Zum Beispiel: [1,2,3, 4] .push ("A", "B") wird [1,2,3,4, "A", "B"] bekommen
Objarray.Reverse () umdreht die Elemente im Array. Zum Beispiel: [1,2,3] .Reverse () wird [3,2,1] erhalten.
Objarray.Shift () ------------ Entfernen Sie das erste Element des Arrays und geben Sie den Wert dieses Elements zurück. Die Art dieser Methode ist der POP -Methode sehr ähnlich, die das letzte Element entfernen soll.
Objarray.Slice (Start, Ende) -------------- RECHTEN SIE EINE SUBSETZUNG DES ARBEITENS Das ursprüngliche Array ist nicht betroffen. Zum Beispiel: [1,2,3,4,5,6] .Slice (1,4) erhalten [2,3,4]. Wenn Start oder Ende negativ ist, werden sie verwendet, um den Längenwert hinzuzufügen. Zum Beispiel: [1,2,3,4,5,6] .Slice (-4, -1) wird [3,4,5] erhalten. Wenn das Ende weniger als oder gleich zu Beginn ist, wird ein leeres Array zurückgegeben.
objarray.sort (Comparefn) -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------- Die Funktion CompareFN muss zwei Parameter Element1 und Element2 akzeptieren. das heißt, halten Sie die ursprüngliche zurück) retektiert 0. Im Vergleich zugelassen werden die Elemente in der Wörterbuchordnung angeordnet. Zum Beispiel: Für die definierte Vergleichsfunktion CMP: Funktion CMP (e1, e2) {return e1-e2;}, dann [3,4,2,7] .Sort (CMP) erhalten [2,3,4,7 ].
Objarray.splice (Start, DeleteCount [, Item1, Item2 [, ...]]]) Dies ist eine komplexe Funktion, um das Löschen, die Substitution und das Einsetzen von Array -Elementen zu vervollständigen. Unter ihnen gibt der Startparameter die zu durchgeführte Indexposition an, und DeleteCount bezieht sich auf die Anzahl der von Anfang an gelöschten Elemente (einschließlich der Startposition). von Anfang an gelöscht. [, item1 [, item2 [, ...]]] bedeutet eine optionale Liste der vor dem Start eingefügten Elemente. wie:
var arr = [0,1,2,3,4,5,6];
Arr.SPLICE (1,1);
document.write (arr); // anzeigen "0, 2, 3, 4, 5, 6"
arr = [0,1,2,3,4,5,6];
arr.splice (0,0, "a", "b");
document.write (arr); // zeigen "a, b, 0,1,2,3,4,5,6"
arr = [0,1,2,3,4,5,6];
Arr.SPLICE (3,2, "C", "D");
document.write (arr); // anzeigen "0,1,2, c, d, 5,6"
objarray.unshift (item1 [, item2 [, ...]]) ----------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------- Seine Eigenschaften und Push -Methodentyp, aber die Push -Methode besteht darin, Elemente zum Ende des Arrays hinzuzufügen. Zum Beispiel: [1,2,3,4] .Unshift ("A", "B") wird ["A", "B", 1,2,3,4] bekommen.
Die Hinzufügung und Löschung von JS-Array-Elementen war heute verwirrend.
var arr = new Array ();
arr [0] = "aaa";
arr [1] = "BBB";
arr [2] = "CCC";
//alert(arr.length);//3
arr.pop ();
//alert(arr.length);//2
//alert(arr-arr.length-1 weibliches);//bbb
arr.pop ();
//alert(arr-arr.length-1 weibliche ))//aaa
//alert(arr.length);//1
var arr2 = new Array ();
//alert(arr2.Length);//0
arr2 [0] = "aaa";
arr2 [1] = "BBB";
//alert(arr2.Length);//2
arr2.pop ();
//alert(arr2.Length);//1
arr2 = arr2.slice (0, arr2.Length-1);
//alert(arr2.Length);//0
arr2 [0] = "aaa";
arr2 [1] = "BBB";
arr2 [2] = "CCC";
arr2 = arr2.slice (0,1);
ALERT (arr2.Length); // 1
Alert (arr2 [0]); // aaa
ALERT (arr2 [1]); // undefiniert
Verschiebung: Löschen Sie das erste Element des ursprünglichen Arrays und geben Sie den Wert des gelöschten Elements zurück.
var a = [1,2,3,4,5];
var b = a.shift ();
nicht geschaltet: Fügen Sie den Parameter zum Beginn des ursprünglichen Arrays hinzu und geben Sie die Länge des Arrays zurück
var a = [1,2,3,4,5];
var b = a.unshift (-2, -1);
HINWEIS: Der Test -Rückgabewert in IE6.0 ist immer undefiniert, und der Test -Return -Wert in FF2.0 beträgt 7, sodass der Rückgabewert dieser Methode unzuverlässig ist. dieser Methode.
Pop: Löschen Sie das letzte Element des ursprünglichen Arrays und geben Sie den Wert des gelöschten Elements zurück.
var a = [1,2,3,4,5];
var b = a.pop ();
Drücken: Fügen Sie den Parameter zum Ende des ursprünglichen Arrays hinzu und geben Sie die Länge des Arrays zurück
var a = [1,2,3,4,5];
var b = a.push (6,7);
CONECAT: Gibt ein neues Array zurück, das aus dem Hinzufügen von Parametern zum ursprünglichen Array besteht.
var a = [1,2,3,4,5];
var b = A.Concat (6,7);
Spleiß (Start, DeleteCount, Val1, Val2, ...): DeleteCount -Element aus der Startposition und einfügen Val1, Val2, ...
Geben Sie beim Löschen des Arrays einfach den StartIndex vorbei.
Wenn nicht alle Elemente gelöscht werden, übergeben Sie den Parameter DeleteCount.
Splice hat auch die Funktion, zuerst mehrere Elemente zu löschen und dann mehrere Elemente an der gelöschten Position zu löschen. .
var a = [1,2,3,4,5];
var b = A.SPLICE (2,2,7,8,9);
var b = A.Splice (0,1);
A.SPLICE (0,0, -2, -1);
var b = A.Splice (A.Length-1,1); // gleicher Pop
A.SPLICE (A.Length, 0,6,7);
Reverse: Inverse das Array
var a = [1,2,3,4,5];
var b = A.Reverse ();
Sortieren (OrderFunction): Sortieren Sie das Array nach angegebenen Parametern
var a = [1,2,3,4,5];
var b = a.sort ();
Slice (Start, Ende): Gibt ein neues Array zurück, das aus Elementen aus dem angegebenen Start -Index zum End -Index im ursprünglichen Array besteht.
var a = [1,2,3,4,5];
var b = a.slice (2,5);
Join (Separator): Gruppen Sie die Elemente des Arrays in eine Zeichenfolge mit dem Trennzeichen als Trennzeichen, falls weggelassen, das Standardkomma als Trennzeichen
var a = [1,2,3,4,5];
var b = a.join ("|");
Hier ist eine weitere Möglichkeit, Array zu verwenden, um JavastringBuffer zu simulieren, um Zeichenfolgen zu verarbeiten:
Die Codekopie lautet wie folgt:
/**
* String -Verarbeitungsfunktion
*/
Funktion StringBuffer () {
var arr = new Array;
this.append = function (str) {
arr [arr.length] = str;
};
this.toString = function () {
Gibt arr.join ("") zurück; // Ping das Array, das sich in eine Zeichenfolge anzieht
};
}
Heute habe ich plötzlich festgestellt, dass Join eine gute Möglichkeit ist, Arrays in Strings in der Anwendung umzuwandeln. Deshalb habe ich sie in Objekte eingekapselt und verwendet:
Die Codekopie lautet wie folgt:
/**
*Umwandeln Sie Arrays in Zeichenfolgen, die durch bestimmte Symbole aufgeteilt werden
*/
FunktionsarrayToString (arr, Separator) {
if (! separator) separator = ""; // Wenn ein Trennzeichen null ist, ist es standardmäßig leer
return arr.join (Trennzeichen);
}
/**
* Finden Sie die im Array enthaltene Zeichenfolge
*/
Funktion ArrayFindString (arr, String) {
var str = arr.join ("");
return Str.Indexof (String);
}