Foreach loop

Für jede Schleife werden fast immer verwendet, um Elemente in einer Abfolge von Elementen zu iterieren.

Foreach Loop (oder Für jede Schleife) ist ein Steuerfluss Aussage zum Durchqueren von Elementen in a Sammlung. Nach einem Standard wird normalerweise anstelle eines Standards verwendet Für Schleife Aussage. Im Gegensatz zu anderen für Schleifenkonstrukte jedoch foreach Loops[1] Normalerweise keinen expliziten Zähler beibehalten: Sie sagen im Wesentlichen "Tun Sie dies mit allem in diesem Satz", anstatt "tun Sie dies x mal ". Dies vermeidet Potenzial Auslösende Fehler und erleichtert Code einfacher zu lesen. In objektorientierten Sprachen a IteratorAuch wenn sie implizit ist, wird häufig als Durchquerenwert verwendet.

Das für jeden Die Erklärung in einigen Sprachen hat eine definierte Reihenfolge und verarbeitet jedes Element in der Sammlung von Ersten bis zum letzten. Das für jeden Aussage in vielen anderen Sprachen, insbesondere in Array -Programmierung Sprachen haben keine bestimmte Reihenfolge. Dies vereinfacht Schleifenoptimierung Im Allgemeinen und im Besonderen erlaubt Vektorverarbeitung von Elementen in der Sammlung gleichzeitig.

Syntax

Die Syntax variiert zwischen den Sprachen. Die meisten verwenden das einfache Wort zumungefähr wie folgt:

Für jeden Artikel in Sammlung: Tun Sie etwas mit dem Artikel

Sprachunterstützung

Programmiersprachen Welche Unterstützung für Schleifen umfasst ABC, Aktionen, Ada, C ++ 11, C#, Coldfusion Markup Sprache (CFML), Kobra, D, Daplex (Abfragesprache), Delphi, ECMaskript, Erlang, Java (seit 1,5),, JavaScript, Lua, Ziel c (seit 2.0), Parasail, Perl, Php, Prolog,[2] Python, Realbasic, Rebol,[3] Rot,[4] Rubin, Scala, Smalltalk, Schnell, Tcl, TCSH, Unix -Muscheln, Visual Basic .net, und Windows PowerShell. Bemerkenswerte Sprachen ohne umher sind C, und C ++ Pre-C ++ 11.

ActionScript 3.0

Aktionen Unterstützt den ECMAScript 4.0 Standard[5] zum für jedes .. in[6] was den Wert bei jedem Index zieht.

var Foo:Objekt = { 	"Apfel":1, 	"Orange":2 }; zum jeder (var Wert:int in Foo) {  	verfolgen(Wert);  } // Gibt "1" zurück "2"

Es unterstützt auch für in[7] das zieht den Schlüssel bei jedem Index.

zum (var Schlüssel:Saite in Foo) {  	verfolgen(Schlüssel);  } // Gibt "Apple" zurück "orange" zurück

Ada

Ada Unterstützt für Schleifen als Teil des Normalen Für Schleife. Sag x ist ein Array:

zum I in X'Bereich Schleife  X (I) : = Get_next_element; Ende Schleife;

Diese Syntax wird hauptsächlich für Arrays verwendet, funktioniert aber auch mit anderen Typen, wenn eine vollständige Iteration erforderlich ist.

Die ADA 2012 hat Schleifen zu Foreach -Schleifen auf jeder Art von Container (Array, Listen, Karten ...) verallgemeinert:

zum Obj von X Schleife  - Arbeiten Sie an OBJ Ende Schleife;

C

Das C Die Sprache hat keine Sammlungen oder ein Foreach -Konstrukt. Es verfügt jedoch über mehrere Standarddatenstrukturen, die als Sammlungen verwendet werden können, und kann leicht mit a gemacht werden Makro.

Es treten jedoch zwei offensichtliche Probleme auf:

  • Das Makro ist unhygienisch: Es deklariert eine neue Variable im vorhandenen Bereich, das nach der Schleife verbleibt.
  • Ein für das Leach -Makro kann nicht definiert werden, der mit unterschiedlichen Sammlungstypen (z. B. Array und verknüpfte Liste) funktioniert oder die für Benutzertypen erweiterbar ist.

C String als Sammlung von Char

#enthalten   / * foreach makro, in der eine Zeichenfolge als Sammlung von Zeichenwerten */angezeigt wird #define foreach (ptrvar, strvar) \ char* ptrvar; \ für (ptrvar = strvar; ( *ptrvar)! = '\ 0'; *ptrvar ++)  int hauptsächlich(int argc, verkohlen** argv) {  verkohlen* S1 = "Abcdefg";  verkohlen* S2 = "123456789";  für jeden (P1, S1) {   printf("Schleife 1: %c\n", *P1);  }  für jeden (p2, S2) {   printf("Schleife 2: %c\n", *p2);  }  Rückkehr 0; }

