Die vorherigen Wörter
Es gibt 22 Methoden im Array. Dieser Artikel unterteilt sie in Objekt -Vererbungsmethoden, Array -Konvertierungsmethoden, Stapel- und Warteschlangenmethoden, Array -Sortiermethoden, Array -Spleißmethoden, Methoden zur Erstellung von Subarray -Erstellungen, Array -Löschmethoden, Array -Positionsmethoden, Array -Merge -Methoden und Array -Iterationsmethoden im Detail.
Objektvererbungsmethode
Array ist ein spezielles Objekt, das die Methoden toString (), Tolocalestring () und ValueOf () des Objektobjekts erbt.
【ToString ()】
Die Methode toString () gibt eine von der Kommas getrennte Zeichenfolge zurück, die aus der Zeichenfolgeform jedes Werts im Array gespleißt wird.
[Anmerkung] Der Rückgabewert dieser Methode entspricht der Zeichenfolge, die durch Aufrufen der join () -Methode ohne Parameter zurückgerufen wird.
[1,2,3] .ToString (); // '1,2,3' ['A', 'B', 'C']. ToString (); // 'a, b, c' [1, [2, 'C']. Tostring (); // '1,2, C'
Da Alert () String -Parameter empfangen will, wird die Methode toString () im Hintergrund aufgerufen und das gleiche Ergebnis wie die Methode toString () erhalten
Alarm ([1,2,3]); // '1,2,3'
【Tolocalestring ()】
Tolocalestring () ist eine lokalisierte Version der Methode toString (), die häufig den gleichen Wert wie die ToString () -Methode zurückgibt, aber nicht immer der Fall ist. Da es das Element nennt, wandelt die Methode Tolocalestring () jedes Array -Element in eine Zeichenfolge um
var person1 = {tolocalestring: function () {return 'nikolaos';}, toString: function () {return 'nikolas';}}; var person2 = {tolocalestring: function () {return 'grigorios'; [Person1, Person2]; console.log (people.toString ()); // 'nikolas, Greg'console.log (people.tolocalestring (); //' Nikolas, Grigorios ''Wenn der Wert eines Elements im Array null oder undefiniert ist, wird der Wert als leerer Zeichenfolge in den Ergebnissen dargestellt, die von den Methoden Tolocalestring () und toString () zurückgegeben werden.
var colors = [1, undefiniert, 2, null, 3]; console.log (farben.tostring ()); // '1,, 2,, 3'console.log (Colors.tolocalestring (); //' 1, 2, 3 '
【Valueof ()】
Die ValueOf () -Methode gibt das Array -Objekt selbst zurück
var a = [1, 2, 3]; console.log (a.ValueOf ()); // [1, 2, 3] Konsole
Array Conversion -Methode
【verbinden()】
Die Methode array.join () ist eine inverse Operation der String.Split () -Methode, die die Zeichenfolge in mehrere Blöcke aufteilt, um ein Array zu erstellen.
Die von Arrays geerbten Methoden Tolocalestring () und toString () werden standardmäßig in an Kommas getrennten Zeichen zurückgeführt. Mit der Methode join () kann verschiedene Grenzwerte verwendet werden, um diese Zeichenfolge zu erstellen. Mit der Methode join () empfängt nur einen Parameter, der als Trennzeichen verwendet wird, und gibt dann eine Zeichenfolge zurück, die alle Array -Elemente enthält.
Wenn kein Wert an die join () -Methode übergeben wird, verwenden Sie ein Komma als Trennzeichen
var a = [1,2,3]; console.log (a.join ()); // '1,2,3'console.log (A.Join (' '); //' 1 2 3'console.log (A.Join (''); // '123'Var B = New New New'n New neu Array (10); B.Join ('-'); // '------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Wenn der Parameter der join () -Methode undefiniert ist, gibt der Standardbrowser die Zeichenfolge mit einem Komma als Trennzeichen zurück, und der IE7-Browser gibt die Zeichenfolge mit 'undefiniertem' als Trennzeichen zurück.
// Der Standardbrowser ist '1,2,3'; IE7-Der Browser ist '1undefined2undEFINed3'var a = [1,2,3]; Konsole.log (A.Join (undefined));
Wenn der Wert eines Elements im Array null oder undefiniert ist, wird der Wert als leerer Zeichenfolge im Ergebnis dargestellt, das von der join () -Methode zurückgegeben wird
var colors = [1, undefiniert, 2, null, 3]; console.log (colors.join ()); // '1,, 2,, 3'
Diese Methode kann auch für Klassenarray -Objekte verwendet werden
console.log (array.prototype.join.call ('hello', '-')); // "hello" var obj = {0: 'a', 1: 'b', länge: 2}; console.log (array.Prototype.join.call (obj, '-'); // 'ab' ab ';[Hinweis] Wenn das Objekt kein Längenattribut hat, handelt es sich nicht um ein Klassenarray, und die Array -Methode kann nicht aufgerufen werden
var obj = {0: 'a', 1: 'b'}; console.log (typeof array.prototype.join.call (obj, '-')); // '' ''Stapel- und Warteschlangenmethoden
Mit den Methoden Push () und Pop () können Arrays als Stapel verwendet werden. Das Verhalten von Unshift () und Shift () -Methoden ist sehr ähnlich zu Push () und Pop (). Der Unterschied besteht darin, dass die ersteren Elemente an der Spitze des Arrays und nicht am Schwanz löschen.
Der Stapel ist eine LIFO-Datenstruktur (Last-First-Out, später in der ersten Out), dh der neueste hinzugefügte Element wird frühestens entfernt. Die Einfügung (als Pushing genannt) und Entfernung (Popup -als Popup) im Stapel findet nur an einem Ort statt - die Oberseite des Stapels. JavaScript bietet PUSP () und POP () -Methoden speziell für Arrays, um ein stapelähnliches Verhalten zu erreichen
Die Zugriffsregel für die Warteschlangendatenstruktur ist FIFO (Erst-in-First-Out, First-In-In-In-Out). Die Warteschlange fügt am Ende der Liste Elemente hinzu und entfernt Elemente am vorderen Ende der Liste. Mit den Methoden "Shift () und Push () in Kombination können Sie Arrays wie Warteschlangen verwenden
【drücken()】
Die PUSP () -Methode kann eine beliebige Anzahl von Parametern empfangen, sie einzeln zum Ende des Arrays hinzufügen und die Länge des modifizierten Arrays zurückgeben. Das Array ändert also das ursprüngliche Array
var a = []; console.log (a, a.push (1)); // [1] 1console.log (a, a.push ('a'); // [1, ']] 2console.log (a, a.push (true, {}); // [1,' a ', wahr, {{}] 4console.log (a, a.push ([5,6])); // [1, 'a', true, {}, [5,6]] 5Wenn Sie zwei Arrays zusammenführen müssen, können Sie die Anwendenmethode verwenden
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.apply (a, b)); // [1,2,3,4,5,6] 6
[Hinweis] Wenn Sie die Anrufmethode verwenden, wird das Array B als Ganzes als Parameter angesehen
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.call (a, b)); // [1,2,3, [4,5,6]] 4
Push () -Methode kann dem Objekt auch Elemente hinzufügen, und das hinzugefügte Objekt wird zu einem Array -Objekt, dh dem Index des entsprechenden Arrays des Taste des neu hinzugefügten Elements, und das Objekt hat ein Längenattribut
var obj = {a: 1}; console.log (obj, [] push.call (obj, 2)); // {a: 1, 0: 2, länge: 1} console【Pop()】
Die POP () -Methode entfernt das letzte Element vom Ende des Arrays, reduziert den Längenwert des Arrays und gibt den entfernten Element zurück. Das Array ändert also das ursprüngliche Array
var a = ['a', 'b', 'c']; console.log (a, a.pop ()); // ['a', 'b'] 'c'
Die Verwendung von POP () -Methoden für leere Arrays meldet keinen Fehler, sondern kehrt undefined zurück
var a = []; console.log (a, a.pop ()); // [] undefiniert
【Schicht()】
Die Shift () -Methode entfernt das erste Element im Array und gibt das Element zurück, während die Länge des Arrays um 1. reduziert wird. Das Array ändert also das ursprüngliche Array
var a = ['a', 'b', 'c']; console.log (a, a.shift ()); // ['b', 'c'] 'a' '' '
Verwenden Sie die Methode für leere Arrays für leere Arrays, und es wird kein Fehler gemeldet, wird jedoch undefiniert zurückkehren
var a = []; console.log (a, a.shift ()); // [] undefiniert
【Unshift ()】
Die Unshift () -Methode fügt ein beliebiges Element am vorderen Ende des Arrays hinzu und gibt die neue Arraylänge zurück. Das Array ändert also das ursprüngliche Array
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x')); // ['x', 'a', 'b', 'c'] 4Wenn Unshift () mit mehreren Parametern aufgerufen wird, werden die Parameter gleichzeitig gleichzeitig eingefügt. Dies bedeutet, dass die Reihenfolge der im endgültigen Array eingefügten Elemente mit ihrer Reihenfolge in der Parameterliste übereinstimmt
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x', 'y', 'z'); // ['x', 'y', 'z', 'a', 'b', 'c'] 6[Hinweis] In IE7-Browser gibt die Unshift () -Methode immer undefiniert zurück
// In Standardbrowser return [1] 1; und in IE7-Browser return [1] undefinedvar a = []; console.log (a, a.unshift (1));
Array -Sortiermethode
Es gibt zwei Methoden im Array, mit denen sie direkt neu ordnen können: Reverse () und Sort ()
【umkehren()】
Reverse () Methode wird verwendet, um die Reihenfolge des Arrays umzukehren und das sortierte Array zurückzugeben. Und die ursprüngliche Array -Bestellung hat sich ebenfalls geändert.
var array = [1,2,4,3,5]; console.log (Array, Array.Reverse ()); // [5,3,4,2,1] [5,3,4,2,1] var array = ['str', wahr, 3]; trsole.log (Array, Array.Reverse ();
【Sortieren()】
Standardmäßig ordnen die Sort () -Methode Array -Elemente in aufsteigender Reihenfolge der Zeichenfolgen an. Die Sortiermethode ruft die Methode toString () jedes Array -Elements auf und vergleichen dann die resultierende Zeichenfolge, um das sortierte Array zurückzugeben, und die ursprüngliche Array -Reihenfolge ändert sich auch.
var array = [1,2,4,3,5]; console.log (array, array.sort ()); // [1,2,3,4,5] [1,2,3,4,5] var array = ['3str', 3,2, '2']; console.log (Array, Array.Sort (); [1,5,10,50]; Konsole.log (Array, Array.Sort ()); // [1, 10, 5, 50]
Wenn das Array undefinierte Elemente enthält, werden sie am Ende des Arrays platziert
var array = ['3', 3, undefined, 2, '2']; console.log (Array, Array.Sort ()); // ["2", 2, "3", 3, undefined] ["2", 2, "3", 3, undefined]
Die Sort () -Methode kann eine Vergleichsfunktion als Argument akzeptieren, um anzugeben, welcher Wert von welchem Wert vorangegangen ist. Die Vergleichsfunktion empfängt zwei Parameter, gibt eine negative Zahl zurück, wenn der erste Parameter vor dem zweiten Parameter vorliegt, 0 zurückgibt, wenn die beiden Parameter gleich sind, und eine positive Zahl zurückgibt, wenn der erste Parameter nach dem zweiten Parameter erfolgt
Funktion compare (value1, value2) {if (value1 <value2) {return -1;} else if (value1> value2) {return 1;} else {return 0;}} var array = ['5px', 50,1,10]; // Wenn der String größer als der String '5px' wird, wird das Ergebnis falsch und der falsche String ist. seconsole.log (array.sort (compare)); // ["5px", 1, 10, 50]Bei numerischen Typen oder ValueOf () -Methoden kann die Vergleichsfunktion den Objekttyp des numerischen Typs vereinfachen.
Funktion Compare (value1, value2) {return value1 - value2;} var array = ['5px', 50,1,10]; console.log (array.sort (vergleichen)); // ["5px", 1,10,50] var array = [5,50,10,10]; console.log (array.sort ();Wenn eine Reihe von Zeichenfolgen unempfindlichem Alphabet -Sortieren durchgeführt wird, wandelt die Vergleichsfunktion zunächst die Parameter in Kleinkappenketten um und startet dann den Vergleich
a = ['Ant', 'Bug', 'Cat', 'Dog']; A.Sort (); // ['Bug', 'Hund', 'Ant', 'Cat']; 0;}); // ['Ant', 'Bug', 'Katze', 'Hund']
【Tipps】 Erstellen Sie ein zufälliges Array mit der Sort () -Methode
Funktion Compare () {return math.random () - 0,5;} var array = [1,2,3,4,5]; console.log (array.sort (vergleich)); // [2,1,5,4,3]Array -Stitching -Methode
【Concat ()】
Die concat () -Methode erstellt ein neues Array, das auf allen Elementen im aktuellen Array basiert. Erstellen Sie zuerst eine Kopie des aktuellen Arrays, fügen Sie dann die empfangenen Parameter zum Ende der Kopie hinzu und gibt schließlich das neu erstellte Array zurück. Daher wirkt sich concat () nicht auf das ursprüngliche Array aus
Wenn der Parameter nicht an die concat () -Methode übergeben wird, kopiert er einfach das aktuelle Array; Wenn der Parameter ein oder mehrere Arrays ist, fügt die Methode jedes Element in diesen Arrays dem Ergebnisarray hinzu. Wenn der übergebene Wert kein Array ist, werden diese Werte einfach zum Ende des Ergebnisarrays hinzugefügt
var numbers = [1,2]; console.log (numbers, numbers.concat (3,4)); // [1,2] [1,2,3,4] console.log (numbers, number.concat ([5,4,3], [3,4,5], 1,2)); // [1,2] [1,2,5,4,3,3,4,5,1,2] console.log (Zahlen, Zahlen.Concat (4, [5, [6,7]])); // [1,2] [1,2,4,5, [6,7]]
Wenn keine Parameter bereitgestellt werden, gibt die concat () -Methode eine flache Kopie des aktuellen Arrays zurück. Die sogenannte "flache Kopie" bedeutet, dass das neue Array, der einen Verweis auf den Wert kopiert, wenn das Array-Element einen Verbindungsartwert (z. B. ein Objekt) enthält.
// Diese Methode kopiert tatsächlich nur die erste Dimension des Arrays. Die erste Dimension des Arrays speichert die Referenz der zweiten Dimension, und die zweite Dimension speichert tatsächlich ihre Inhalts -Var -Zahlen = [1,2]; var newnumbers = numbers.concat (); Konsole.log (Zahlen, Newnumbers); // [1,2] [1,2] Zahlen [0] = 0; console.log (Zahlen). [[1,2];
Die concat () -Methode kann auch verwendet werden, um Objekte in Arrays zusammenzuführen, muss jedoch mit der CALL () -Methode erfolgen.
var newarray = array.prototype.concat.call ({a: 1}, {b: 2}) console.log (newarray); // [{a: 1}, {b: 2}] console.log (newarray [0] .a); // 1 1 1 1;Erstellen Sie Subtarray -Methode
【Scheibe()】
Die Slice () -Methode erstellt ein neues Array basierend auf einem oder mehreren Elementen im aktuellen Array, akzeptiert ein oder zwei Parameter, dh die Rückgabe der Start- und Endpositionen des Elements und schließlich das Neuarray zurückzugeben, sodass Slice () nicht das ursprüngliche Array betrifft
Die Slice -Methode (Start, End) erfordert zwei Parameter Start und Ende, wodurch ein Subtarrray in diesem Array von der Startposition in die Endposition (aber nicht enthält) zurückgibt. Wenn das Ende undefiniert ist oder nicht existiert, gibt es alle Elemente von der Startposition bis zum Ende des Arrays zurück
Wenn Start eine negative Zahl ist, start = max (Länge + Start, 0)
Wenn das Ende eine negative Zahl ist, End = max (Länge + Ende, 0)
Start und Ende können Positionen nicht tauschen
Wenn es keine Parameter gibt, kehren Sie zum ursprünglichen Array zurück
var numbers = [1,2,3,4,5]; console.log (Nummern.Slice (2)); // [3,4,5] Konsole.log (Nummern.Slice (2, undefined)); // [3,4,5] Consol E.Log (Nummern.Slice (2,3)); // [3] console.log (number.lice (2,1)); // [] console.log (Nummern.Slice (-3)); //-3+5 = 2 -> [3,4,5] console.log (number.slice (-8)); // max (5 + -8,0) = 0 -> [1,2,3,4,5] console.log (Nummern.Slice (0, -3)); // -3 + 5 = 2 -> [1,2] console.log (nummern.slice (-2, -1)); //-2+5 = 3; -1+5 = 4; -> [4]
Wenn keine Parameter bereitgestellt werden, gibt die Slice () -Methode eine flache Kopie des aktuellen Arrays zurück
// Diese Methode kopiert tatsächlich nur die erste Dimension des Arrays. Die erste Dimension des Arrays speichert die Referenz der zweiten Dimension, und die zweite Dimension speichert tatsächlich ihre Inhalts -Var -Zahlen = [1,2]; var newnumbers = numbers.slice (); Konsole.log (Zahlen, newnumbers); // [1,2] [1,2] Zahlen [0] = 0; console.log (Zahlen). [[1,2];
Die Slice () -Methode umfasst implizite Typumwandlung der Number () -Transformationsfunktion. Wenn der Start in NAN umgewandelt wird, ist es gleichwertig zu Start = 0; Wenn das Ende in NAN umgewandelt wird (außer dass das Ende undefiniert ist), wird ein leeres Array ausgegeben
var numbers = [1,2,3,4,5]; console.log (Nummern.Slice (nan)); // [1,2,3,4,5] console.log (Nummern.Slice (0, nan)); // [] console.log (Nummern.Slice (TRUE, [3]); // [2,3] Console sole
Sie können die Slice () -Methode verwenden, um das Klassenarray -Objekt in ein reales Array zu verwandeln
var arr = array.prototype.slice.call (Array ähnlich); Array.Prototype.slice.call ({0: 'a', 1: 'b', Länge: 2}) // ['a', 'B'] Array.Prototype.Slice.call (Dokument).Array -Löschmethode
【spleißen()】
Splice () und Slice () haben sehr ähnliche Namen, aber ihre Funktionen sind im Wesentlichen unterschiedlich. Mit der Splice () -Methode wird ein Teil des ursprünglichen Arrays gelöscht und kann neue Array -Mitglieder am gelöschten Ort hinzufügen. Diese Methode ändert das ursprüngliche Array.
Splice () gibt ein Array zurück, das aus gelöschten Elementen besteht, oder ein leeres Array, wenn keine gelöschten Elemente zurückgegeben werden.
Der erste Parameter von Splice () startet die Startposition für das Einfügen oder Löschen. Wenn Start eine negative Zahl ist, start = max (Länge + Start, 0); Wenn Start NAN ist, ist es gleichwertig zu starten = 0
Wenn nur ein Element bereitgestellt wird, ist es gleichwertig, das ursprüngliche Array in zwei Arrays am angegebenen Ort aufzuteilen
var a = [1,2,3,4,5,6,7,8]; Konsole.Log (a, a.SPLICE (); // [1,2,3,4,5,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, A.Splices (4); // [1,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,8,4); = [1,2,3,4,5,6,7,8]; console.log (a, a.Splice (-4)); //-4+8 = 4; [1,2,3,4] [5,6,7,8] var a = [1,2,3,4,5,6,7,8]; Konsole.log (a, a.splice (-9)); // max (-9+8,0) = 0 [] [1,2,3,5,5,7,8] var a = = [1,2,3,4,5,6,7,8]; Konsole.log (A, A.Splice (Nan)); // [] [1,2,3,4,5,6,7,8]
Die zweite Parameterummer gibt die Anzahl der Elemente an, die aus dem Array gelöscht werden sollten. Wenn der zweite Parameter weggelassen wird, werden alle Elemente vom Start bis zum Ende des Arrays gelöscht. Wenn die Zahl negativ oder nan oder undefiniert ist, nummer = 0, so wird das Element nicht gelöscht
var a = [1,2,3,4,5,6,7,8]; console.log (a, A.SPLICE (0,2)); // [3,4,5,6,7,8] [1,2] var a = [1,2,3,4,5,6,7]; console.log (a, a, a, a, a, a, a, a, a, a, .splice (10,2); [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; Konsole.log (A, A.SPLICE (1,100)); // [1] [2,3,4,5,6,7] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, -5)); // [1,2,3,4,5,6,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, nan)); // [1,2,3,4,5,6,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, undefined)); // [1,2,3,4,5,6,7] [] var a = [1,2,3,4,5,6,7,8]; Konsole.log (A, A.Splice (1, undefined)); // [1,2,3,4,5,6,7] []
Wenn es später mehr Parameter gibt, bedeutet dies, dass dies die neuen Elemente sind, die in das Array eingefügt werden müssen
var a = [1,2,3,4,5]; console.log (a, A.Splice (2,0, 'A', 'B'); // [1,2, 'A', 'B', 3,4,5] [] console.log (a, a.splice (2,2, [1,2], 3); // // [1,2]; ['a', 'b']
Array -Positionsmethode
ES5 fügt Array -Instanzen zwei Positionsmethoden hinzu: indexof () und lastIndexof ()
【Indexof ()】
Indexof (Search, Start) -Methode empfängt zwei Parametersuche und Start, um den Ort zurückzugeben, an dem die Suche zuerst angezeigt wird. Wenn sie nicht gefunden wird, gibt sie -1 zurück
Der Suchparameter gibt das zu durchsuchende Element an. Verwenden Sie den strengen Gleichstellungsoperator (===) zum Vergleich
var arr = [1,2,3, '1', '2', '3']; console.log (arr.indexof ('2'); // 4console.log (arr.indexof (3)); // 2console.log (arr.indexof (0); //-1-1);Der Startparameter gibt die Startposition der Suche an. Diese Methode fordert die Number () -Transformationsfunktion implizit auf, um nicht-numerische Startwerte (außer undefined) in Zahlen umzuwandeln. Wenn dieser Parameter ignoriert wird oder wenn der Parameter undefiniert oder NAN ist, starten Sie = 0
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.indexof ('a', undefined)); // 0console.log (arr.indexof ('a', nan); // 0conol E.Log (arr.indexof ('a', 1)); // 5console.log (arr.indexof ('a', true)); // 5console.log (arr.indexof ('a',-1)); // max (0, -1+7) = 6; -1console.log (arr.indexof ('a',-5)); // max (0, -5+7) = 2; 5console.log (arr.indexof ('a',-50)); // max (0, -50+7) = 0; 0 var person = {name: 'nicholas'}; var people = [{name: 'nicholas'}]; var morePeople = [Person]; alarm (people.indexof (Person)); //-1, obwohl Person und Menschen die gleichen Werte haben, sind zwei Referenzen Alerces (morepeople. alert (morepeople.indexof ({name: 'nicholas'})); //-1, weil sie nicht die gleiche Referenz sindKompatible Schreibmethode der Indexof () -Methode
if (typeof array.prototype.indexof! 0; für (var k = 0, Länge = this.Length; k <Länge; k ++) {if (k> = fromIndex && this [k] === Searchelement) {index = k; break;}} return index;};};【LastIndexof ()】
Im Gegensatz zu Indexof () schaut lastIndexof () von rechts nach links aus
Die letzte Methode für die LastIndexof (Such, Start) empfängt zwei Parametersuche und Start, wobei der Ort zurückgegeben wird, an dem die Suche zuerst angezeigt wird, und wenn sie nicht gefunden wird, gibt sie -1 zurück
Der Suchparameter gibt das zu durchsuchende Element an. Verwenden Sie den strengen Gleichstellungsoperator (===) zum Vergleich
var arr = [1,2,3, '1', '2', '3']; console.log (arr.lastIndexof ('2'); // 4console.log (arr.lastIndexof (3)); // 2console.log (arr.lastIndexof (0);Start bedeutet die Startposition der Suche, die die Number () -Transformationsfunktion implizit aufruft, um nicht numerische (außer undefinierte) Startwerte in Zahlen umzuwandeln. Wenn dieser Parameter ignoriert wird oder wenn der Parameter undefiniert oder NAN ist, starten Sie = 0
Im Gegensatz zur letzten methode von lastIndexof () einer Zeichenfolge, wenn die Suchmethode eine negative Zahl ist, such = max (0, Länge+Suche)
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.lastindexof ('b'); // 6console.log (arr.lastindexof ('b', undefined); //-1conol.log (Arr.lastindexof ('A', u nDefined)); // 0console.log (arr.lastindexof ('B', nan)); //-1console.log (arr.lastindexof ('B', 1)); // 1console.log (arr.lastindexof ('B',-1); //mx (0, -1+7) = 6; 6console.log (arr.lastIndexof ('B',-5)); // max (0, -5+7) = 2; 1console.log (arr.lastIndexof ('B',-50)); // max (0, -50+7) = 0; -1【Tipps】 Geben Sie alle Indexwerte von Elementen zurück, die den Kriterien erfüllen
Alle übereinstimmenden Elemente finden Sie durch Looping, um indexof () oder lastIndexof () aufzurufen.
Funktion AllIndexof (Array, Wert) {var result = []; var pos = array.indexof (value); if (pos === -1) {return -1;} while (pos> -1) {result.push (pos); pos = array.indexof (Wert, pos+1); [1,2,3,3,2,1]; console.log (Allindexof (Array, 1)); // [0,5]Kompatible Schreibmethode der LastIndexof () -Methode
if (typeof array.prototype.lastIndexof! Länge - 1; für (var k = Länge - 1; k> -1; k- = 1) {if (k <= von iNdex && this [k] === Searchelement) {index = k; break;}} return index;};};}Array -Merge -Methode
Die Array -Zusammenführungsmethoden umfassen Vertrag () und Reduderight () -Methoden. Sie verwenden die angegebene Funktion, um Array -Elemente zu kombinieren, um einen einzelnen Wert zu generieren. Dies ist ein häufiger Betrieb in der funktionellen Programmierung, auch als "Injektion" und "Zusammenbruch" bezeichnet wird
【reduzieren()】
Die Verrückungsmethode erfordert zwei Parameter. Die erste ist eine Funktion, die vereinfachte Operationen ausführt. Die Aufgabe, Funktionen zu vereinfachen, besteht darin, eine Methode zu verwenden, um zwei Werte in einen Wert zu kombinieren oder zu subtrahieren und den vereinfachten Wert zurückzugeben.
Die vereinfachte Funktion akzeptiert vier Parameter, nämlich:
【1】 Anfangsvariable, standardmäßig zum ersten Elementwert des Arrays. Der Rückgabewert nach der ersten Ausführung der Funktion wird als anfängliche Variable für die zweite Ausführung der Funktion usw. verwendet
【2】 Die aktuelle Variable, wenn der zweite Parameter angegeben ist, ist die Variable der Wert des ersten Elements des Arrays. Andernfalls ist der Wert des zweiten Elements der Wert des zweiten Elements.
【3】 Der Index der Elemente, die der aktuellen Variablen im Array entsprechen (ab 0)
【4】 Original -Array -Objekt
Unter diesen vier Parametern der vereinfachten Funktion sind nur die ersten beiden erforderlich, während die letzten beiden optional sind.
values.Reduce (Funktion (prev, cur, index, array) {// Todo});Der zweite (optionale) Parameter der Methode Red
var a = [1,2,3,4,5];var sum = a.reduce(function(x,y){return x+y},0);//Sum of array var product = a.reduce(function(x,y){return x*y},1);//Finding product of array var max = a.reduce(function(x,y){return (x>y)?x:y;});//Finding maximum value[1, 2, 3, 4, 5] .Reduce (Funktion (prev, cur) {console.log (prev, cur) return prev + cur;}); // 1 2 // 3 // 6 4 // 10 5 // Letzte Ergebnis: 15 [1, 2, 3, 4, 5] .Recu (prev, cur) {/ console. 3 // 6 4 // 10 5 // Letztes Ergebnis: 15[Anmerkung] Der Rückgabeergebnis -Typ der Vertrag () -Methode entspricht dem anfänglichen Wert, der in übergebener in übergebener Wert ist
[1, 2, 3, 4, 5] .Reduce (Funktion (prev, cur) {console.log (prev.sum, cur); pre.sum = prev.sum + cur; return prev;}, {sum: 0}); // 0 1 // 1 2 // 3 // 6 // 10 5 // Objekt {sum: 15}}}}}}Mit der Methode record () können Sie eine Summenmethode für die Summe von Arrays schreiben
Array.Prototype.sum = function () {return this.reduce (function (prev, cur) {return prew + cur;})}; [3,4,5,6,10] .sum (); // 28Da die Reduzierung der Methode jedes Element in Sequenz verarbeitet, kann sie tatsächlich zur Suche nach einem Element verwendet werden. Finden Sie zum Beispiel das längste Array -Element
Funktion findlongest (Einträge) {return -Einträge.Reduce (Funktion (prev, cur) {return cur.length> prev.length? cur: prev;}, '');} console.log (findlongest ([1,2,3, 'ab', 4, 'bcd', 5,6785,4]); // 'bcd';Sie können die Methode record () verwenden, um die Abflachung von zweidimensionalen Arrays zu erreichen
var matrix = [[1, 2], [3, 4], [5, 6]]; // 2d Array Flacher var fallten = matrix.Reduce (Funktion (prev, cur) {return prev.concat (cur);}); console.log (flacher); // [1, 2, 3, 4, 5, 6]Auf einem leeren Array führt das Aufrufen von Reduzierung () ohne den Anfangswertparameter zu einer Typ -Fehlerausnahme. Wenn es nur einen Wert gibt, wenn es aufgerufen wird - hat das Array nur ein Element und es wird kein Anfangswert angegeben, oder es gibt ein leeres Array und ein Anfangswert wird angegeben - reduzieren () gibt diesen Wert einfach zurück, ohne die vereinfachte Funktion aufzurufen
var arr = []; arr.Reduce (function () {}); // Uncortn TypeError: Reduzierung des leeren Array ohne Anfangswert arr = []; arr.ReDuce (function () {}, 1); // 1Kompatible Schreibmethode von record () Methode
if (typeof array.prototype.Reduce! Länge;
【Reduderight ()】
Reduzeright () funktioniert genauso wie bei recal
var values = [1,2,3,4,5]; var sum = values.receright (function (prev, cur, index, array) {console.log (prev, cur); return Prev + cur;}); console.log (sum); // 5 4 // 9 3 // 12 2 // 14 1 // 15Reduderight () -Methodenkompatible Schreibmethode
if (typeof array.prototype.REDUCERIGHT! {für (k; k> -1; k- = 1) {this.hasownProperty (k) && (vorher = callback (vorher, this [k], k, this);}} Zurück;};}Array -Iterationsmethode
ECMAScript5 definiert 5 iterative Methoden für Arrays. Jede Methode empfängt zwei Parameter: die Funktion, die auf jedem Element ausgeführt wird, und das Zielfernrohr, das (optional) die Funktion ausführt - was den Wert davon beeinflusst. Die in diese Methoden übergebenen Funktionen empfangen drei Parameter: den Wert des Array -Elements, die Position des Elements im Array und das Array -Objekt selbst. Abhängig von der verwendeten Methode kann der Rückgabewert nach der Ausführung dieser Funktion den zugegriffenen Rückgabewert beeinflussen oder nicht
Funktion (Element, Index, Array) {// Todo}【Karte()】
In der Methode MAP () wird eine bestimmte Funktion auf jedem Element des Arrays ausgeführt und ein Array zurückgegeben, das aus den Ergebnissen jedes Funktionsaufrufs besteht
// f ist die Funktion, die von jedem Element des Arrays aufgerufen wird. Sein Rückgabewert wird zum Element des Rückgabearrays; o ist optional dieser Wert, wenn f als Array bezeichnet wird. Map (f, o); [1,2,3] .MAP (Funktion (Element, Index, arr) {Rückgabeelement*Element}); // [1,4,9] [1,2,3] .MAP (Funktion (Element, Index, arr) {Rückgabeelement*Index}); // [0,2,6]Die Methode MAP () kann auch einen zweiten Parameter akzeptieren, der das Objekt angibt, auf das darauf hingewiesen wird, wenn die Rückruffunktion ausgeführt wird
var arr = ['a', 'b', 'c']; [1,2] .MAP (Funktion (Element, Index, arr) {return this [item]}, arr); // ['B', 'C']Wenn Sie es in der Praxis verwenden, können Sie die Methode map () verwenden, um die Erfassung spezifischer Attributwerte im Objektarray zu erleichtern
var user = [{name: 't1', E -Mail:'[email protected] '}, {name:' t2 ', E -Mail:'[email protected]'}, {name: 't3', E -Mail:'[email protected] '}]; console.log (arrsole). "[email protected]", "[email protected]"]MAP () -Methode kann auch für Klassenarray -Objekte verwendet werden
Array.Prototype.map.call ('ABC', Funktion (Element, Index, arr) {return item.touppercase ()}); // ["A", "B", "C"]Bei spärlichen Arrays ruft die MAP () -Methode die Funktion nicht auf der Sequenznummer auf, in der das Element nicht tatsächlich existiert.
var a = [1,, 3]; console.log (a.map (Funktion (Element, Index, arr) {Rückgabeelement*2;}); // [2, 2: 6]MAP () Methodenkompatible Schreibmethode
if (typeof array.prototype.map! arr;};}
【Foreach ()】
In der Methode foreach () wird eine bestimmte Funktion für jedes Element im Array ausgeführt, und diese Methode gibt keinen Wert zurück. Im Wesentlichen das gleiche wie die Iteration über einem Array für die Schleife. Wenn Sie einen Rückgabewert benötigen, verwenden Sie normalerweise die Kartenmethode
[1,2,3,4] .foreach (Funktion (Element, Index, arr) {console.log (item)}); // 1 // 2 // 3 // 4Ähnlich der für die für die Schleife unten
var array = [1, 2, 3, 4]; für (var k = 0, länge = array.length; k <Länge; k ++) {console.log (Array [k]);}Verwenden Sie die Methode foreAch (), um eine einfache Ergänzung zu implementieren
var sum = 0; [1, 2, 3, 4] .foreach (Funktion (Element, Index, Array) {sum += item;}); console.log (sum); // 10Zusätzlich zur Annahme eines erforderlichen Rückruffunktionsparameters kann der zweite Parameter auch einen optionalen Kontextparameter akzeptieren (ändern Sie diesen Zeiger in der Rückruffunktion).
var out = []; [1, 2, 3] .foreach (Funktion (Elem) {this.push (elem * elem);}, out); console.log (out); // [1, 4, 9]Der zweite Parameter ist sehr nützlich für mehrschichtige dies, da dies in der Regel inkonsistent zeigt.
var obj = {name: 'zhang san', mal: [1, 2, 3], drucken: function () {// Dies zeigt auf objconsole.log (this); this.times.foreach (Funktion (n) {// Dies zeigt auf windowConsole.log (this);});}}; obj.print (); var obj = {name: 'zhang san', mal: [1, 2, 3], drucken: function () {// Dies zeigt auf objconsole.log (this); this.times.foreach (Funktion (n) {// Dies zeigt auch auf objconsole.log (this);}, this);}}; obj.print ();foreach () Loop kann für Klassenarray -Objekte verwendet werden
var str = 'ABC'; Array.Prototype.foreach.call (str, Funktion (Element, Index, Array) {console.log (Element + ':' + index);}); // a: 0 // b: 1 // c: 2Anders als
var a = [1,2,3]; a [1]; für (var i = 0; i <A.Length; i ++) {console.log (a [i]);} // 1 // undefined // 3 a.foreach (function (item, index, arr) {console.log (item)});Die foreAch () -Methode kann den Traversal nicht beenden, bevor alle Elemente an die genannte Funktion übergeben werden. Das heißt, es gibt keine entsprechende Break -Anweisung wie die in der for -Schleife verwendete. Wenn Sie frühzeitig enden möchten, müssen Sie die foreach () -Methode in einen Try -Block einsetzen und eine Ausnahme auswerfen
für (var i = 0; i <5; i ++) {if (i == 2) break;} console.log (i); // 2 var a = [1,2,3,4,5]; console.log (a.forach (Funktion, Index, Index, arr) {ide (index == 2) break; var a = [1,2,3,4,5];foreach () Methodenkompatible Schreibmethode
if (typeof array.prototype.foreach! Object.Prototype.hasownProperty.call (this, k)) {fn.call (Kontext, this [k], k, this);}}}}}【Filter()】
Die filter () -Methode führt eine bestimmte Funktion auf jedem Element im Array aus und gibt ein Array von Elementen zurück, die true zurückgeben. Diese Methode wird häufig verwendet, um alle Array -Elemente abzufragen, die den Kriterien erfüllen
[1, 2, 3, 4, 5].filter(function (elem) {return (elem > 3);});// [4, 5][0, 1, 'a', false].filter(Boolean);// [1, "a"][1, 2, 3, 4, 5].filter(function (elem, index, arr) {return index % 2 === 0;});// [1, 3, 5]Die filter () -Methode kann auch einen zweiten Parameter akzeptieren und das Kontextobjekt (dieses Objekt) angeben, in dem sich die Testfunktion befindet
var Obj = function () {this.MAX = 3;};var myFilter = function (item) {if (item > this.MAX) {return true;}};var arr = [2, 8, 3, 4, 1, 3, 2, 9];arr.filter(myFilter, new Obj());// [8, 4, 9]filter () überspringt fehlende Elemente in spärlichen Arrays. Sein Rückgabebereich ist immer dicht, sodass es die Lücken in spärlichen Arrays komprimieren kann.
var a = [1,2 ,,,, 3 ,,, 4]; console.log (A.Length); // 10var Density = A. filter (function () {return true;}) console.log (dicht, dicht.Length); // [1,2,3,4] 4Wenn Sie freie Stellen komprimieren und undefinierte und Nullelemente löschen möchten, können Sie die Filter () -Methode wie diese verwenden
var a = [1,2, undefined ,, 3, null ,, 4]; console.log (A.Length); // 10var density = A.Filter (Funktion (Element) {return item!Filter () Methodenkompatible Schreibmethode
if (typeof array.prototype.filter! arr.push (this [k]);}} return arr;};}
【manche()】
In der Methode "Some ()) wird eine bestimmte Funktion auf jedem Element im Array ausgeführt. Wenn die Funktion für eines der beiden Elemente true, gibt sie True zurück. Und wenn und nur wenn alle Elemente im Wert die Entscheidungsfunktion aufrufen, gibt sie false zurück
a = [1,2,3,4,5];
Wenn Sie eine () -Methode in einem leeren Array anrufen
[] .Some (function () {}); // falseEinige () Methodenkompatible Schreibmethode
if (typeof Array.prototype.some != "function") {Array.prototype.some = function (fn, context) {var passed = false;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === true) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}【jeder()】
every()方法对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true；只要有一项返回false，则返回false
a = [1,2,3,4,5];a.every(function(elem, index, arr){elem < 10;})//truea.every(function(elem, index, arr){return elem%2 ===0;});//false在空数组上调用every()方法会返回true
[].every(function(){});//trueevery()方法兼容写法
if (typeof Array.prototype.every != "function") {Array.prototype.every = function (fn, context) {var passed = true;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === false) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}Zusammenfassen
JavaScript -Array -Methoden sind speziell als allgemein definiert, sodass sie nicht nur für reale Arrays, sondern auch für Klassenarray -Objekte korrekt funktionieren. Of these 22 methods, all methods except toString() and toLocaleString() are common
可以改变原数组的方法总共有7种：包括unshift()、shift()、push()、pop()这4种栈和队列方法，reverse()和sort()这2种数组排列方法，数组删改方法splice()
The above is the 22 must-learn methods of arrays in JavaScript introduced to you by the editor (recommended). Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!