Wie kann ich alle Einträge in einem Array mit JavaScript durchlaufen?

Ich dachte, es wäre so etwas:

forEach(instance in theArray)

Wobei theArray mein Array ist, aber dies scheint falsch zu sein.

4935
Dante1986 17 Feb. 2012 im 17:51

24 Antworten

Wenn Sie ein riesiges Array haben, sollten Sie {{X0 }} , um Effizienz zu erzielen. Iteratoren sind eine Eigenschaft bestimmter JavaScript-Sammlungen (z. B. {{X1) }}, Set , String, < a href = "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" rel = "noreferrer"> Array ). Sogar {{X5} } verwendet iterator unter der Haube.

Iteratoren verbessern die Effizienz, indem Sie die Elemente in einer Liste einzeln als Stream verwenden können. Das Besondere an einem Iterator ist, wie er eine Sammlung durchläuft. Andere Schleifen müssen die gesamte Sammlung im Voraus laden, um darüber zu iterieren, während ein Iterator nur die aktuelle Position in der Sammlung kennen muss.

Sie greifen auf das aktuelle Element zu, indem Sie die next -Methode des Iterators aufrufen. Die nächste Methode gibt das value des aktuellen Elements und ein boolean zurück, um anzuzeigen, wann Sie das Ende der Sammlung erreicht haben. Das folgende Beispiel zeigt das Erstellen eines Iterators aus einem Array.

Verwandeln Sie Ihr reguläres Array mithilfe von {{X0} in einen Iterator } Methode wie folgt:

    const myArr = [2,3,4]

let it = myArr.values();

console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());

Sie können Ihr reguläres Array auch mithilfe von { {X0}} wie folgt:

const myArr = [2,3,4]

let it = myArr[Symbol.iterator]();

console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());

Sie können Ihr reguläres array auch in ein {{ X1}} wie folgt:

let myArr = [8, 10, 12];

function makeIterator(array) {
    var nextIndex = 0;
    
    return {
       next: function() {
           return nextIndex < array.length ?
               {value: array[nextIndex++], done: false} :
               {done: true};
       }
    };
};

var it = makeIterator(myArr);

console.log(it.next().value);   // {value: 8, done: false}
console.log(it.next().value);   // {value: 10, done: false}
console.log(it.next().value);   // {value: 12, done: false}
console.log(it.next().value);   // {value: undefined, done: true}

HINWEIS :

  • Iteratoren sind von Natur aus erschöpfbar.
  • Objekte sind standardmäßig nicht iterable. Verwenden Sie for..in in diesem Fall, weil anstelle von Werten mit Schlüsseln gearbeitet wird.

Weitere Informationen zu iteration protocol finden Sie hier.

5
BlackBeard 6 Juli 2018 im 11:32

Ein Weg, der Ihrer Idee am nächsten kommt, wäre die Verwendung von Array.forEach(), das eine Abschlussfunktion akzeptiert, die für jedes Element des Arrays ausgeführt wird.

myArray.forEach(
  (item) => {
    // Do something
    console.log(item);
  }
);

Eine andere praktikable Möglichkeit wäre die Verwendung von Array.map(), die auf die gleiche Weise funktioniert, aber auch alle von Ihnen zurückgegebenen Werte in einem neuen Array zurückgibt (im Wesentlichen jedes Element einem neuen zuzuordnen), wie folgt:

var myArray = [1, 2, 3];
myArray = myArray.map(
  (item) => {
    return item + 1;
  }
);

console.log(myArray); // [2, 3, 4]
7
CherryDT 4 Sept. 2019 im 17:51

ECMAScript 5 (die Version auf JavaScript) für die Arbeit mit Arrays:

forEach - Durchläuft jedes Element im Array und macht mit jedem Element alles, was Sie brauchen.

['C', 'D', 'E'].forEach(function(element, index) {
  console.log(element + " is #" + (index+1) + " in the musical scale");
});

// Output
// C is the #1 in musical scale
// D is the #2 in musical scale
// E is the #3 in musical scale

Falls Sie sich mehr für den Betrieb eines Arrays mit einer eingebauten Funktion interessieren.

map - Erstellt ein neues Array mit dem Ergebnis der Rückruffunktion. Diese Methode eignet sich gut, wenn Sie die Elemente Ihres Arrays formatieren müssen.