C int-Array als Sammlung von INT (Array-Größe, die bei Compile-Time bekannt ist)

#enthalten   / * foreach makro, das ein Array von int -Werten als Sammlung von int -Werten betrachtet */ #define foreach (intpvar, intarr) \ int* intpvar; \ für (intpvar = intarr; intpvar <(intarr +(sizeof (intarr)/sizeof (intarr [0]))); ++ intpvar)  int hauptsächlich(int argc, verkohlen** argv) {  int A1[] = {1, 1, 2, 3, 5, 8};  int A2[] = {3, 1, 4, 1, 5, 9};  für jeden (P1, A1) {   printf("Schleife 1: %d\n", *P1);  }  für jeden (p2, A2) {   printf("Schleife 2: %d\n", *p2);  }  Rückkehr 0; }

Allgemeine: String oder Array als Sammlung (Sammlungsgröße zur Laufzeit bekannt)

Notiz: idxtype kann entfernt werden und Typof (col [0]) an seiner Stelle verwendet mit GCC
#enthalten  #enthalten   / * foreach makro, in dem ein Array von gegebener Typ als Sammlung von Werten des angegebenen Typs */angezeigt wird #define arraylen (arr) (sizeof (arr)/sizeof (arr [0])) #define foreach (idXtype, idxpvar, col, colsiz) \ idXType* idxpvar; \ für (idxpvar = col; idxpvar <(col +colSiz); ++ idxpvar)  int hauptsächlich(int argc, verkohlen** argv) {  verkohlen* C1 = "Sammlung";  int C2[] = {3, 1, 4, 1, 5, 9};  doppelt* C3;  int C3len = 4;  C3 = (doppelt*)CALLOC(C3len, Größe von(doppelt));   C3[0] = 1.2; C3[1] = 3.4; C3[2] = 5.6; C3[3] = 7.8;   für jeden (verkohlen, P1, C1, Strlen(C1)) {   printf("Schleife 1: %c\n", *P1);  }  für jeden (int, p2, C2, Arraylen(C2)) {   printf("Schleife 2: %d\n", *p2);  }  für jeden (doppelt, p3, C3, C3len) {   printf("Schleife 3:%.1LF\n", *p3);  }  Rückkehr 0; }

C#

Im C#Angenommen, Myarray ist eine Reihe von ganzen Zahlen:

für jeden (int x in myarray) { Konsole.Schreiben(x); }

Sprache integrierte Abfrage (Linq) liefert die folgende Syntax, um a zu akzeptieren delegieren oder Lambda -Ausdruck:

myarray.Auflisten().Für jeden(x => Konsole.Schreiben(x));

C ++

C ++ 11 Bietet eine Foreach -Schleife. Die Syntax ähnelt der von Java:

#enthalten  int hauptsächlich() {   int myint[] = {1, 2, 3, 4, 5};   zum (int i : myint)   {   std::Cout << i << '\n';   } }

C ++ 11 Range basierend für Aussagen wurde in implementiert in GNU Compiler -Sammlung (GCC) (seit Version 4.6), Klang (seit Version 3.0) und Visuell c ++ 2012 (Version 11 [8]))

Der Bereichsbasis zum ist syntethischer Zucker gleichwertig:

  zum (Auto __anon = Start(myint); __anon ! = Ende(myint); ++__anon)   {   Auto i = *__anon;   std::Cout << i << '\n';   }

Der Compiler verwendet Argumentabhängige Suche um die zu beheben Start und Ende Funktionen.[9]

Die C ++ - Standardbibliothek unterstützt auch für jeden,[10] Das wendet jedes Element auf eine Funktion an, die jede vordefinierte Funktion oder ein Lambda -Ausdruck sein kann. Während der Bereich für erst vom Anfang bis zum Ende ist, können Sie die Richtung oder den Bereich ändern, indem Sie die ersten beiden Parameter ändern.

#enthalten  #enthalten  // enthält std :: for_each #enthalten  int hauptsächlich() {   std::Vektor<int> v {1, 2, 3, 4, 5};   std::für jeden(v.Start(),, v.Ende(),, [] (int i)   {   std::Cout << i << '\n';   });   std::Cout << "Umgekehrt, aber 2 Elemente überspringen:\n";   std::für jeden(v.rbegin()+2, v.zerreißen(),, [] (int i)   {   std::Cout << i << '\n';   }); }

Qt, ein C ++ - Framework, bietet ein Makro, das für Schleifen zur Verfügung stellt[11] Verwenden der STL -Iterator -Schnittstelle:

#enthalten  #enthalten  int hauptsächlich() {   Qlist<int> aufführen;   aufführen << 1 << 2 << 3 << 4 << 5;   für jeden (int i, aufführen)   {   Qdebug() << i;   } }

Schub, Eine Reihe von kostenlosen, von Experten begutachteten tragbaren C ++-Bibliotheken enthält auch Forach-Loops:[12] 

