JS-Interviewfrage: Kann forEach aus der Schleife aussteigen?

Als mir diese Frage gestellt wurde, war ich unwissend und hatte keine Ahnung. Natürlich habe ich sie nicht richtig beantwortet. Ich habe forEach immer falsch verstanden. Da es viel einfacher ist als die ursprüngliche for-Schleife, dachte ich einmal, es sei eine syntaktische Vereinfachung, die zur Vereinfachung des Schreibens erstellt wurde. Es wird auch häufig in der Wirtschaft verwendet, aber ich habe nie über die Probleme mit diesem Ansatz nachgedacht.

forEach-Nutzungsanweisungen

Referenz: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach?v=example

arr.forEach(Funktionsrückruf(aktuellerWert, Index, Array) {
    //Ihr Iterator
}[, diesesArg]);

• currentValue --- Das aktuell verarbeitete Element
• index --- Der Index des aktuell verarbeiteten Elements
• Array --- das Array, auf das forEach angewendet wird

Es gibt einen Tipp zur Verwendung von break und return in forEach. Der Originaltext lautet wie folgt:

Es gibt keine andere Möglichkeit, eine forEach()-Schleife zu stoppen oder zu unterbrechen, als eine Exception auszulösen. Wenn Sie ein solches Verhalten benötigen, ist die forEach()-Methode das falsche Werkzeug. Verwenden Sie stattdessen eine einfache Schleife. Wenn Sie die Array-Elemente auf ein Prädikat testen und einen Booleschen Rückgabewert benötigen, können Sie every() oder every() verwenden.
some() stattdessen. Falls verfügbar, können die neuen Methoden find() oder findIndex() auch für die vorzeitige Beendigung bei wahren Prädikaten verwendet werden.

Dies bedeutet, dass die Verwendung von break und return in forEach falsch ist. Wenn Sie break oder return verwenden möchten, verwenden Sie bitte every oder some-Funktionen.

Zurück zum Titel: Zunächst einmal kann forEach keine Möglichkeit nutzen, aus der Schleife auszusteigen. Warum? Wir wissen, dass forEach eine Funktion empfängt, die im Allgemeinen zwei Parameter hat, der erste ist das aktuelle Element der Schleife und der zweite ist der Index, der dem Element entspricht. Lassen Sie es uns manuell implementieren:

Array.prototype.myForEach = Funktion (fn) {
    für (lass i = 0; i < diese.Länge; i++) {
        fn(dies[i], i, dies);
    }
}

Ich habe keine Möglichkeit zu wissen, ob forEach wirklich auf diese Weise implementiert ist, aber der einfache Pseudocode oben erfüllt die Eigenschaften von forEach und es ist auch offensichtlich, dass Sie nicht aus der Schleife herausspringen können, weil Sie keine Möglichkeit haben, den echten Hauptteil der for-Schleife zu bedienen.

Später, nachdem ich die Dokumente durchgesehen hatte, stellte ich fest, dass die offizielle Definition von forEach nicht so syntaktisch einfach war, wie ich dachte. Die Standardanweisung lautet, dass forEach die von Ihnen angegebene Funktion einmal für jedes Array-Element ausführt. An diesem Punkt wurden meine Gedanken allmählich klarer und in der offiziellen Dokumentation steht auch dieser Absatz:

Es gibt keine andere Möglichkeit, die Schleife anzuhalten oder auszubrechen, als eine Ausnahme auszulösen. Wenn Sie dieses Verhalten benötigen, ist die Methode forEach() das falsche Werkzeug.

Verwenden Sie eine Throwing-Exception, um aus der Foreach-Schleife auszusteigen

sei arr = [0, 1, "Stopp", 3, 4];
versuchen {
    arr.forEach(element => {
        wenn (Element === "Stopp") {
            neuen Fehler werfen("forEachBreak");
        }
        console.log(element); // Ausgabe 0 1 und danach nichts });
} fangen (e) {
    console.log(e.message); // fürJedeBreak
};

Natürlich lässt sich bei Verwendung eines Try-Catch-Wrappers die Leistung nicht vermeiden, wenn der Schleifenkörper zu groß ist. Daher ist das Auslösen einer Ausnahme kein Allheilmittel zur Lösung des forEach-Problems. Kehren wir zum am Anfang geschriebenen Pseudocode zurück. Wir werden ihn optimieren und die Beurteilung der übergebenen Funktion zur echten for-Schleife hinzufügen:

Array.prototype.forEach = Funktion (fn) {
    für (lass i = 0; i < diese.Länge; i++) {
        sei ret = fn(dies[i], i, dies);
        wenn (Typ von ret !== "undefiniert" und (ret == null || ret == false)) abbrechen;
    }
}

Auf diese Weise können Sie auf natürliche Weise entsprechend dem Rückgabewert aus der Schleife herausspringen:

sei arr = [0, 1, "Stopp", 3, 4];

arr.forEach(element => {
    wenn (Element === 'Stopp') false zurückgibt
    console.log(element); // Ausgabe 0 1 und danach nichts });

console.log('return bedeutet fortfahren:');
arr.forEach(element => {
    wenn (Element === 'Stopp') zurückgeben
    konsole.log(element); // 0 1 3 4
});

Das Dokument erwähnt auch, dass forEach eine synchrone Funktion erfordert, was bedeutet, dass bei der Verwendung asynchroner Funktionen oder Promises als Rückrufe unerwartete Ergebnisse auftreten können. Daher sollte forEach mit Vorsicht oder überhaupt nicht verwendet werden. Dies bedeutet natürlich nicht, dass wir bei der Projektentwicklung immer einfache for-Schleifen verwenden sollten, um alles abzuschließen. Wir können for..of.. beim Durchlaufen von Arrays und for..in.. beim Durchlaufen von Objekten verwenden. Das offizielle Dokument listet auch einige andere Toolfunktionen unter dem forEach-Dokument auf:

Array.prototype.find()
Array.prototype.findIndex()
Array.prototype.map()
Array.prototype.filter()
Array.prototype.jedes()
Array.prototype.some()

Abhängig von den verschiedenen Geschäftsszenarien können Sie die entsprechenden Toolfunktionen verwenden, um die Geschäftslogik effektiver zu handhaben. Was forEach betrifft, werde ich es von nun an wohl einfach vergessen.

Zusammenfassen

Dies ist das Ende dieses Artikels über die JS-Interviewfrage, ob forEach aus der Schleife springen kann. Weitere relevante Inhalte zum Thema „JS forEach aus der Schleife springen“ finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass alle 123WORDPRESS.COM in Zukunft unterstützen werden!