Durchlaufen Sie ein Array in Javascript

In Java können Sie eine for Schleife verwenden, um Objekte in einem Array wie folgt zu verschieben:

 String[] myStringArray = {"Hello", "World"}; for (String s : myStringArray) { // Do something } 

Können Sie dasselbe in Javascript tun?

2600
10 июня '10 в 3:04 2010-06-10 03:04 Mark Szymanski wird am 10. Juni 10 um 03:04 2010-06-10 03:04 eingestellt
@ 39 Antworten
  • 1
  • 2

Verwenden Sie eine sequentielle for Schleife:

 var myStringArray = ["Hello","World"]; var arrayLength = myStringArray.length; for (var i = 0; i < arrayLength; i++) { alert(myStringArray[i]); //Do something } 

@zipcodeman schlägt die Verwendung des for...in Operators vor. Um for-in Arrays zu wiederholen, sollte jedoch vermieden werden, dass dieser Operator die Eigenschaften eines Objekts auflisten soll.

Es sollte nicht für Objekte des Array-Typs verwendet werden, weil:

  • Die Reihenfolge der Iterationen ist nicht garantiert, Array-Indizes können nicht in numerischer Reihenfolge aufgerufen werden.
  • Geerbte Eigenschaften werden ebenfalls aufgelistet.

Der zweite Punkt ist, dass dies zu einer Vielzahl von Problemen führen kann. Wenn Sie beispielsweise das Array.prototype Objekt erweitern, um dort eine Methode Array.prototype , wird diese Eigenschaft ebenfalls aufgelistet.

Zum Beispiel:

 Array.prototype.foo = "foo!"; var array = ['a', 'b', 'c']; for (var i in array) { alert(array[i]); } 

Im obigen Code werden "a", "b", "c" und "foo!"

Dies ist besonders problematisch, wenn Sie eine Bibliothek verwenden, die stark auf die Erweiterung Ihrer eigenen Prototypen (z. B. MooTools) angewiesen ist.

Der for-in Operator sollte, wie ich bereits gesagt habe, die Eigenschaften eines Objekts auflisten, zum Beispiel:

 var obj = { "a": 1, "b": 2, "c": 3 }; for (var prop in obj) { if (obj.hasOwnProperty(prop)) { // or if (Object.prototype.hasOwnProperty.call(obj,prop)) for safety... alert("prop: " + prop + " value: " + obj[prop]) } } 

In dem obigen Beispiel können Sie mit der Methode hasOwnProperty nur Ihre eigenen Eigenschaften hasOwnProperty Nur Eigenschaften, die ein Objekt physisch besitzt, verfügen nicht über geerbte Eigenschaften.

Ich würde empfehlen, den folgenden Artikel zu lesen:

3210
10 июня '10 в 3:07 2010-06-10 03:07 Die Antwort wird von CMS am 10. Juni 10 um 10:07 2010-06-10 03:07 gegeben

Ja, es wird davon ausgegangen, dass Ihre Implementierung das for ... of in ECMAScript 2015 eingeführten Funktion (das Release "Harmony") enthält ... was heutzutage eine ziemlich sichere Annahme ist.

Es funktioniert so:

 // REQUIRES ECMASCRIPT 2015+ var s, myStringArray = ["Hello", "World"]; for (s of myStringArray) { // ... do something with s ... } 

Oder noch besser, weil ECMAScript 2015 auch Variablen im Bereich eines Blocks mithilfe von let und const bereitstellt:

 // REQUIRES ECMASCRIPT 2015+ const myStringArray = ["Hello", "World"]; for (const s of myStringArray) { // ... do something with s ... } // s is no longer defined here 

Einige JavaScript-Entwickler arbeiten jedoch immer noch in einer Umgebung, die noch nicht vorhanden ist. Dies gilt insbesondere, wenn sie Code schreiben, der in Webbrowsern ausgeführt wird. In diesem Fall können Websiteentwickler oft nicht sicher sein, welchen Browser bzw. welche Version ihre Clients verwenden werden.

Wenn Sie davon ausgehen können, dass der JavaScript-Interpreter mit der vorherigen Version der ECMAScript-Spezifikation kompatibel ist (die beispielsweise Versionen von Internet Explorer bis 9 ausschließt), können Sie anstelle der Schleife die Iterator-Methode forEach verwenden. In diesem Fall übergeben Sie eine Funktion, die für jedes Element im Array aufgerufen wird:

border=0
 var myStringArray = [ "Hello", "World" ]; myStringArray.forEach( function(s) { // ... do something with s ... } ); 

Aber selbst wenn es zu viel ist, um davon auszugehen, und Sie möchten etwas, das in allen JavaScript-Versionen funktioniert, sollten Sie einen expliziten Zählzyklus verwenden. Die sicherste Version, die spärliche Arrays korrekt verarbeitet, sieht folgendermaßen aus:

 var i, s, myStringArray = [ "Hello", "World" ], len = myStringArray.length; for (i=0; i<len; ++i) { if (i in myStringArray) { s = myStringArray[i]; // ... do something with s ... } } 

Das Zuweisen eines myStringArray.length zu einer lokalen Variablen (im Gegensatz zum Einschließen des vollständigen Ausdrucks myStringArray.length in die Schleifenbedingung) kann im Wesentlichen myStringArray.length von der Leistung myStringArray.length , da die Suche nach Eigenschaften jedes Mal bis zum Ende myStringArray.length . Wenn Sie Rhino in meinem Auto verwenden, beträgt die Beschleunigung 43%.

In der Loop-Initialisierungsklausel wird häufig ein Länge-Caching wie folgt angezeigt:

 var i, len, myStringArray = [ "Hello", "World" ]; for (len = myStringArray.length, i=0; i<len; ++i) { 

Die andere Syntax for ... in verwendet, um die Eigenschaften eines Objekts zu durchlaufen. Da ein Array in JavaScript nur ein Objekt mit numerischen Eigenschaftsnamen (und der automatisch aktualisierten length ) ist, können Sie das Array theoretisch mit dem Loop durchlaufen. Das Problem ist jedoch, dass es nicht auf die numerischen Werte der Eigenschaften beschränkt ist (denken Sie daran, dass sogar Methoden tatsächlich nur Eigenschaften sind, deren Wert ein Abschluss ist) und sie auch nicht in numerischer Reihenfolge durchlaufen. Daher sollte die for ... in Syntax nicht zum Durchlaufen von Arrays verwendet werden.

958
16 апр. Antwort von Mark Reed am 16. April 2012-04-16 05:03 '12 am 5:03 2012-04-16 05:03

Sie können map , eine funktionale Programmiermethode, die auch in anderen Sprachen verfügbar ist, z. B. Python und Haskell .

 [1,2,3,4].map( function(item) { alert(item); }) 

Allgemeine Syntax:

 array.map(func) 

Im Allgemeinen benötigt func einen Parameter, der ein Element eines Arrays ist. Im Falle von JavaScript kann es jedoch einen zweiten Parameter, den Elementindex, und einen dritten Parameter, der das Array selbst ist, benötigen.

Der Rückgabewert von array.map ist ein anderes Array. Sie können es daher wie folgt verwenden:

 var x = [1,2,3,4].map( function(item) {return item * 10;}); 

Und jetzt x - [10,20,30,40] .

Sie müssen keine Inline-Funktion schreiben. Dies kann eine separate Funktion sein.

 var item_processor = function(item) { // Do something complicated to an item } new_list = my_list.map(item_processor); 

welche Art gleichwertig sein wird:

  for (item in my_list) {item_processor(item);} 

Außerdem erhalten Sie keine new_list .

410
10 июня '10 в 3:09 2010-06-10 03:09 Die Antwort wird von hasen am 10. Juni '10 um 3:09 2010-06-10 03:09 gegeben

In JavaScript wird nicht empfohlen, ein Array mit einer for-in-Schleife zu durchlaufen, aber es ist besser, eine for-Schleife zu verwenden. Beispiel:

 for(var i=0, len=myArray.length; i < len; i++){} 

Es wird auch optimiert ("Caching" der Länge des Arrays). Wenn Sie mehr erfahren möchten, lesen Sie meinen Beitrag zum Thema .

105
07 дек. antworten gegeben sebarmeli 07 Dez 2010-12-07 10:24 '10 am 10:24 2010-12-07 10:24

für (var s myStringArray) {

(Direkte Antwort auf deine Frage: Jetzt kannst du!)

Die meisten anderen Antworten sind korrekt, erwähnen jedoch nicht (wie geschrieben), dass ECMA Script 6 2015 einen neuen Mechanismus für die Iteration, die for..of , for..of .

Diese neue Syntax ist die eleganteste Methode zum Durchlaufen eines Arrays in Javascript (da Sie keinen Iterationsindex benötigen), wird jedoch von Browsern noch nicht unterstützt.

Es funktioniert derzeit mit Firefox 13+ und Chrome 37+ und nicht mit anderen Browsern (siehe Browserkompatibilität unten). Glücklicherweise gibt es JS-Compiler (wie Babel ), mit denen wir die Funktionen der nächsten Generation nutzen können.

Es funktioniert auch auf Node (ich habe es in Version 0.12.0 getestet).

Array-Iteration

 // You could also use "let" instead of "var" for block scope. for (var letter of ["a", "b", "c"]) { console.log(letter); } 

Iteration eines Arrays von Objekten

 var band = [ {firstName : 'John', lastName: 'Lennon'}, {firstName : 'Paul', lastName: 'McCartney'} ]; for(var member of band){ console.log(member.firstName + ' ' + member.lastName); } 

Generator Iteration:

(Beispiel aus https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of )

 function* fibonacci() { // a generator function let [prev, curr] = [1, 1]; while (true) { [prev, curr] = [curr, prev + curr]; yield curr; } } for (let n of fibonacci()) { console.log(n); // truncate the sequence at 1000 if (n >= 1000) { break; } } 

Kompatibilitätstabelle: http://kangax.github.io/es5-compat-table/es6/ # Für Schleifen

Spec: http://wiki.ecmascript.org/doku.php?id=harmony:iterators

}

97
11 авг. Die Antwort wird von Marlon Bernardes gegeben. 11. Aug. 2013-08-11 18:54 '13 am 18:54 2013-08-11 18:54

Opera, Safari, Firefox und Chrome verwenden jetzt eine Reihe allgemeiner Array-Methoden, um mehrere gemeinsame Schleifen zu optimieren.

Sie benötigen zwar nicht alle, aber sie können sehr nützlich sein oder werden von jedem Browser unterstützt.

Mozilla Labs hat die von ihnen und WebKit verwendeten Algorithmen veröffentlicht, sodass Sie sie selbst hinzufügen können.

Der Filter gibt ein Array von Elementen zurück, die eine bestimmte Bedingung oder einen bestimmten Test erfüllen.

Jede gibt true zurück, wenn jedes Element des Arrays den Test besteht.

Manche geben true zurück, wenn jemand den Test besteht.

forEach führt die Funktion für jedes Element des Arrays aus und gibt nichts zurück.

Die Map ähnelt forEach, gibt jedoch ein Array von Operationsergebnissen für jedes Element zurück.

Alle diese Methoden benötigen eine Funktion für das erste Argument und ein optionales zweites Argument. Hierbei handelt es sich um ein Objekt, dessen Gültigkeitsbereich Sie den Elementen des Arrays beim Durchlaufen der Funktion aufzwingen möchten.

Ignoriere ihn, bis du ihn brauchst.

indexOf und lastIndexOf finden die gewünschte Position des ersten oder letzten Elements, die genau mit ihrem Argument übereinstimmt.

 (function(){ var p, ap= Array.prototype, p2={ filter: function(fun, scope){ var L= this.length, A= [], i= 0, val; if(typeof fun== 'function'){ while(i< L){ if(i in this){ val= this[i]; if(fun.call(scope, val, i, this)){ A[A.length]= val; } } ++i; } } return A; }, every: function(fun, scope){ var L= this.length, i= 0; if(typeof fun== 'function'){ while(i<L){ if(i in this  !fun.call(scope, this[i], i, this)) return false; ++i; } return true; } return null; }, forEach: function(fun, scope){ var L= this.length, i= 0; if(typeof fun== 'function'){ while(i< L){ if(i in this){ fun.call(scope, this[i], i, this); } ++i; } } return this; }, indexOf: function(what, i){ i= i || 0; var L= this.length; while(i< L){ if(this[i]=== what) return i; ++i; } return -1; }, lastIndexOf: function(what, i){ var L= this.length; i= i || L-1; if(isNaN(i) || i>= L) i= L-1; else if(i< 0) i += L; while(i> -1){ if(this[i]=== what) return i; --i; } return -1; }, map: function(fun, scope){ var L= this.length, A= Array(this.length), i= 0, val; if(typeof fun== 'function'){ while(i< L){ if(i in this){ A[i]= fun.call(scope, this[i], i, this); } ++i; } return A; } }, some: function(fun, scope){ var i= 0, L= this.length; if(typeof fun== 'function'){ while(i<L){ if(i in this  fun.call(scope, this[i], i, this)) return true; ++i; } return false; } } } for(p in p2){ if(!ap[p]) ap[p]= p2[p]; } return true; })(); 
82
10 июня '10 в 5:43 2010-06-10 05:43 Die Antwort wird von kennebec am 10. Juni '10 um 5:43 2010-06-10 05:43 abgegeben

Verwenden Sie eine while-Schleife ...

 var i=0, item, items = ['one','two','three']; while(item = items[i++]){ console.log(item); } 

Protokolle: 'Eins', 'Zwei', 'Drei'

Und für die umgekehrte Reihenfolge noch effizienter

 var items = ['one','two','three'], i = items.length; while(i--){ console.log(items[i]); } 

Protokolle: 'drei', 'zwei', 'eins'

Oder klassisch for Schleife

 var items = ['one','two','three'] for(var i=0, l = items.length; i < l; i++){ console.log(items[i]); } 

Protokolle: 'Eins', 'Zwei', 'Drei'

Link: http://www.sitepoint.com/google-closure-how-not-to-write-javascript/

62
05 янв. Antwort auf Timo Huovinen 05 Jan 2012-01-05 12:15 '12 at 12:15 2012-01-05 12:15

die Einführung

Seit meiner Studienzeit programmiere ich in Java, JavaScript, Pascal, ABAP , PHP, Progress 4GL, C / C ++ und vielleicht in mehreren anderen Sprachen, über die ich im Moment nicht nachdenken kann.

Alle haben zwar ihre eigenen sprachlichen Merkmale, aber jede dieser Sprachen hat viele der gleichen Grundkonzepte. Zu diesen Konzepten gehören Prozeduren / Funktionen, IF -Anweisungen, FOR Loops und WHILE Loops.


Traditionell for -schleife

Eine traditionelle for Schleife besteht aus drei Komponenten:

  1. Initialisierung: Wird ausgeführt, bevor der Look-Block zum ersten Mal ausgeführt wird.
  2. Bedingung: Überprüft die Bedingung vor jeder Ausführung der Schleife und beendet die Schleife, wenn sie falsch ist
  3. Folgender Gedanke: Wird jedes Mal nach der Schleife ausgeführt

Diese drei Komponenten sind voneinander a getrennt ; Zeichen. Der Inhalt für jede dieser drei Komponenten ist optional. Dies bedeutet, dass for Mindestzyklus Folgendes möglich ist:

 for (;;) { // Do stuff } 

Natürlich müssen Sie if(condition === true) { break; } if(condition === true) { break; } if(condition === true) { break; } if(condition === true) { break; } oder if(condition === true) { return; } if(condition === true) { return; } if(condition === true) { return; } if(condition === true) { return; } irgendwo drin, for -loop, um es zu stoppen.

Normalerweise wird die Initialisierung jedoch zur Deklaration eines Indexes verwendet, diese Bedingung wird verwendet, um diesen Index mit einem Minimal- oder Maximalwert zu vergleichen, und der folgende Gedanke wird verwendet, um den Index zu erhöhen:

 for (var i = 0, length = 10; i < length; i++) { console.log(i); } 

Verwenden traditioneller for Schleifen zum Durchlaufen eines Arrays

Die herkömmliche Methode zum Durchlaufen eines Arrays lautet wie folgt:

 for (var i = 0, length = myArray.length; i < length; i++) { console.log(myArray[i]); } 

Oder, wenn Sie es vorziehen, zurückzurollen, machen Sie Folgendes

 for (var i = myArray.length - 1; i > -1; i--) { console.log(myArray[i]); } 

Es gibt jedoch viele Optionen, zum Beispiel:

 for (var key = 0, value = myArray[key], length = myArray.length; key < length; value = myArray[++key]) { console.log(value); } 

... oder das ...

 var i = 0, length = myArray.length; for (; i < length;) { console.log(myArray[i]); i++; } 

... oder diese:

 var key = 0, value; for (; value = myArray[key++];){ console.log(value); } 

Was am besten funktioniert, hängt weitgehend vom persönlichen Geschmack sowie vom konkreten Anwendungsfall ab, den Sie implementieren.

Bitte beachten Sie, dass jede dieser Optionen von allen Browsern unterstützt wird, auch von sehr alten!


In while Schleife

Eine Alternative zur for Schleife ist die while Schleife. Um ein Array zu durchlaufen, können Sie Folgendes tun:

 var key = 0; while(value = myArray[key++]){ console.log(value); } 

Wie traditionelle for Loops, while Loops sogar von den ältesten Browsern unterstützt werden.

Beachten Sie auch, dass die while-Schleife als for Schleife überschrieben werden kann. Zum Beispiel verhält sich while Schleife hier oben wie for -loop:

 for(var key = 0; value = myArray[key++];){ console.log(value); } 

For...in und for...of

In Javascript können Sie auch Folgendes tun:

 for (i in myArray) { console.log(myArray[i]); } 

Dies sollte jedoch mit Vorsicht angewendet werden, da es sich in allen Fällen nicht so verhält wie das traditionelle Zyklus, und es gibt mögliche Nebenwirkungen, die berücksichtigt werden müssen. Siehe Warum ist "für ... in" bei Array-Iteration eine schlechte Idee? Weitere Details

Alternativ for...in gibt es jetzt auch for...of Das folgende Beispiel zeigt den Unterschied zwischen for...of Schleife und for...in Schleife:

 var myArray = [3, 5, 7]; myArray.foo = "hello"; for (var i in myArray) { console.log(i); // logs 0, 1, 2, "foo" } for (var i of myArray) { console.log(i); // logs 3, 5, 7 } 

Darüber hinaus müssen Sie berücksichtigen, dass keine Version von Internet Explorer for...of ( Edge 12+ ) und for...in mindestens Internet Explorer 10 unterstützt wird.


Array.prototype.forEach()

Eine Alternative for -loops ist Array.prototype.forEach() , die die folgende Syntax verwendet:

 myArray.forEach(function(value, key, myArray) { console.log(value); }); 

Array.prototype.forEach() von allen modernen Browsern sowie von Internet Explorer 9 und höher Array.prototype.forEach() .


Bibliotheken

Schließlich haben viele Utility-Bibliotheken auch eigene Änderungen. AFAIK, die drei beliebtesten:

jQuery.each() , in jQuery :

 $.each(myArray, function(key, value) { console.log(value); }); 

_.each() in Underscore.js :

 _.each(myArray, function(value, key, myArray) { console.log(value); }); 

_.forEach() , in Lodash.js :

 _.forEach(myArray, function(value, key) { console.log(value); }); 
52
29 февр. Antwort von John Slegers 29. Februar 2016-02-29 21:56 '16 um 21:56 2016-02-29 21:56

Wenn Sie einen kurzen Weg zum Aufnehmen einer schnellen Schleife benötigen, können Sie in umgekehrter Reihenfolge iterieren:

 for (var i=myArray.length;i--;){ var item=myArray[i]; } 

Dies hat den Vorteil des Längen-Caching (ähnlich wie for (var i=0, len=myArray.length; i<len; ++i) und anders als for (var i=0; i<myArray.length; ++i) ), während die Anzahl der Zeichen geringer ist.

Es gibt sogar mehrere Male, in denen Sie die Umkehrung wiederholen müssen, z. B. wenn Sie eine Live-NodeList wiederholen, bei der Sie Elemente während der Iteration aus dem DOM entfernen möchten .

35
04 июня '12 в 19:26 2012-06-04 19:26 Die Antwort wird von Phrogz am 4. Juni 12 um 19:26 gegeben. 2012-06-04 19:26

Einige Fälle, in denen eine kreisförmige Array-Iteration für eine funktionale Programmierung in JavaScript verwendet wird:

1. Schleifen Sie einfach durch das Array.

 const myArray = [{x:100}, {x:200}, {x:300}]; myArray.forEach((element, index, array) => { console.log(element.x); // 100, 200, 300 console.log(index); // 0, 1, 2 console.log(array); // same myArray object 3 times }); 

Anmerkung: Array.prototype.forEach () ist streng genommen kein funktionaler Weg, da die als Eingabeparameter verwendete Funktion keinen Wert zurückgeben soll, der daher nicht als reine Funktion betrachtet werden kann.

2. Prüfen Sie, ob eines der Elemente des Arrays den Test besteht.

 const people = [ {name: 'John', age: 23}, {name: 'Andrew', age: 3}, {name: 'Peter', age: 8}, {name: 'Hanna', age: 14}, {name: 'Adam', age: 37}]; const anyAdult = people.some(person => person.age >= 18); console.log(anyAdult); // true 

3. Konvertieren Sie in ein neues Array

 const myArray = [{x:100}, {x:200}, {x:300}]; const newArray= myArray.map(element => element.x); console.log(newArray); // [100, 200, 300] 

Hinweis Die map () -Methode erstellt ein neues Array mit den Ergebnissen des Aufrufs der bereitgestellten Funktion für jedes Element im aufrufenden Array.

4. Fassen Sie eine bestimmte Eigenschaft zusammen und berechnen Sie ihren Durchschnitt

 const myArray = [{x:100}, {x:200}, {x:300}]; const sum = myArray.map(element => element.x).reduce((a, b) => a + b, 0); console.log(sum); // 600 = 0 + 100 + 200 + 300 const average = sum / myArray.length; console.log(average); // 200 

5. Erstellen Sie ein neues Array basierend auf dem Original, ohne es jedoch zu ändern.

 const myArray = [{x:100}, {x:200}, {x:300}]; const newArray= myArray.map(element => { return { ...element, x: element.x * 2 }; }); console.log(myArray); // [100, 200, 300] console.log(newArray); // [200, 400, 600] 

6. Zählen Sie die Anzahl jeder Kategorie.

 const people = [ {name: 'John', group: 'A'}, {name: 'Andrew', group: 'C'}, {name: 'Peter', group: 'A'}, {name: 'James', group: 'B'}, {name: 'Hanna', group: 'A'}, {name: 'Adam', group: 'B'}]; const groupInfo = people.reduce((groups, person) => { const {A = 0, B = 0, C = 0} = groups; if (person.group === 'A') { return {...groups, A: A + 1}; } else if (person.group === 'B') { return {...groups, B: B + 1}; } else { return {...groups, C: C + 1}; } }, {}); console.log(groupInfo); // {A: 3, C: 1, B: 2} 

7. Holen Sie sich eine Teilmenge des Arrays basierend auf bestimmten Kriterien.

 const myArray = [{x:100}, {x:200}, {x:300}]; const newArray = myArray.filter(element => element.x > 250); console.log(newArray); // [{x:300}] 

Hinweis Die filter () -Methode erstellt ein neues Array mit allen Elementen, die den von der bereitgestellten Funktion implementierten Test bestehen.

8. Array sortieren

 const people = [ { name: "John", age: 21 }, { name: "Peter", age: 31 }, { name: "Andrew", age: 29 }, { name: "Thomas", age: 25 } ]; let sortByAge = people.sort(function (p1, p2) { return p1.age - p2.age; }); console.log(sortByAge); 

2019

23 февр. Die Antwort ist gegeben Yuci 23 Feb. 2018-02-23 14:29 '18 um 14:29 Uhr 2018-02-23 14:29 Uhr

Es gibt eine Möglichkeit, dies zu tun, wenn Sie sehr wenig versteckte Bereiche in Ihrer Schleife haben und zusätzliche Variablen entfernen.

 var i = 0, item; // note this is weak to sparse arrays or falsey values for ( ; item = myStringArray[i++] ; ){ item; // This is the string at the index. } 

Oder wenn Sie wirklich einen Bezeichner bekommen wollen und eine klassische for Schleife haben:

 var i = 0, len = myStringArray.length; // cache the length for ( ; i < len ; i++ ){ myStringArray[i]; // Don't use this if you plan on changing the length of the array } 

Moderne Browser unterstützen in Array-Prototypen alle Methoden, map , reduce , filter und viele andere Methoden.

26
17 мая '11 в 1:52 2011-05-17 01:52 Die Antwort wird von Gabriel am 17. Mai um 01:52 2011-05-17 01:52 gegeben

Es gibt mehrere Möglichkeiten, ein Array in Javascript zu wechseln.

Gesamtzyklus:

 var i; for (i = 0; i < substr.length; ++i) { // Do something with `substr[i]` } 

ES5 für jeden:

 substr.forEach(function(item) { // Do something with `item` }); 

jQuery.each:

 jQuery.each(substr, function(index, item) { // Do something with `item` (or `this` is also `item` if you like) }); 

Weitere Informationen finden Sie hier. Sie können auch die MDN auf eine Schleife durch ein Array in JavaScript und mit jQuery überprüfen.

26
23 июля '14 в 15:59 2014-07-23 15:59 Die Antwort ist RizN81 am 23. Juli 14 um 15:59 Uhr 2014-07-23 15:59

Ich würde die Verwendung der Underscore.js- Bibliothek unbedingt empfehlen. Es bietet Ihnen verschiedene Funktionen, mit denen Sie Arrays / Collections durchlaufen können.

Zum Beispiel:

 _.each([1, 2, 3], function(num){ alert(num); }); => alerts each number in turn... 
25
17 апр. Antworten Andrew Thomson 17. April 2012-04-17 02:33 '12 um 02:33 2012-04-17 02:33

Die Kontur des Arrays:

 for(var i = 0; i < things.length; i++){ var thing = things[i]; console.log(thing); } 

Objektzyklus:

 for(var prop in obj){ var propValue = obj[prop]; console.log(propValue); } 
24
02 авг. die antwort ist bzim 02 aug gegeben. 2016-08-02 00:18 '16 am 0:18 2016-08-02 00:18

Ja, Sie können dasselbe mit einer Schleife in JavaScript tun, aber nicht auf diese beschränkt sein. Es gibt viele Möglichkeiten, Arrays in JavaScrip zu durchlaufen. Stellen Sie sich vor, Sie haben dieses Array unten und möchten es überlaufen:

 var arr = [1, 2, 3, 4, 5]; 

Dies sind Lösungen:

1) für einen Zyklus

Für eine Schleife ist dies eine allgemeine Methode zum Schleifen von Arrays in JavaScript, wird jedoch nicht als schnellste Lösung für große Arrays angesehen:

 for (var i=0, l=arr.length; i<l; i++) { console.log(arr[i]); } 

2) Tschüss-Zyklus

Während die Schleife als der schnellste Weg zum Scrollen durch >

 let i=0; while (arr.length>i) { console.log(arr[i]); i++; } 

3) Während
Machen Sie dasselbe mit einigen Syntaxunterschieden, wie unten gezeigt:

 let i=0; do { console.log(arr[i]); i++; } while (arr.length>i);