// Let's upper case the items in the array
['bob', 'joe', 'jen'].map(function(elem) {
  return elem.toUpperCase();
});

// Output: ['BOB', 'JOE', 'JEN']

reduzieren - Wie der Name schon sagt, wird das Array auf einen einzelnen Wert reduziert, indem die angegebene Funktion aufgerufen wird, die das aktuelle Element und das Ergebnis der vorherigen Ausführung übergibt.

[1,2,3,4].reduce(function(previous, current) {
  return previous + current;
});
// Output: 10
// 1st iteration: previous=1, current=2 => result=3
// 2nd iteration: previous=3, current=3 => result=6
// 3rd iteration: previous=6, current=4 => result=10

alle - Gibt true oder false zurück, wenn alle Elemente im Array den Test in der Rückruffunktion bestehen.

// Check if everybody has 18 years old of more.
var ages = [30, 43, 18, 5];
ages.every(function(elem) {
  return elem >= 18;
});

// Output: false

Filter - Sehr ähnlich zu allen, außer dass dieser Filter ein Array mit den Elementen zurückgibt, die für die angegebene Funktion true zurückgeben.

// Finding the even numbers
[1,2,3,4,5,6].filter(function(elem){
  return (elem % 2 == 0)
});

// Output: [2,4,6]
18
Peter Mortensen 3 Sept. 2019 im 20:55

Wenn Sie forEach() verwenden möchten, sieht es so aus:

theArray.forEach ( element => {
    console.log(element);
});

Wenn Sie for() verwenden möchten, sieht es so aus:

for(let idx = 0; idx < theArray.length; idx++){
    let element = theArray[idx];
    console.log(element);
}
5
cfnerd 4 Jän. 2019 im 23:18

JQuery-Methode mit $.map:

var data = [1, 2, 3, 4, 5, 6, 7];

var newData = $.map(data, function(element) {
    if (element % 2 == 0) {
        return element;
    }
});

// newData = [2, 4, 6];
11
Daniel W. 1 Apr. 2014 im 11:15

Wahrscheinlich ist die for(i = 0; i < array.length; i++) -Schleife nicht die beste Wahl. Warum? Wenn Sie dies haben:

var array = new Array();
array[1] = "Hello";
array[7] = "World";
array[11] = "!";

Die Methode ruft von array[0] bis array[2] auf. Erstens werden zuerst Variablen referenziert, die Sie nicht einmal haben, zweitens würden Sie die Variablen nicht im Array haben, und drittens wird der Code dadurch mutiger. Schau her, es ist was ich benutze:

for(var i in array){
    var el = array[i];
    //If you want 'i' to be INT just put parseInt(i)
    //Do something with el
}

Und wenn Sie möchten, dass es eine Funktion ist, können Sie dies tun:

function foreach(array, call){
    for(var i in array){
        call(array[i]);
    }
}

Wenn Sie brechen wollen, etwas mehr Logik:

function foreach(array, call){
    for(var i in array){
        if(call(array[i]) == false){
            break;
        }
    }
}

Beispiel:

foreach(array, function(el){
    if(el != "!"){
        console.log(el);
    } else {
        console.log(el+"!!");
    }
});

Es gibt zurück:

//Hello
//World
//!!!
27
Peter Mortensen 8 März 2014 im 10:49

Wenn Sie ein Array von Objekten mit der Pfeilfunktion durchlaufen möchten:

let arr = [{name:'john', age:50}, {name:'clark', age:19}, {name:'mohan', age:26}];

arr.forEach((person)=>{
  console.log('I am ' + person.name + ' and I am ' + person.age + ' old');
})
6
Peter Mortensen 3 Sept. 2019 im 20:04

Gemäß der neuen aktualisierten Funktion ECMAScript 6 (ES6) und ECMAScript 2015 können Sie die folgenden Optionen mit Schleifen verwenden:

für Schleifen

for(var i = 0; i < 5; i++){
  console.log(i);
}

// Output: 0,1,2,3,4

für ... in Schleifen

let obj = {"a":1, "b":2}

for(let k in obj){
  console.log(k)
}

// Output: a,b

Array.forEach ()

let array = [1,2,3,4]

array.forEach((x) => {
  console.log(x);
})

// Output: 1,2,3,4

für ... von Schleifen

let array = [1,2,3,4]

for(let x of array){
  console.log(x);
}

// Output: 1,2,3,4

while-Schleifen

let x = 0

