Die einfache Antwort ist, eine return-Anweisung innerhalb der forEach-Schleife setzen, wie es @nnnnnn gesagt hat,
elementsCollection.forEach(function(element){
if (!element.shouldBeProcessed)
return; // Verarbeitung dieser Iteration abbrechen
// Dieser Teil wird vermieden, wenn nicht notwendig
doSomeLengthyOperation();
});
aber wenn du eine ausführliche Antwort auf diese Frage möchtest, dann bleib bei mir.
Annehmen, dass du die Implementierung der forEach-Schleife nicht kennst, dann sieh dir die folgende Implementierung der forEach-Schleife an, die genau diejenige ist, die in ECMA-262, 5. Edition für die forEach-Schleife spezifiziert ist.
Quelle Array.prototype.forEach() - JavaScript | MDN
if (!Array.prototype['forEach']) {
Array.prototype.forEach = function(callback, thisArg) {
if (this == null) { throw new TypeError('Array.prototype.forEach called on null or undefined'); }
var T, k;
// 1. Lasse O das Ergebnis des Aufrufs von toObject() unter Verwendung des
// |this| Werts als Argument sein.
var O = Object(this);
// 2. Lasse lenValue das Ergebnis des Aufrufs der Get() internen
// Methode von O mit dem Argument "length" sein.
// 3. Lasse len toUint32(lenValue) sein.
var len = O.length >>> 0;
// 4. Wenn isCallable(callback) false ist, wirf eine TypeError Ausnahme.
// Siehe: https://es5.github.com/#x9.11
if (typeof callback !== "function") { throw new TypeError(callback + ' is not a function'); }
// 5. Wenn thisArg übergeben wurde, lass T thisArg sein; andernfalls lass
// T undefined sein.
if (arguments.length > 1) { T = thisArg; }
// 6. Lass k 0 sein.
k = 0;
// 7. Wiederhole, solange k < len
while (k < len) {
var kValue;
// a. Lass Pk zu ToString(k) sein.
// Das ist implizit für LHS Operanden des in Operators
// b. Lass kPresent das Ergebnis des Aufrufs der HasProperty
// internen Methode von O mit Argument Pk sein.
// Dieser Schritt kann mit c kombiniert werden.
// c. Wenn kPresent true ist, dann
if (k in O) {
// i. Lass kValue das Ergebnis des Aufrufs der Get internen
// Methode von O mit dem Argument Pk sein.
kValue = O[k];
// ii. Ruf die Call interne Methode von callback mit T als
// dem this Wert und Argumentenliste, die kValue, k und O enthalten, auf.
callback.call(T, kValue, k, O);
}
// d. Erhöhe k um 1.
k++;
}
// 8. Gib undefined zurück
};
}
Es ist wirklich nicht notwendig, jede Zeile des obigen Codes zu verstehen, denn was uns interessiert, ist die while-Schleife,
while (k < len) {
var kValue;
// a. Lass Pk zu ToString(k) sein.
// Das ist implizit für LHS Operanden des in Operators
// b. Lass kPresent das Ergebnis des Aufrufs der HasProperty
// internen Methode von O mit Argument Pk sein.
// Dieser Schritt kann mit c kombiniert werden.
// c. Wenn kPresent true ist, dann
if (k in O) {
// i. Lass kValue das Ergebnis des Aufrufs der Get internen
// Methode von O mit dem Argument Pk sein.
kValue = O[k];
// ii. Ruf die Call interne Methode von callback mit T als
// dem this Wert und Argumentenliste, die kValue, k und O enthalten, auf.
callback.call(T, kValue, k, O);
}
// d. Erhöhe k um 1.
k++;
}
Wenn du bemerkst, gibt es eine Anweisung callback.call(T, KValue, K, O) wieder sind wir nicht an den Argumenten interessiert, die dem call()-Methode hier übergeben werden, sondern woran wir wirklich interessiert sind, ist die Bindung des callback, die eine function ist, die du deiner forEach-Schleife in JavaScript gibst. Sieh dir die Methode call einfach ruft das Objekt (JavaScript-Funktion) auf, auf das sie aufgerufen wird, mit einem this-Wert und individuell bereitgestellten Argumenten auf.
Wenn du nicht verstehst, was call ist, dann sieh dir Function.prototype.Call() - JavaScript | MDN an.
Du musst dir nur überlegen, wenn deine Funktion, die callback in diesem Fall zurückgibt, zu einem beliebigen Zeitpunkt wird die Schleife wie gewohnt aktualisiert. Die Schleife kümmert sich nicht darum, ob die callback-Funktion jeden einzelnen Schritt ausgeführt hat, der ihr gegeben wurde; wenn die Kontrolle zur Schleife zurückgegeben wurde, muss die Schleife ihre Aufgabe erfüllen. Jedes Mal, wenn die Schleife aktualisiert wird, wird der callback mit einem neuen Satz von Werten aufgerufen, wie du dort siehst T, KValue, K, O ändern sich jedes Mal, wenn sich die Schleife aktualisiert, also wenn du an einem Punkt aus deiner Funktion zurückkehrst, d. h. callback, gibst du einfach die Kontrolle an die Schleife weiter, in der du aufgerufen wurdest, egal an welchem Punkt du aus deiner Funktion zurückkehrst, wenn du einige Operationen in deiner Funktion zu einer gegebenen Bedingung überspringen möchtest, dann setze die return-Anweisung einfach vor die Anweisungen, die du überspringen möchtest.
So überspringst du eine Iteration innerhalb einer forEach-Schleife.