#enthalten  #enthalten    int hauptsächlich() {   int myint[] = {1, 2, 3, 4, 5};     Boost_foreach(int &i, myint)   {   std::Cout << i << '\n';   } }

C ++/cli

Das C ++/cli Die Sprache schlägt ein ähnliches Konstrukt vor C#.

Angenommen, Myarray ist eine Reihe von ganzen Zahlen:

zum jeder (int x in myarray) {  Konsole::Schreiben(x); }

ColdFusion Markup Sprache (CFML)

Hauptartikel: Coldfusion Markup Sprache

Skriptsyntax 

// Arrays Arrayach[1,2,3,4,5], Funktion(v) {  Recordput(v); }); // oder zum (v in [1,2,3,4,5]) {  Recordput(v); } // oder // (nur Railo; nicht in Coldfusion unterstützt) Briefe = ["a","b","c","d","E"]; Letters.each(Funktion(v) {  Recordput(v); // Abcde }); // Strukturen zum (k in Sammlung) {  Recordput(Sammlung[k]); } // oder strukturiert(Sammlung, Funktion(k,v) {  Recordput("Schlüssel: #K#, Wert: #V#; ""); }); // oder // (nur Railo; nicht in Coldfusion unterstützt) Sammlung.each(Funktion(k,v) {  Recordput("Schlüssel: #K#, Wert: #V#; ""); });

Tag -Syntax 

  Index="V" Array="#['A', 'B', 'C', 'D', 'E']#">  #v#

CFML identifiziert den Wert als "Index" in diesem Konstrukt fälschlicherweise. das Index Variable empfängt den tatsächlichen Wert des Array -Elements, nicht des Index.

  Artikel="k" Sammlung="#Sammlung#">  #Sammlung[k]#

Common Lisp

Common Lisp Bietet für die Fähigkeit der Vermittlung entweder mit dem Dolist Makro:

(Dolist (i '(1 3 5 6 8 10 14 17))  (drucken i))

oder die Mächtigen Schleife Makro, um mehr Datentypen zu iterieren

(Schleife zum i in '(1 3 5 6 8 10 14 17)  tun (drucken i))

und sogar mit dem MAPCAR Funktion:

(MAPCAR #'drucken '(1 3 5 6 8 10 14 17))

D

Hauptartikel: D (Programmiersprache) 
für jeden(Artikel; einstellen) {  // etwas zu Gegenstand tun }

oder

für jeden(Streit) {  // Wert bestehen }

Pfeil

Hauptartikel: Dart (Programmiersprache) 
zum (Finale Element in Somecollection) {  // etwas mit Element mach }

Objekt Pascal, Delphi

Hauptartikel: Objekt Pascal

Für die Unterstützung von Unterstützung wurde in hinzugefügt Delphi 2005 und verwendet eine Enumerator -Variable, die in der deklariert werden muss var Sektion.

zum Aufzähler in Sammlung tun Start  // Mach hier etwas Ende;

Eiffel

Die Iteration (foreach) Form der Eiffel Das Schleifenkonstrukt wird durch das Schlüsselwort eingeführt across.

In diesem Beispiel jedes Element der Struktur meine Liste wird gedruckt:

  über meine Liste wie IC Schleife drucken (IC.Artikel) Ende

Die lokale Einheit IC ist eine Instanz der Bibliotheksklasse Iteration_Cursor. Das Cursor -Feature Artikel Bietet Zugriff auf jedes Strukturelement. Nachkommen der Klasse Iteration_Cursor Kann erstellt werden, um spezialisierte Iterationsalgorithmen zu verarbeiten. Die Arten von Objekten, die iteriert werden können (meine Liste im Beispiel) basieren auf Klassen, die aus der Bibliotheksklasse erben WIEDERHOLBAR.

Die Iterationsform der Eiffelschleife kann auch als boolescher Ausdruck verwendet werden, wenn das Schlüsselwort Schleife wird durch beide ersetzt alle (Wirkung Universelle Quantifizierung) oder etwas (Wirkung Existenzielle Quantifizierung).

Diese Iteration ist ein boolescher Ausdruck, der wahr ist, wenn alle Elemente in meine Liste Zählungen von mehr als drei haben:

  über meine Liste wie IC alle IC.Artikel.zählen > 3 Ende

Das Folgende ist wahr, wenn mindestens ein Artikel eine Anzahl von mehr als drei hat:

  über meine Liste wie IC etwas IC.Artikel.zählen > 3 Ende

gehen

gehen's foreach Loop kann verwendet werden, um über ein Array, eine Scheibe, eine String, eine Karte oder einen Kanal zu schleifen.

Mit dem Zwei-Wert-Formular erhalten wir den Index/Schlüssel (erstes Element) und den Wert (zweites Element):

zum Index, Wert : = Angebot Somecollection { 	// etwas zum Index und Wert tue }

Mit dem Ein-Wert-Formular erhalten wir den Index/Schlüssel (erstes Element):

zum Index : = Angebot Somecollection { 	// etwas zum Index tue }

[13]

Groovig

Groovig Unterstützung zum Schleifen über Sammlungen wie Arrays, Listen und Bereiche:

def x = [1,2,3,4] zum (v in x)  // Schleife über das 4-Element-Array x {  println v } zum (v in [1,2,3,4]))  // Schleife über 4-Element-Literalliste  {  println v } zum (v in 1..4)  // Schleife über den Bereich 1..4 {  println v }

Groovy unterstützt auch einen C-Stil für Schleife mit einem Array-Index:

zum (i = 0; i < x.Größe(); i++) {  println x[i] }

Sammlungen in Groovy können auch über die Verwendung der iteriert werden jeder Schlüsselwort und eine Schließung. Standardmäßig wird der Schleifenschuhtummy benannt es 

x.jeder{ println es }  // Drucken Sie jedes Element des X -Arrays x.jeder{i-> println i}  // Äquivalent zur obigen Linie, nur Schleifenschummel explizit "I" genannt "I"

Haskell

Haskell Ermöglicht das Schleifen über Listen mit monadisch Aktionen verwenden MAPM_ und bilden_ (MAPM_ mit seinen Argumenten geflippt) von Kontrolle.Monad:

Code Drucke 
MAPM_ drucken [1..4] 
1 2 3 4 
bilden_ "Prüfung" $ \verkohlen -> tun   Putchar verkohlen  Putchar verkohlen 
tteesstt

Es ist auch möglich, diese Funktionen so zu verallgemeinern, dass sie eher an Anwendungsfunktionen als an Monaden und jeder Datenstruktur arbeiten, die mithilfe von Verwendungsgrad durchlaufen werden kann Traverse (zum mit seinen Argumenten umgedreht) und MAPM (bilden mit seinen Argumenten geflippt) von Data.traversable.

Haxe

Hauptartikel: Haxe 
zum (Wert in wiederholbar) {  verfolgen(Wert); } Lambda.Iter(wiederholbar, Funktion(Wert) verfolgen(Wert));

Java

Im Java, ein für dasesconstruct wurde eingeführt in Java Entwickler-Kit (JDK) 1.5.0.[14]

Offizielle Quellen verwenden mehrere Namen für das Konstrukt. Es wird als "Enhanced for Loop" bezeichnet.[14] die "For-Each-Schleife",[15] und die "Foreach -Erklärung".[16] 

zum (Typ Artikel : IterableCollection) {  // etwas zu Gegenstand tun }

JavaScript

Das ECMascript 6 Standard hat für..of Für die Iteration ohne Index ohne Generatoren, Arrays und mehr:

zum (var Artikel von Array) {  // Sachen machen }

Alternativ funktionsbasierter Stil: [17] 

Array.für jeden(Artikel => {  // Sachen machen })

Für ungeordnete Iteration über die Schlüssel in einem Objekt, JavaScript zeigt das für in Schleife:

zum (var Schlüssel in Objekt) {  // Machen Sie Dinge mit Objekt [Schlüssel] }

Um die Iteration auf die Eigenschaften des Objekts zu beschränken, ohne die durch die Prototypkette geerbten, ist es manchmal nützlich, einen HasownProperty () -Test hinzuzufügen, Wenn er von der JavaScript -Engine unterstützt wird (Für Webkit/Safari bedeutet dies "in Version 3 oder später").

zum (var Schlüssel in Objekt) {  wenn (Objekt.HasownProperty(Schlüssel)) {  // Machen Sie Dinge mit Objekt [Schlüssel]  } }

ECMascript 5 Bereitstellung von Object.Keys Methode, um die eigenen Schlüssel eines Objekts in ein Array zu übertragen.[18] 

var Buchen = { Name: "Ein Weihnachtslied", Autor: "Charles Dickens" };  zum(var Schlüssel von Objekt.Schlüssel(Buchen)) {  Alarm("PropertyName =" Schlüssel + "Eigenschaftswert =" + Buchen[Schlüssel]); }

Lua[19]

Hauptartikel: Lua (Programmiersprache)

Nur durch numerische Indexwerte iterieren:

zum Index, Wert in Ipairs(Array) tun 	-- etwas tun Ende

Durch alle Indexwerte iterieren:

zum Index, Wert in Paare(Array) tun 	-- etwas tun Ende

Mathematica

Im Mathematica, Tun Bewertet einfach einen Ausdruck für jedes Element einer Liste, ohne einen Wert zurückzugeben.

Im[]: = Tun[Dosomethitem mit, {Artikel, aufführen}]

Es ist häufiger zu verwenden Tisch, was das Ergebnis jeder Bewertung in einer neuen Liste zurückgibt.

Im[]: = aufführen = {3, 4, 5}; Im[]: = Tisch[Artikel^2, {Artikel, aufführen}] aus[]= {9, 16, 25}

Matlab

Hauptartikel: Matlab 
zum Artikel = Array %etwas tun Ende

Minze

Für jede Schleifen werden in Mint unterstützt, die die folgende Syntax besitzen:

zum jeder Element von aufführen  /* 'Etwas tun.' */ Ende

Das zum (;;) oder während (wahr) Endlosschleife in Minze kann mit einem für jede Schleife und ein geschrieben werden unendlich lange Liste.[20] 

importieren Typ /* 'Diese Funktion wird auf' zugeordnet  * 'Jede Indexnummer I der' '  * 'Unendlich lange Liste.'  */ Sub Identität(x)  Rückkehr x Ende /* 'Das Folgende erstellt die Liste'  * '[0, 1, 2, 3, 4, 5, ..., Infinity]'  */ Infinitelistin = aufführen(Identität) zum jeder Element von Infinitelistin  /* 'Mach etwas für immer.' */ Ende

Ziel c

Foreach Loops, genannt Schnelle Aufzählung, werden beginnend unterstützt Ziel c 2.0. Sie können verwendet werden, um über jedes Objekt zu iterieren, das das NSFastEnumeration -Protokoll implementiert, einschließlich NSArray, NSDictionary (Iterates Over -Tasten), NSSet usw.

Nsarray *a = [Nsarray Neu];  // Jede Containerklasse kann ersetzt werden zum(Ich würde obj in a) {  // Beachten Sie die dynamische Tippen (wir müssen das nicht wissen   // Art des in 'a' gespeicherten Objekts. In der Tat kann es geben   // viele verschiedene Arten von Objekten im Array.   printf("%s\n", [[obj Bezeichnung] UTF8String]);  // muss UTF8String mit %s verwenden   Nslog(@"%@", obj);  // als Objekt verlassen }

NSArrays können auch eine Nachricht an ihre Mitglieder senden:

Nsarray *a = [Nsarray Neu]; [a MakoBjectSperformselector:@Wähler(printdescription)];

Wo Blöcke Ein NSArray ist verfügbar, kann automatisch einen Block für jeden enthaltenen Element ausführen:

[myarray enumerateObjectsusingblock:^(Ich würde obj, Nsuinteger IDX, Bool *Pause) 	{ 		Nslog(@"obj%@", obj); 		wenn [obj Sollte Intenation])) 			*Pause = JAWOHL; 	}];

Die Art der iterierten Sammlung diktiert den mit jeder Iteration zurückgegebenen Artikel. Zum Beispiel:

NSDictionary *d = [NSDictionary Neu]; zum(Ich würde Schlüssel in d) {   NSOBJECT *obj = [d ObjectForkey:Schlüssel];  // Wir verwenden den (eindeutigen) Schlüssel, um auf das (möglicherweise nicht eindeutige) Objekt zuzugreifen.   Nslog(@"%@", obj); }

Ocaml

Ocaml ist ein funktionale Sprache. Somit kann das Äquivalent einer foreach -Schleife als Bibliotheksfunktion über Listen und Arrays erreicht werden.

Für Listen:

Aufführen.Iter (Spaß x -> print_int x) [1;2;3;4] ;;

oder kurz:

Aufführen.Iter print_int [1;2;3;4] ;;

Für Arrays:

Array.Iter (Spaß x -> print_int x) [|1;2;3;4|] ;;

oder kurz:

Array.Iter print_int [|1;2;3;4|] ;;

Parasail

Das Parasail Die parallele Programmiersprache unterstützt verschiedene Arten von Iteratoren, einschließlich eines allgemeinen "Iterators" für jeden "Iterator über einem Container:

var Con : Container<Element_type> : = ... // ... zum jeder Elem von Con gleichzeitig Schleife  // Schleife kann auch "vorwärts" oder "umgekehrt" oder nicht ordnungsgemäß sein (der Standard)  // ... etwas mit Elem mach Ende Schleife

Parasail unterstützt auch Filter bei Iteratoren und die Fähigkeit, sich sowohl auf den Schlüssel als auch auf den Wert einer Karte zu beziehen. Hier ist eine Vorwärts -Iteration über die Elemente von "my_map", die nur Elemente auswählen, bei denen sich die Schlüssel in "my_set" befinden:

var My_map : Karte<Schlüsselart => Univ_string, Werttyp => Baum<Ganze Zahl>> : = ... Const My_set : Satz<Univ_string> : = ["ABC", "def", "Ghi"]; zum jeder [Str => Tr] von My_map {Str in My_set} nach vorne Schleife  // ... etwas mit STR oder TR machen Ende Schleife

Pascal

Im Pascal, ISO Standard 10206: 1990 eingeführte Iteration über Setzen Sie Typen, daher:

var  lt: Elementtype;  ELTSET: einstellen von Elementtype; {...} zum lt in ELTSET tun  {... etwas mit ELT} machen

Perl

Im Perl, für jeden (Dies entspricht dem kürzeren für) kann verwendet werden, um Elemente einer Liste zu durchqueren. Der Ausdruck, der die Sammlung angibt, die überschreiten soll, wird im Listenkontext bewertet und jedes Element der resultierenden Liste wird wiederum auf die Schleifenvariable hingewiesen.

Listen Sie ein wörtliches Beispiel: Beispiel:

für jeden (1, 2, 3, 4) {  drucken $ _; }

Array -Beispiele:

für jeden (@arr) {  drucken $ _; } 
für jeden $ x (@arr) { #$ x ist das Element in @arr  drucken $ x; }

Hash Beispiel:

für jeden $ x (Schlüssel %Hash) {  drucken $ x . "=" . $ hash{$ x}; # $ x ist ein Schlüssel in %Hash und $ Hash {$ x} ist sein Wert }

Direkte Änderung der Sammlungsmitglieder:

@arr = ( "REMED-FOO", "Entfernen Sie Bar" ); für jeden $ x (@arr) {  $ x = ~ s/entfernen-//; } # Jetzt @arr = ('foo', 'Bar');

Php

Hauptartikel: PHP syntax and semantics 
für jeden ($ set wie $ Wert) {  // etwas zu $ ​​Wert machen; }

Es ist auch möglich, sowohl Schlüssel als auch Werte unter Verwendung der alternativen Syntax zu extrahieren:

für jeden ($ set wie $ key => $ Wert) {  Echo "{$ key} hat einen Wert von {$ Wert}"; }

Direkte Änderung der Sammlungsmitglieder:

$ arr = Array(1, 2, 3); für jeden ($ arr wie &$ Wert) { // beachten  $ Wert++; } // jetzt $ arr = Array (2, 3, 4); // funktioniert auch mit der vollständigen Syntax für jeden ($ arr wie $ key => &$ Wert) {  $ Wert++; }

Python

Hauptartikel: Python (Programmiersprache) 
zum Artikel in iterable_collection:  # Mach etwas mit Artikel

Pythons Tupelzuordnung, die in seiner Foreach -Schleife vollständig verfügbar ist assoziative Arrays:

zum Schlüssel, Wert in SONDICT.Artikel():  # Direkte Iteration auf einem Diktat iteriert seine Schlüssel  # Sachen machen

Wie für in ist die einzige Art von für Schleife in Python, das entspricht der in anderen Sprachen gefundenen "Zähler" -Schloop ist ...

zum i in Angebot(Len(seq)):  # Mach etwas mit seq [i]

... obwohl ich die benutze aufzählen Die Funktion wird als "pythonisch" angesehen:

zum i, Artikel in aufzählen(seq):  # Machen Sie Sachen mit Artikel  # Zuweisen Sie es möglicherweise SEQ [i] zurück zurück

Schläger

Hauptartikel: Schläger (Programmiersprache) 
(zum [Artikel einstellen]))  (DO-BISE-MIT Artikel))

oder mit dem konventionellen Schema für jeden Funktion:

(für jeden DO-BISE-MIT eine Liste)

DO-BISE-MIT ist eine Ein-Argument-Funktion.

Raku

Im Raku, eine Schwestersprache zu Perl, zum muss verwendet werden, um Elemente einer Liste zu durchqueren (für jeden ist nicht erlaubt). Der Ausdruck, der die Sammlung angibt, die überschreiten soll, wird in List-Kontext bewertet, aber standardmäßig nicht abgeflacht, und jedes Element der resultierenden Liste ist wiederum die Schleifenvariable (en).

Listen Sie ein wörtliches Beispiel: Beispiel:

zum 1..4 {.sagen; }

Array -Beispiele:

zum @arr {.sagen; }

Die for -Schleife in seiner Anweisung -Modifikatorform:

.sagen zum @arr;
zum @arr -> $ x { sagen $ x; }
zum @arr -> $ x, $ y { # mehr als ein Artikel gleichzeitig  sagen "$ x, $ y"; }

Hash Beispiel:

zum Schlüssel %Hash -> $ key { sagen "$ key: $ hash {$ key}"; }

oder

zum %Hash.KV -> $ key, $ Wert { sagen "$ key: $ value"; }

oder

zum %Hash -> $ x { sagen "$ X.Key (): $ x.Value ()"; # Klammern mussten in die doppelt zitierte Zeichenfolge eintreten }


Direkte Modifikation von Sammlungsmitgliedern mit einem doppelt spitzen Block, <->:

mein @arr = 1,2,3;zum @arr <-> $ x { $ x *= 2; }# Jetzt @arr = 2,4,6;

Rubin

Hauptartikel: Ruby (Programmiersprache) 
einstellen.jeder tun |Artikel|  # etwas zu Gegenstand tun Ende

oder

zum Artikel in einstellen  # etwas zu Gegenstand tun Ende

Dies kann auch mit einem Hash verwendet werden.

einstellen.jeder tun |Artikel,Wert|  # etwas zu Gegenstand tun  # etwas zu schätzen tu Ende

Rost

Hauptartikel: Rust (programming language)

Das zum Schleife hat die Struktur zum in { / * Optionale Anweisungen * /}. Es ruft die implizit die Incorator :: Into_iter Methode für den Ausdruck und verwendet den resultierenden Wert, der das implementieren muss Iterator Merkmal. Wenn der Ausdruck selbst ein Iterator ist, wird er direkt von dem verwendet zum Schleife durch ein Implementierung von Literator für alle Iterators Das gibt den Iterator unverändert zurück. Die Schleife ruft die an Iterator :: Weiter Methode auf dem Iterator vor Ausführung des Schleifenkörpers. Wenn Iterator :: Weiter kehrt zurück Etwas(_)Der Wert im Inneren wird dem zugeordnet Muster und der Schleifenkörper wird ausgeführt; Wenn es zurückkehrt KeinerDie Schleife wird beendet.

Lassen Mut Zahlen = VEC![1, 2, 3]; // unveränderliche Referenz: zum Nummer in &Zahlen { // Rufe Incoratorator :: Into_iter (& Nummern) an   println!("{}", Nummer); } zum Quadrat in Zahlen.Iter().Karte(|x| x * x) { // number.iter (). map (| x | x * x) implementiert den Iterator   println!("{}", Quadrat); } // Veränderliche Referenz: zum Nummer in &Mut Zahlen { // Rufe Incoratorator :: Into_iter (& Mut Nummern) an   *Nummer *= 2; } // Drucke "[2, 4, 6]": println!("{:?}", Zahlen); // verbraucht den VEC und erstellt einen Iterator: zum Nummer in Zahlen { // Rufe Incoratorator :: Into_iter (Zahlen) an   // ... } // Fehler mit "Ausleihen von bewegtem Wert": // println! ("{:?}", number);

Scala

Hauptartikel: Scala (Programmiersprache) 
// Rückgabeliste geänderter Elemente Artikel Karte { x => etwas tun(x) } Artikel Karte MultiplyBytwo zum {x <- Artikel} Ertrag etwas tun(x) zum {x <- Artikel} Ertrag MultiplyBytwo(x) // Nichts zurückgeben, einfach Aktion ausführen Artikel für jeden { x => etwas tun(x) } Artikel für jeden println zum {x <- Artikel} etwas tun(x) zum {x <- Artikel} println(x) // Musteranpassungsbeispiel für das Verständnis zum ((Schlüssel, Wert) <- Somemap) println(s"$Schlüssel -> $Wert")

Planen

Hauptartikel: Schema (Programmiersprache) 
(für jeden DO-BISE-MIT eine Liste)

DO-BISE-MIT ist eine Ein-Argument-Funktion.

Smalltalk

Hauptartikel: Smalltalk 
Sammlung tun: [:Artikel| "Mach etwas zu Gegenstand" ]

Schnell

Schnell verwendet die zum…in Konstruktion, um Mitglieder einer Sammlung zu iterieren.[21] 

zum Ding in Somecollection {   // etwas mit Ding mach }

Das zum…in Die Schleife wird häufig mit den Konstrukten geschlossener und halber Öffnung verwendet, um eine bestimmte Anzahl von Male über den Schleifenkörper zu iterieren.

zum i in 0..<10 {   // 0 .. <10 konstruiert einen halben Öffnungsbereich, also den Schleifenkörper   // wird für i = 0, i = 1,…, i = 9 wiederholt. } zum i in 0...10 {   // 0 ... 10 konstruiert einen geschlossenen Bereich, also den Schleifenkörper   // wird für i = 0, i = 1,…, i = 9, i = 10 wiederholt. }

Systemverilog

Systemverilog unterstützt die Iteration über einen beliebigen Vektor- oder Array -Typ einer beliebigen Dimensionalität mit dem für jeden Stichwort.

Ein triviales Beispiel iteriert über eine Reihe von ganzen Zahlen:

Code Drucke 
int  Array_1d[] = '{ 3, 2, 1, 0 }; für jeden Array_1d[Index]  $Anzeige("array_1d [ %0d]: %0d", Index, Array_1d[Index]); 
Array_1d [0]: 3 Array_1d [1]: 2 Array_1d [2]: 1 Array_1d [3]: 0

Ein komplexeres Beispiel iteriert eine assoziative Reihe von Arrays von ganzen Zahlen:

Code Drucke 
int  Array_2d[Saite][] = '{ "Zehn": '{ 10, 11 },  "zwanziger Jahre": '{ 20, 21 } }; für jeden Array_2d[Schlüssel,Index]  $Anzeige("Array_2d [%s,%0d]:%0d", Schlüssel, Index, Array_2d[Schlüssel,Index]); 
Array_2d [Tens, 0]: 10 Array_2d [TENS, 1]: 11 Array_2d [Zwanzig Jahre, 0]: 20 Array_2d [Zwanziger Jahre, 1]: 21

Tcl

Tcl Verwendet, um über Listen zu iterieren. Es ist möglich, mehr als eine Iteratorvariable anzugeben. In diesem Fall werden ihnen sequentielle Werte aus der Liste zugewiesen.

Code Drucke 
für jeden {i j} {1 2 3 4 5 6} {   stellt "$ i $ j" } 
1 2 3 4 5 6

Es ist auch möglich, über mehr als eine Liste gleichzeitig zu iterieren. Im Folgenden i nimmt sequentielle Werte der ersten Liste an, j Sequentielle Werte der zweiten Liste:

Code Drucke 
für jeden i {1 2 3} j {a b c}  {   stellt "$ i $ j" } 
1 a 2 b 3 c

Visual Basic .net

Hauptartikel: Visual Basic .net 
Zum Jeder Artikel Im Aufzählbar  'Mach etwas mit Gegenstand. Nächste

oder ohne Geben Sie Inferenz ein 

Zum Jeder Artikel Wie Typ Im Aufzählbar  'Mach etwas mit Gegenstand. Nächste

Fenster

Konventioneller Befehlsprozessor

Hauptartikel: Command.com und cmd.exe

Rufen Sie eine Hypothetik an Frob Befehl dreimal und geben Sie ihm jedes Mal einen Farbnamen.

C: \>ZUM %%a IN ( rot grün blau ) TUN Frob %%a

Windows PowerShell

Hauptartikel: Windows PowerShell 
für jeden ($ item in $ set) {  # Mach etwas zu $ ​​item }

Aus einer Pipeline

$ liste | Für jeden-Objekt {Schreibhost $ _} # oder die Aliase verwenden $ liste | für jeden {schreiben $ _} $ liste | % {schreiben $ _}

Xslt

Hauptartikel: Xslt 
  select ="einstellen">

[22]

Siehe auch

Verweise

  1. ^ "D Programmiersprache für jeden Anweisung Dokumentation ". Digital Mars. Abgerufen 2008-08-04.
  2. ^ "Swi-prolog-foreach/2". www.swi-prolog.org. Abgerufen 2020-02-10.
  3. ^ http://www.rebol.com. {{}}: Fehlen oder leer |title= (Hilfe)
  4. ^ http://www.red-lang.org. {{}}: Fehlen oder leer |title= (Hilfe)
  5. ^ "Vorgeschlagene ECMascript 4. Ausgabe - Sprachübersicht" (PDF). Abgerufen 2020-02-21.
  6. ^ "für jeden ... in". Abgerufen 2020-02-21.
  7. ^ "für in". Abgerufen 2020-02-21.
  8. ^ "C ++ 11 Funktionen in Visual C ++ 11 - Visual C ++ Team Blog - Site Home - MSDN -Blogs". Blogs.msdn.com. 2011-09-12. Abgerufen 2013-08-04.
  9. ^ "Bereichsbasis für Schleife (seit C ++ 11)". en.cppreference.com. Abgerufen 2018-12-03.
  10. ^ "std :: for_each - cppreference". en.cppreference.com. Abgerufen 2017-09-30.
  11. ^ "QT 4.2: Generische Container". Doc.qt.digia.com. Archiviert von das Original Am 2015-11-23. Abgerufen 2013-08-04.
  12. ^ Eric Niebler (2013-01-31). "Kapitel 9. Boost.foreach - 1.53.0". Boost.org. Abgerufen 2013-08-04.
  13. ^ "Bereichsklausel". Die GO -Programmiersprachenspezifikation.Die Go -Programmiersprache. Abgerufen 20. Oktober, 2013.
  14. ^ a b "Verbessert für Schleifen - dieses neue Sprachkonstrukt [...]" "Java -Programmiersprache, Abschnitt: Verbesserungen in JDK 5". Sun Microsystems, Inc. 2004. Abgerufen 2009-05-26.
  15. ^ "Die For-Each-Schleife" "Die For-Each-Schleife". Sun Microsystems, Inc. 2008. Abgerufen 2009-05-10.
  16. ^ "Implementieren dieser Schnittstelle ermöglicht es einem Objekt, das Ziel der" foreach "-serklärung" zu sein. "Iterbar (Java -Plattform SE 6)". Sun Microsystems, Inc. 2004. Abgerufen 2009-05-12.
  17. ^ "Array.Prototype.foreach () - JavaScript | Mdn".
  18. ^ "Object.keys". Mozilla Developer Network. Abgerufen 7. Mai, 2014.
  19. ^ "Lua -Programmierung/Tabellen - Wikibooks, offene Bücher für eine offene Welt". en.wikibooks.org. Abgerufen 2017-12-06.
  20. ^ Chu, Oliver. "Minz -Tutorial". Abgerufen 20. Oktober 2013.
  21. ^ "Steuerfluss - Die Swift -Programmiersprache (Swift 5.5)".
  22. ^ "XSLT <XSL: For-Each> Element". W3schools.com.