while(x < 5){
  console.log(x)
  x++
}

// Output: 1,2,3,4

do ... while-Schleifen

let x = 0

do{
  console.log(x)
  x++
}while(x < 5)

// Output: 1,2,3,4
4
Peter Mortensen 8 März 2020 im 14:51

Ab ECMAScript 6:

list = [0, 1, 2, 3]
for (let obj of list) {
    console.log(obj)
}

Wobei of die mit in verbundenen Kuriositäten vermeidet und es wie die for Schleife einer anderen Sprache funktioniert und let im Gegensatz dazu i innerhalb der Schleife bindet innerhalb der Funktion.

Die geschweiften Klammern ({}) können weggelassen werden, wenn nur ein Befehl vorhanden ist (z. B. im obigen Beispiel).

28
Peter Mortensen 12 Sept. 2019 im 05:12

Sie können forEach so anrufen:

forEach iteriert über das von Ihnen bereitgestellte Array und hat für jede Iteration element, die den Wert dieser Iteration enthält. Wenn Sie einen Index benötigen, können Sie den aktuellen Index abrufen, indem Sie i als zweiten Parameter in der Rückruffunktion für forEach übergeben.

Foreach ist im Grunde eine Funktion hoher Ordnung, die eine andere Funktion als Parameter verwendet.

let theArray= [1,3,2];

theArray.forEach((element) => {
  // Use the element of the array
  console.log(element)
}

Ausgabe:

1
3
2

Sie können auch über ein Array wie folgt iterieren:

for (let i=0; i<theArray.length; i++) {
  console.log(i); // i will have the value of each index
}
7
Nouman Dilshad 25 Jän. 2020 im 12:13

In nativem JavaScript gibt es keine for each Schleife. Sie können entweder Bibliotheken verwenden, um diese Funktionalität zu erhalten (ich empfehle Underscore.js) einfache for in Schleife.

for (var instance in objects) {
   ...
}

Beachten Sie jedoch, dass es Gründe geben kann, eine noch einfachere for - Schleife zu verwenden (siehe Frage zum Stapelüberlauf Warum wird “für verwendet? … In ”mit Array-Iteration so eine schlechte Idee? )

var instance;
for (var i=0; i < objects.length; i++) {
    var instance = objects[i];
    ...
}
22
Community 23 Mai 2017 im 11:47

Dies ist ein Iterator für eine nicht spärliche Liste, bei der der Index bei 0 beginnt. Dies ist das typische Szenario beim Umgang mit document.getElementsByTagName oder document.querySelectorAll.

function each( fn, data ) {

    if(typeof fn == 'string')
        eval('fn = function(data, i){' + fn + '}');

    for(var i=0, L=this.length; i < L; i++) 
        fn.call( this[i], data, i );   

    return this;
}

Array.prototype.each = each;  

Verwendungsbeispiele:

Beispiel 1

var arr = [];
[1, 2, 3].each( function(a){ a.push( this * this}, arr);
arr = [1, 4, 9]

Beispiel 2

each.call(document.getElementsByTagName('p'), "this.className = data;",'blue');

Jedes p-Tag erhält class="blue"

Beispiel 3

each.call(document.getElementsByTagName('p'), 
    "if( i % 2 == 0) this.className = data;",
    'red'
);

Jedes zweite p-Tag erhält class="red">

Beispiel 4

each.call(document.querySelectorAll('p.blue'), 
    function(newClass, i) {
        if( i < 20 )
            this.className = newClass;
    }, 'green'
);

Und schließlich werden die ersten 20 blauen p-Tags in grün geändert

Vorsicht bei der Verwendung von Zeichenfolgen als Funktion: Die Funktion wird außerhalb des Kontexts erstellt und sollte nur verwendet werden, wenn Sie sich des variablen Bereichs sicher sind. Andernfalls ist es besser, Funktionen zu übergeben, bei denen das Scoping intuitiver ist.

21
Karl Gjertsen 29 Sept. 2016 im 12:28

Wenn es Ihnen nichts ausmacht, das Array zu leeren:

var x;

while(x = y.pop()){ 

    alert(x); //do something 

}

x enthält den letzten Wert von y und wird aus dem Array entfernt. Sie können auch shift() verwenden, um das erste Element aus y zu entfernen.

33
joeytwiddle 30 Mai 2014 im 18:37

Es gibt keine eingebaute Fähigkeit, forEach einzubrechen. Um die Ausführung zu unterbrechen, verwenden Sie Array#some wie folgt:

[1,2,3].some(function(number) {
    return number === 1;
});

Dies funktioniert, weil some true zurückgibt, sobald einer der in Array-Reihenfolge ausgeführten Rückrufe true zurückgibt und die Ausführung des Restes kurzschließt. Originalantwort Siehe Array-Prototyp für einige

15
Community 23 Mai 2017 im 12:34

Wenn Sie die jQuery Bibliothek verwenden, können Sie jQuery.each :

$.each(yourArray, function(index, value) {
  // do your stuff here
});

BEARBEITEN:

Gemäß der Frage möchte der Benutzer Code in Javascript anstelle von jquery, so dass die Bearbeitung erfolgt

var length = yourArray.length;   
for (var i = 0; i < length; i++) {
  // Do something with yourArray[i].
}
237
Anik Islam Abhi 12 Nov. 2015 im 05:17

Verwenden von Schleifen mit ECMAScript 6 Destructuring und der Spread-Operator

Die Destrukturierung und Verwendung des Spread-Operators hat sich für Neulinge in ECMAScript 6 als sehr gut lesbar / ästhetisch erwiesen, obwohl einige JavaScript-Veteranen dies möglicherweise als chaotisch betrachten. Junioren oder andere Leute könnten es nützlich finden.

In den folgenden Beispielen wird for...of und die .forEach Methode.

Beispiele 6, 7 und 8 können mit beliebigen Funktionsschleifen wie .map, .filter, .reduce, .sort, {{X4} verwendet werden. }, .some. Weitere Informationen zu diesen Methoden finden Sie im Array-Objekt.

Beispiel 1: Normale for...of - Schleife - hier keine Tricks.

let arrSimple = ['a', 'b', 'c'];

for (let letter of arrSimple) {
  console.log(letter);
}

Beispiel 2: Teilen Sie Wörter in Zeichen

let arrFruits = ['apple', 'orange', 'banana'];

for (let [firstLetter, ...restOfTheWord] of arrFruits) {
  // Create a shallow copy using the spread operator
  let [lastLetter] = [...restOfTheWord].reverse();
  console.log(firstLetter, lastLetter, restOfTheWord);
}

Beispiel 3: Schleifen mit key und value

// let arrSimple = ['a', 'b', 'c'];

// Instead of keeping an index in `i` as per example `for(let i = 0 ; i<arrSimple.length;i++)`
// this example will use a multi-dimensional array of the following format type:
// `arrWithIndex: [number, string][]`

let arrWithIndex = [
  [0, 'a'],
  [1, 'b'],
  [2, 'c'],
];

// Same thing can be achieved using `.map` method
// let arrWithIndex = arrSimple.map((i, idx) => [idx, i]);

// Same thing can be achieved using `Object.entries`
// NOTE: `Object.entries` method doesn't work on Internet Explorer  unless it's polyfilled
// let arrWithIndex = Object.entries(arrSimple);

for (let [key, value] of arrWithIndex) {
  console.log(key, value);
}

Beispiel 4: Objekteigenschaften inline abrufen

let arrWithObjects = [{
    name: 'Jon',
    age: 32
  },
  {
    name: 'Elise',
    age: 33
  }
];

for (let { name, age: aliasForAge } of arrWithObjects) {
  console.log(name, aliasForAge);
}

Beispiel 5: Holen Sie sich tiefe Objekteigenschaften von dem, was Sie benötigen

let arrWithObjectsWithArr = [{
    name: 'Jon',
    age: 32,
    tags: ['driver', 'chef', 'jogger']
  },
  {
    name: 'Elise',
    age: 33,
    tags: ['best chef', 'singer', 'dancer']
  }
];

for (let { name, tags: [firstItemFromTags, ...restOfTags] } of arrWithObjectsWithArr) {
  console.log(name, firstItemFromTags, restOfTags);
}

Beispiel 6: Wird Beispiel 3 mit .forEach verwendet?

let arrWithIndex = [
  [0, 'a'],
  [1, 'b'],
  [2, 'c'],
];

// Not to be confused here, `forEachIndex` is the real index
// `mappedIndex` was created by "another user", so you can't really trust it

arrWithIndex.forEach(([mappedIndex, item], forEachIndex) => {
  console.log(forEachIndex, mappedIndex, item);
});

Beispiel 7: Wird Beispiel 4 mit .forEach verwendet?

let arrWithObjects = [{
    name: 'Jon',
    age: 32
  },
  {
    name: 'Elise',
    age: 33
  }
];
// NOTE: Destructuring objects while using shorthand functions
// are required to be surrounded by parentheses
arrWithObjects.forEach( ({ name, age: aliasForAge }) => {
  console.log(name, aliasForAge)
});

Beispiel 8: Wird Beispiel 5 mit .forEach verwendet

let arrWithObjectsWithArr = [{
    name: 'Jon',
    age: 32,
    tags: ['driver', 'chef', 'jogger']
  },
  {
    name: 'Elise',
    age: 33,
    tags: ['best chef', 'singer', 'dancer']
  }
];

arrWithObjectsWithArr.forEach(({
  name,
  tags: [firstItemFromTags, ...restOfTags]
}) => {
  console.log(name, firstItemFromTags, restOfTags);
});
9
Peter Mortensen 3 Sept. 2019 im 20:21

Die Lambda-Syntax funktioniert normalerweise nicht in Internet Explorer 10 oder niedriger.

Ich benutze normalerweise die

[].forEach.call(arrayName,function(value,index){
    console.log("value of the looped element" + value);
    console.log("index of the looped element" + index);
});

Wenn Sie ein jQuery -Fan sind und bereits eine jQuery-Datei ausgeführt wird, sollten Sie die Positionen der Index- und Wertparameter umkehren

$("#ul>li").each(function(**index, value**){
    console.log("value of the looped element" + value);
    console.log("index of the looped element" + index);
});
6
Peter Mortensen 3 Sept. 2019 im 20:36

Wenn Sie ein Array durchlaufen möchten, verwenden Sie die dreiteilige Standardschleife for.

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

Sie können einige Leistungsoptimierungen erzielen, indem Sie myArray.length zwischenspeichern oder rückwärts durchlaufen.

42
Quentin 17 Feb. 2012 im 13:55

Hinweis : Diese Antwort ist hoffnungslos veraltet. Weitere Informationen zu einem moderneren Ansatz finden Sie unter den verfügbaren Methoden Array. Methoden von Interesse könnten sein:

  • für jedes
  • Karte
  • Filter
  • Postleitzahl
  • reduzieren
  • jeden
  • etwas

Die Standardmethode zum Iterieren eines Arrays in JavaScript ist eine Vanille for - Schleife:

var length = arr.length,
    element = null;
for (var i = 0; i < length; i++) {
  element = arr[i];
  // Do something with element
}

Beachten Sie jedoch, dass dieser Ansatz nur dann gut ist, wenn Sie ein dichtes Array haben und jeder Index von einem Element belegt ist. Wenn das Array dünn ist, können bei diesem Ansatz Leistungsprobleme auftreten, da Sie viele Indizes durchlaufen, die im Array nicht wirklich vorhanden sind. In diesem Fall ist eine for .. in - Schleife möglicherweise die bessere Idee. Sie müssen jedoch die entsprechenden Sicherheitsvorkehrungen treffen, um sicherzustellen, dass nur die gewünschten Eigenschaften des Arrays (dh die Array-Elemente) berücksichtigt werden, da auch die for..in - Schleife aufgelistet wird in älteren Browsern oder wenn die zusätzlichen Eigenschaften als enumerable definiert sind.

In ECMAScript 5 wird es eine forEach-Methode für den Array-Prototyp geben, dies ist jedoch der Fall wird in älteren Browsern nicht unterstützt. Um es konsistent verwenden zu können, müssen Sie entweder über eine Umgebung verfügen, die es unterstützt (z. B. Knoten). js für serverseitiges JavaScript) oder verwenden Sie eine "Polyfill". Die Polyfüllung für diese Funktionalität ist jedoch trivial und da sie das Lesen des Codes erleichtert, ist sie eine gute Polyfüllung.

506
Peter Mortensen 3 Sept. 2019 im 19:57

Ich möchte dies auch als Komposition einer Rückwärtsschleife und als Antwort oben für jemanden hinzufügen, der diese Syntax auch möchte.

var foo = [object,object,object];
for (var i = foo.length, item; item = foo[--i];) {
    console.log(item);
}

Vorteile:

Der Vorteil dabei: Sie haben die Referenz bereits in der ersten, so dass sie später nicht mit einer anderen Zeile deklariert werden muss. Dies ist praktisch, wenn Sie das Objektarray durchlaufen.

Nachteile:

Dies wird immer dann unterbrochen, wenn die Referenz falsch ist - falsey (undefiniert usw.). Es kann jedoch als Vorteil genutzt werden. Es würde jedoch das Lesen etwas erschweren. Und je nach Browser kann es "nicht" optimiert werden, um schneller als das Original zu arbeiten.

12
HZStudio 28 März 2020 im 16:08

Einige Sprachen im C -Stil verwenden foreach, um Aufzählungen zu durchlaufen. In JavaScript erfolgt dies mit der for..in Schleifenstruktur:

var index,
    value;
for (index in obj) {
    value = obj[index];
}

Es gibt einen Haken. for..in durchläuft jedes der aufzählbaren Elemente des Objekts und die Elemente seines Prototyps. Um zu vermeiden, dass Werte gelesen werden, die vom Prototyp des Objekts geerbt werden, überprüfen Sie einfach, ob die Eigenschaft zum Objekt gehört:

for (i in obj) {
    if (obj.hasOwnProperty(i)) {
        //do stuff
    }
}

Darüber hinaus hat ECMAScript 5 einen forEach Methode zu Array.prototype, mit der über ein Array mit a aufgelistet werden kann calback (die Polyfüllung befindet sich in den Dokumenten, sodass Sie sie weiterhin für ältere Browser verwenden können):

arr.forEach(function (val, index, theArray) {
    //do stuff
});

Es ist wichtig zu beachten, dass Array.prototype.forEach nicht unterbrochen wird, wenn der Rückruf false zurückgibt. jQuery und Underscore.js stellen ihre eigenen Variationen von each bereit, um Schleifen bereitzustellen, die kurzgeschlossen werden können.

83
Peter Mortensen 13 Juli 2013 im 01:18

Es gibt einige Möglichkeiten , ein Array in JavaScript wie folgt zu durchlaufen:

für - es ist das häufigste . Vollständiger Codeblock für die Schleife

var languages = ["Java", "JavaScript", "C#", "Python"];
var i, len, text;
for (i = 0, len = languages.length, text = ""; i < len; i++) {
    text += languages[i] + "<br>";
}
document.getElementById("example").innerHTML = text;
<p id="example"></p>

while - Schleife, während eine Bedingung abgeschlossen ist. Es scheint die schnellste Schleife zu sein

var text = "";
var i = 0;
while (i < 10) {
    text +=  i + ") something<br>";
    i++;
}
document.getElementById("example").innerHTML = text;
<p id="example"></p>

do / while - Durchlaufen Sie auch einen Codeblock, während die Bedingung erfüllt ist. Wird mindestens einmal ausgeführt.

var text = ""
var i = 0;

do {
    text += i + ") something <br>";
    i++;
}
while (i < 10);

document.getElementById("example").innerHTML = text;
<p id="example"></p>

Funktionsschleifen - forEach, map, filter, auch reduce (sie durchlaufen die Funktion, werden jedoch bei Bedarf verwendet etwas mit Ihrem Array usw.

// For example, in this case we loop through the number and double them up using the map function
var numbers = [65, 44, 12, 4];
document.getElementById("example").innerHTML = numbers.map(function(num){return num * 2});
<p id="example"></p>

Weitere Informationen und Beispiele zur funktionalen Programmierung auf Arrays finden Sie im Blog-Beitrag Funktionale Programmierung in JavaScript: Zuordnen, Filtern und Reduzieren .

20
Alireza 22 Okt. 2019 im 23:32

Eine forEach -Implementierung (siehe in jsFiddle):

function forEach(list,callback) {
  var length = list.length;
  for (var n = 0; n < length; n++) {
    callback.call(list[n]);
  }
}

var myArray = ['hello','world'];

forEach(
  myArray,
  function(){
    alert(this); // do something
  }
);
31
nmoliveira 18 Dez. 2013 im 12:22

Es gibt drei Implementierungen von foreach in jQuery wie folgt.

var a = [3,2];

$(a).each(function(){console.log(this.valueOf())}); //Method 1
$.each(a, function(){console.log(this.valueOf())}); //Method 2
$.each($(a), function(){console.log(this.valueOf())}); //Method 3
28
Peter Mortensen 8 März 2014 im 10:50