Foreach-Schleife – Wikipedia

Posted on by
before-content-x4

Kontrollflussanweisung

Für jede Schleife werden fast immer Elemente in einer Folge von Elementen durchlaufen.

Foreach-Schleife (oder für jede Schleife) ist eine Kontrollflussanweisung zum Durchlaufen von Elementen in einer Sammlung. Foreach wird normalerweise anstelle eines Standards verwendet für Schleife Erklärung. Im Gegensatz zu anderen for-Schleifenkonstrukten jedoch foreach-Schleifen[1] In der Regel wird kein expliziter Zähler beibehalten: Sie sagen im Wesentlichen “Tun Sie dies für alles in diesem Satz” und nicht “Tun Sie dies” x times “. Dies vermeidet mögliche Fehler nacheinander und vereinfacht das Lesen von Code. In objektorientierten Sprachen wird häufig ein Iterator, auch wenn er implizit ist, als Mittel zum Durchlaufen verwendet.

Das für jeden Die Anweisung in einigen Sprachen hat eine definierte Reihenfolge, in der jedes Element in der Sammlung vom ersten bis zum letzten verarbeitet wird. Das für jeden Anweisungen in vielen anderen Sprachen, insbesondere in Array-Programmiersprachen, haben keine bestimmte Reihenfolge. Dies vereinfacht die Schleifenoptimierung im Allgemeinen und ermöglicht im Besonderen die gleichzeitige Vektorverarbeitung von Elementen in der Sammlung.

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

for each item in collection:
  do something to item

Sprachunterstützung[edit]

Zu den Programmiersprachen, die jede Schleife unterstützen, gehören ABC, ActionScript, Ada, C ++ 11, C #, CFML (ColdFusion Markup Language), Cobra, D, Daplex (Abfragesprache), Delphi, ECMAScript, Erlang, Java (seit 1.5), JavaScript , Lua, Objective-C (seit 2.0), ParaSail, Perl, PHP, Prolog,[2]Python, REALbasic, Ruby, Scala, Smalltalk, Swift, Tcl, tcsh, Unix-Shells, Visual Basic .NET und Windows PowerShell. Bemerkenswerte Sprachen ohne foreach sind C und C ++ vor C ++ 11.

ActionScript 3.0[edit]

ActionScript unterstützt den ECMAScript 4.0-Standard[3] zum for each .. in[4] Dadurch wird der Wert an jedem Index abgerufen. 

var foo:Object = {
	"apple":1,
	"orange":2
};

for each (var value:int in foo) { 
	trace(value); 
}

// returns "1" then "2"

Es unterstützt auch for .. in[5] das zieht den Schlüssel an jedem Index. 

for (var key:String in foo) { 
	trace(key); 
}

// returns "apple" then "orange"

Ada[edit]

Ada unterstützt foreach-Schleifen als Teil der normalen for-Schleife. Angenommen, X ist ein Array: 

for I in X'Range loop
   X (I) := Get_Next_Element;
end loop;

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

Ada 2012 hat Schleifen verallgemeinert, um Schleifen für jede Art von Container (Array, Listen, Karten …) zu finden: 

for Obj of X loop
   -- Work on Obj
end loop;

C.[edit]

Die C-Sprache enthält keine Sammlungen oder ein foreach-Konstrukt. Es verfügt jedoch über mehrere Standarddatenstrukturen, die als Sammlungen verwendet werden können, und foreach kann einfach mit einem Makro erstellt werden.

Es treten jedoch zwei offensichtliche Probleme auf:

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

C-String als Sammlung von Zeichen 

#include 

/* foreach macro viewing a string as a collection of char values */
#define foreach(ptrvar, strvar) 
char* ptrvar; 
for (ptrvar = strvar; (*ptrvar) != ''; *ptrvar++)

int main(int argc, char** argv) {
 char* s1 = "abcdefg";
 char* s2 = "123456789";
 foreach (p1, s1) {
  printf("loop 1: %cn", *p1);
 }
 foreach (p2, s2) {
  printf("loop 2: %cn", *p2);
 }
 return 0;
}

C int-Array als Sammlung von int (Array-Größe zur Kompilierungszeit bekannt) 

#include 

/* foreach macro viewing an array of int values as a collection of int values */
#define foreach(intpvar, intarr) 
int* intpvar; 
for (intpvar = intarr; intpvar < (intarr + (sizeof(intarr)/sizeof(intarr[0]))); ++intpvar)

int main(int argc, char** argv) {
 int a1[] = {1, 1, 2, 3, 5, 8};
 int a2[] = {3, 1, 4, 1, 5, 9};
 foreach (p1, a1) {
  printf("loop 1: %dn", *p1);
 }
 foreach (p2, a2) {
  printf("loop 2: %dn", *p2);
 }
 return 0;
}

Am allgemeinsten: Zeichenfolge oder Array als Sammlung (zur Laufzeit bekannte Sammlungsgröße)

Hinweis: idxtype kann entfernt werden und typeof(col[0]) an seiner Stelle mit GCC verwendet
#include 
#include 

/* foreach macro viewing an array of given type as a collection of values of given type */
#define arraylen(arr) (sizeof(arr)/sizeof(arr[0]))
#define foreach(idxtype, idxpvar, col, colsiz) 
idxtype* idxpvar; 
for (idxpvar = col; idxpvar < (col + colsiz); ++idxpvar)

int main(int argc, char** argv) {
 char* c1 = "collection";
 int c2[] = {3, 1, 4, 1, 5, 9};
 double* c3;
 int c3len = 4;
 c3 = (double*)calloc(c3len, sizeof(double)); 
 c3[0] = 1.2; c3[1] = 3.4; c3[2] = 5.6; c3[3] = 7.8;

 foreach (char, p1, c1, strlen(c1)) {
  printf("loop 1: %cn", *p1);
 }
 foreach (int, p2, c2, arraylen(c2)) {
  printf("loop 2: %dn", *p2);
 }
 foreach (double, p3, c3, c3len) {
  printf("loop 3: %.1lfn", *p3);
 }
 return 0;
}

C #[edit]

In C # wird angenommen, dass myArray ein Array von Ganzzahlen ist: 

foreach (int x in myArray) { Console.WriteLine(x); }

Language Integrated Query (LINQ) bietet die folgende Syntax, die einen Delegaten- oder Lambda-Ausdruck akzeptiert: 

myArray.ToList().ForEach(x => Console.WriteLine(x));

C ++[edit]

C ++ 11 bietet eine foreach-Schleife. Die Syntax ähnelt der von Java: 

#include 

int main()
{
  int myint[] = {1, 2, 3, 4, 5};

  for (int i : myint)
  {
    std::cout << i << 'n';
  }
}

C ++ 11-bereichsbasierte Anweisungen wurden in GNU Compiler Collection (GCC) (seit Version 4.6), Clang (seit Version 3.0) und Visual C ++ 2012 (Version 11) implementiert [6])

Die Reichweite basiert zum ist syntaktischer Zucker äquivalent zu: 

  for (auto __anon = begin(myint); __anon != end(myint); ++__anon)
  {
    auto i = *__anon;
    std::cout << i << 'n';
  }

Der Compiler verwendet eine argumentabhängige Suche, um das Problem zu beheben Start und Ende Funktionen.[7]

Die C ++ Standard Library unterstützt ebenfalls für jeden,[8] Dadurch wird jedes Element auf eine Funktion angewendet, bei der es sich um eine beliebige vordefinierte Funktion oder einen Lambda-Ausdruck handeln kann. Während bereichsbasiert für nur vom Anfang bis zum Ende ist, können Sie den Bereich und die Richtung ändern, indem Sie die ersten beiden Parameter ändern. 

#include 
#include  // contains std::for_each
#include 

int main()
{
  std::vector<int> v {1, 2, 3, 4, 5};

  std::for_each(v.begin(), v.end(), [&](int i)
  {
    std::cout << i << 'n';
  });

  std::cout << "reversed but skip 2 elements:n";

  std::for_each(v.rbegin()+2, v.rend(), [&](int i)
  {
    std::cout << i << 'n';
  });
}

Qt, ein C ++ – Framework, bietet ein Makro für jede Schleife[9] Verwenden der STL-Iterator-Schnittstelle: 

#include 
#include 

int main()
{
  QList<int> list;

  list << 1 << 2 << 3 << 4 << 5;

  foreach (int i, list)
  {
    qDebug() << i;
  }
}

Boost, eine Reihe von kostenlosen, von Experten geprüften tragbaren C ++ – Bibliotheken bietet außerdem jede Schleife:[10]

#include 
#include 
 
int main()
{
  int myint[] = {1, 2, 3, 4, 5};
 
  BOOST_FOREACH(int &i, myint)
  {
    std::cout << i << 'n';
  }
}

C ++ / CLI[edit]

Die C ++ / CLI-Sprache schlägt ein Konstrukt vor, das C # ähnelt.

Angenommen, myArray ist ein Array von Ganzzahlen: 

    for each (int x in myArray)
    {
        Console::WriteLine(x);
    }

ColdFusion Markup Language (CFML)[edit]

Skriptsyntax[edit]

// arrays
arrayeach([1,2,3,4,5], function(v){
    writeOutput(v);
});

// or

for (v in [1,2,3,4,5]){
    writeOutput(v);
}

// or

// (Railo only; not supported in ColdFusion)
letters = ["a","b","c","d","e"];
letters.each(function(v){
    writeOutput(v); // abcde
});

// structs
for (k in collection){
    writeOutput(collection[k]);
}

// or

structEach(collection, function(k,v){
    writeOutput("key: #k#, value: #v#;");
});

// or
// (Railo only; not supported in ColdFusion)
collection.each(function(k,v){
    writeOutput("key: #k#, value: #v#;");
});

Tag-Syntax[edit]


 index="v" array="#['a','b','c','d','e']#">
  #v#

CFML identifiziert den Wert in diesem Konstrukt fälschlicherweise als “Index”. das index Variable erhält den tatsächlichen Wert des Array-Elements, nicht seinen Index. 


 item="k" collection="#collection#">
    #collection[k]#

Common Lisp[edit]

Common Lisp bietet jede Fähigkeit entweder mit dem Dolist Makro: 

(dolist (i '(1 3 5 6 8 10 14 17))
  (print i))

oder die Mächtigen Schleife Makro zum Durchlaufen weiterer Datentypen 

(loop for i in '(1 3 5 6 8 10 14 17)
      do (print i))

und sogar mit dem mapcar Funktion: 

(mapcar #'print '(1 3 5 6 8 10 14 17))

D.[edit]

foreach(item; set) {
  // do something to item
}
or
foreach(argument) {
  // pass value
}

Pfeil[edit]

for (final element in someCollection) {
  // do something with element
}

Objekt Pascal, Delphi[edit]

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

for enumerator in collection do
begin
  //do something here
end;

Eiffel[edit]

Die Iterationsform (foreach) des Eiffel-Schleifenkonstrukts wird durch das Schlüsselwort eingeführt across.

In diesem Beispiel jedes Element der Struktur my_list wird gedruckt: 

            across my_list as ic loop print (ic.item) end

Die lokale Entität ic ist eine Instanz der Bibliotheksklasse ITERATION_CURSOR. Die Funktion des Cursors item bietet Zugriff auf jedes Strukturelement. Nachkommen der Klasse ITERATION_CURSOR kann für spezielle Iterationsalgorithmen erstellt werden. Die Objekttypen, über die iteriert werden kann (my_list im Beispiel) basieren auf Klassen, die von der Bibliotheksklasse erben ITERABLE.

Die Iterationsform der Eiffel-Schleife kann auch als boolescher Ausdruck beim Schlüsselwort verwendet werden loop wird durch entweder ersetzt all (bewirkt eine universelle Quantifizierung) oder some (existenzielle Quantifizierung bewirken).

Diese Iteration ist ein boolescher Ausdruck, der wahr ist, wenn alle Elemente in enthalten sind my_list haben mehr als drei: 

            across my_list as ic all ic.item.count > 3 end

Folgendes gilt, wenn mindestens ein Element eine Anzahl von mehr als drei aufweist: 

            across my_list as ic some ic.item.count > 3 end

Gehen[edit]

Die foreach-Schleife von Go kann verwendet werden, um ein Array, einen Slice, eine Zeichenfolge, eine Karte oder einen Kanal zu durchlaufen.

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

for index, value := range someCollection {
	// Do something to index and value
}

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

for index := range someCollection {
	// Do something to index
}

[11]

Groovy[edit]

Groovy unterstützt zum Schleifen über Sammlungen wie Arrays, Listen und Bereiche: 

def x = [1,2,3,4]
for (v in x)           // loop over the 4-element array x
{
    println v
}

for (v in [1,2,3,4])   // loop over 4-element literal list 
{
    println v
}

for (v in 1..4)        // loop over the range 1..4
{
    println v
}

Groovy unterstützt auch eine for-Schleife im C-Stil mit einem Array-Index: 

for (i = 0; i < x.size(); i++)
{
    println x[i]
}

Sammlungen in Groovy können auch mit der Option iteriert werden jeder Schlüsselwort und eine Schließung. Standardmäßig wird der Loop-Dummy benannt es 

x.each{ println it }     // print every element of the x array
x.each{i-> println i}    // equivalent to line above, only loop dummy explicitly named "i"

Haskell[edit]

Haskell ermöglicht das Durchlaufen von Listen mit monadischen Aktionen mit mapM_ und forM_ ((mapM_ mit umgedrehten Argumenten) aus Control.Monad::

Code druckt 
1
2
3
4

forM_ "test" $ char -> do 
    putChar char
    putChar char

tteesstt

Es ist auch möglich, diese Funktionen zu verallgemeinern, um auf anwendbaren Funktoren anstatt auf Monaden und jeder Datenstruktur zu arbeiten, die mit durchquert werden kann traverse ((for mit umgedrehten Argumenten) und mapM ((forM mit umgedrehten Argumenten) aus Data.Traversable.

Haxe[edit]

for (value in iterable) {
    trace(value);
}

Lambda.iter(iterable, function(value) trace(value));

Java[edit]

In Java wurde ein foreach-Konstrukt in Java Development Kit (JDK) 1.5.0 eingeführt.[12]

Offizielle Quellen verwenden mehrere Namen für das Konstrukt. Es wird als “Enhanced for Loop” bezeichnet.[12] die “For-Each-Schleife”,[13] und die “foreach-Anweisung”.[14]

for (Type item : iterableCollection) {
    // Do something to item
}

JavaScript[edit]

Der EcmaScript 6 Standard hat for..of für indexlose Iteration über Generatoren, Arrays und mehr: 

for (var item of array){
    // Do stuff
}

Alternativ funktionsbasierter Stil: [15]

array.forEach(item => {
    // Do stuff
})

Für eine ungeordnete Iteration über die Schlüssel in einem Objekt bietet JavaScript die for...in Schleife: 

for (var key in object) {
    // Do stuff with object[key]
}

Um die Iteration auf die Eigenschaften des Objekts zu beschränken, mit Ausnahme derjenigen, die über die Prototypenkette geerbt wurden, ist es manchmal nützlich, einen hasOwnProperty () -Test hinzuzufügen, sofern dies von der JavaScript-Engine unterstützt wird (für WebKit / Safari bedeutet dies “in Version 3 oder höher” “). 

for (var key in object) {
    if (object.hasOwnProperty(key)) {
        // Do stuff with object[key]
    }
}

ECMAScript 5 stellte die Object.keys-Methode bereit, um die eigenen Schlüssel eines Objekts in ein Array zu übertragen.[16]

var book = { name: "A Christmas Carol", author: "Charles Dickens" }; 
for(var key of Object.keys(book)){
    alert("PropertyName = " key + " Property Value = " + book[key]);
}

Lua[17][edit]

Iterieren Sie nur durch numerische Indexwerte:

for index, value in ipairs(array) do
	-- do something
end

Durchlaufen Sie alle Indexwerte:

for index, value in pairs(array) do
	-- do something
end

Mathematica[edit]

In Mathematica Do bewertet einfach einen Ausdruck für jedes Element einer Liste, ohne einen Wert zurückzugeben. 

In[]:= Do[doSomethingWithItem, {item, list}]

Es ist üblicher zu verwenden Table, die das Ergebnis jeder Bewertung in einer neuen Liste zurückgibt. 

In[]:= list = {3, 4, 5};

In[]:= Table[item^2, {item, list}]
Out[]= {9, 16, 25}

MATLAB[edit]

for item = array
%do something
end

Minze[edit]

Für jede Schleife werden in Mint folgende Syntax unterstützt: 

for each element of list
    /* 'Do something.' */
end

Das for (;;) oder while (true) Endlosschleife in Mint kann mit einer für jede Schleife und einer unendlich langen Liste geschrieben werden.[18]

import type
/* 'This function is mapped to'
 * 'each index number i of the'
 * 'infinitely long list.'
 */
sub identity(x)
    return x
end
/* 'The following creates the list'
 * '[0, 1, 2, 3, 4, 5, ..., infinity]'
 */
infiniteList = list(identity)
for each element of infiniteList
    /* 'Do something forever.' */
end

Ziel c[edit]

Foreach-Schleifen, die als schnelle Aufzählung bezeichnet werden, werden ab Objective-C 2.0 unterstützt. Sie können verwendet werden, um über jedes Objekt zu iterieren, das das NSFastEnumeration-Protokoll implementiert, einschließlich NSArray, NSDictionary (iteriert über Schlüssel), NSSet usw. 

NSArray *a = [NSArray new];       // Any container class can be substituted

for(id obj in a) {                // Note the dynamic typing (we do not need to know the
                                  // Type of object stored in 'a'.  In fact, there can be
                                  // many different types of object in the array.

    printf("%sn", [[obj description] UTF8String]);  // Must use UTF8String with %s
    NSLog(@"%@", obj);                               // Leave as an object
}

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

NSArray *a = [NSArray new];

[a makeObjectsPerformSelector:@selector(printDescription)];

Wenn Blöcke verfügbar sind, kann ein NSArray automatisch einen Block für jedes enthaltene Element ausführen: 

[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop)
	{
		NSLog(@"obj %@", obj);
		if ([obj shouldStopIterationNow])
			*stop = YES;
	}];

Die Art der Sammlung, die iteriert wird, bestimmt das Element, das bei jeder Iteration zurückgegeben wird. Zum Beispiel: 

NSDictionary *d = [NSDictionary new];

for(id key in d) {
    NSObject *obj = [d objectForKey:key];      // We use the (unique) key to access the (possibly nonunique) object.
    NSLog(@"%@", obj);
}

OCaml[edit]

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

Für Listen: 

List.iter (fun x -> print_int x) [1;2;3;4];;

oder kurz gesagt: 

List.iter print_int [1;2;3;4];;

Für Arrays: 

Array.iter (fun x -> print_int x) [|1;2;3;4|];;

oder kurz gesagt: 

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

ParaSail[edit]

Die parallele Programmiersprache ParaSail unterstützt verschiedene Arten von Iteratoren, einschließlich eines allgemeinen “für jeden” Iterators über einen Container: 

var Con : Container<Element_Type> := ...
// ...
for each Elem of Con concurrent loop  // loop may also be "forward" or "reverse" or unordered (the default)
  // ... do something with Elem
end loop

ParaSail unterstützt auch Filter für Iteratoren und die Möglichkeit, sowohl auf den Schlüssel als auch auf den Wert einer Karte zu verweisen. Hier ist eine Vorwärtsiteration über die Elemente von “My_Map”, wobei nur Elemente ausgewählt werden, bei denen sich die Schlüssel in “My_Set” befinden: 

var My_Map : Map<Key_Type => Univ_String, Value_Type => Tree<Integer>> := ...
const My_Set : Set<Univ_String> := ["abc", "def", "ghi"];

for each [Str => Tr] of My_Map {Str in My_Set} forward loop
   // ... do something with Str or Tr
end loop

Pascal[edit]

In Pascal führte der ISO-Standard 10206: 1990 eine Iteration über festgelegte Typen ein, also: 

var
  elt: ElementType;
  eltset: set of ElementType;

{...}

for elt in eltset do
  { ... do something with elt }

Perl[edit]

In Perl für jeden (was dem kürzeren für entspricht) kann verwendet werden, um Elemente einer Liste zu durchlaufen. Der Ausdruck, der die Sammlung angibt, über die eine Schleife durchgeführt werden soll, wird im Listenkontext ausgewertet, und jedes Element der resultierenden Liste wird wiederum auf die Schleifenvariable ausgerichtet.

Listenliteralbeispiel: 

foreach (1, 2, 3, 4) {
    print $_;
}

Array-Beispiele: 

foreach (@arr) {
    print $_;
}

foreach $x (@arr) { #$x is the element in @arr
    print $x;
}

Hash-Beispiel: 

foreach $x (keys %hash) {
    print $x . " = " . $hash{$x}; # $x is a key in %hash and $hash{$x} is its value
}

Direkte Änderung der Sammlungsmitglieder: 

@arr = ( 'remove-foo', 'remove-bar' );
foreach $x (@arr){
    $x =~ s/remove-//;
}
# Now @arr = ('foo', 'bar');

PHP[edit]

foreach ($set as $value) {
    // Do something to $value;
}

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

foreach ($set as $key => $value) {
    echo "{$key} has a value of {$value}";
}

Direkte Änderung der Sammlungsmitglieder: 

$arr = array(1, 2, 3);
foreach ($arr as &$value) { // Note the &, $value is a reference to the original value inside $arr
    $value++;
}
// Now $arr = array(2, 3, 4);

// also works with the full syntax
foreach ($arr as $key => &$value) {
    $value++;
}

Python[edit]

for item in iterable_collection:
    # Do something with item

Die Tupelzuweisung von Python, die in der foreach-Schleife vollständig verfügbar ist, macht es auch trivial, (Schlüssel-, Wert-) Paare in assoziativen Arrays zu iterieren: 

for key, value in some_dict.items():  # Direct iteration on a dict iterates on its keys
    # Do stuff

Wie for ... in ist die einzige Art von for-Schleife in Python. Das Äquivalent zur “Zähler” -Schleife in anderen Sprachen ist … 

for i in range(len(seq)):
    # Do something to seq[i]

… obwohl mit dem enumerate Funktion wird eher als “pythonisch” angesehen: 

for i, item in enumerate(seq):
    # Do stuff with item
    # Possibly assign it back to seq[i]

Schläger[edit]

(for ([item set])
  (do-something-with item))

oder unter Verwendung des herkömmlichen Schemas for-each Funktion: 

(for-each do-something-with a-list)

do-something-with ist eine Ein-Argument-Funktion.

Raku[edit]

In Raku, einer Schwestersprache von Perl, zum muss verwendet werden, um Elemente einer Liste zu durchlaufen (für jeden ist nicht erlaubt). Der Ausdruck, der die Sammlung angibt, über die eine Schleife ausgeführt werden soll, wird im Listenkontext ausgewertet, jedoch nicht standardmäßig abgeflacht, und jedes Element der resultierenden Liste wird wiederum auf die Schleifenvariablen ausgerichtet.

Listenliteralbeispiel:

Array-Beispiele:

Die for-Schleife in ihrer Anweisungsmodifikatorform: 

for @arr -> $x {
    say $x;
}

for @arr -> $x, $y {    # more than one item at a time
    say "$x, $y";
}

Hash-Beispiel: 

for keys %hash -> $key {
    say "$key: $hash{$key}";
}

oder 

for %hash.kv -> $key, $value {
    say "$key: $value";
}

oder 

for %hash -> $x {
    say "$x.key(): $x.value()";    # Parentheses needed to inline in double quoted string
}

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

my @arr = 1,2,3;
for @arr <-> $x {
    $x *= 2;
}
# Now @arr = 2,4,6;

Rubin[edit]

set.each do |item|
  # do something to item
end

oder 

for item in set
  # do something to item
end

Dies kann auch mit einem Hash verwendet werden. 

set.each do |item,value|
  # do something to item
  # do something to value
end

Rost[edit]

Das for Schleife hat die Struktur for in { /* optional statements */ }. Es ruft implizit die IntoIterator::into_iter Methode für den Ausdruck und verwendet den resultierenden Wert, der die implementieren muss Iterator Merkmal. Wenn der Ausdruck selbst ein Iterator ist, wird er direkt von der verwendet for Schleife durch eine Implementierung von IntoIterator für alle Iterators das gibt den Iterator unverändert zurück. Die Schleife ruft die Iterator::next Methode auf dem Iterator vor dem Ausführen des Schleifenkörpers. Wenn Iterator::next kehrt zurück Some(_)wird der Wert im Inneren dem Muster zugewiesen und der Schleifenkörper wird ausgeführt; wenn es zurückkommt Nonewird die Schleife beendet. 

let mut numbers = vec![1, 2, 3];

// Immutable reference:
for number in &numbers { // calls IntoIterator::into_iter(&numbers)
    println!("{}", number);
}

for square in numbers.iter().map(|x| x * x) { // numbers.iter().map(|x| x * x) implements Iterator
    println!("{}", square);
}

// Mutable reference:
for number in &mut numbers { // calls IntoIterator::into_iter(&mut numbers)
    *number *= 2;
}

// prints "[2, 4, 6]":
println!("{:?}", numbers);

// Consumes the Vec and creates an Iterator:
for number in numbers { // calls IntoIterator::into_iter(numbers)
    // ...
}

// Errors with "borrow of moved value":
// println!("{:?}", numbers);

Scala[edit]

// return list of modified elements
items map { x => doSomething(x) }
items map multiplyByTwo

for {x <- items} yield doSomething(x)
for {x <- items} yield multiplyByTwo(x)

// return nothing, just perform action
items foreach { x => doSomething(x) }
items foreach println

for {x <- items} doSomething(x)
for {x <- items} println(x)

// pattern matching example in for-comprehension
for ((key, value) <- someMap) println(s"$key -> $value")

Planen[edit]

(for-each do-something-with a-list)

do-something-with ist eine Ein-Argument-Funktion.

Smalltalk[edit]

collection do: [:item| "do something to item" ]

Schnell[edit]

Swift benutzt die for…in Konstrukt, um über Mitglieder einer Sammlung zu iterieren.[19]

for thing in someCollection {
    // do something with thing
}

Das for…in Eine Schleife wird häufig mit Konstrukten mit geschlossenem und halboffenem Bereich verwendet, um den Schleifenkörper eine bestimmte Anzahl von Malen zu durchlaufen. 

for i in 0..<10 {
    // 0..<10 constructs a half-open range, so the loop body
    // is repeated for i = 0, i = 1, …, i = 9.
}

for i in 0...10 {
    // 0...10 constructs a closed range, so the loop body
    // is repeated for i = 0, i = 1, …, i = 9, i = 10.
}

SystemVerilog[edit]

SystemVerilog unterstützt die Iteration über einen beliebigen Vektor- oder Array-Typ einer beliebigen Dimensionalität mithilfe von foreach Stichwort.

Ein einfaches Beispiel iteriert über ein Array von Ganzzahlen:

Code druckt 
int  array_1d[] = '{ 3, 2, 1, 0 };

foreach array_1d[index]
  $display("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 durchläuft ein assoziatives Array von Arrays von Ganzzahlen:

Code druckt 
int  array_2d[string][] = '{ "tens": '{ 10, 11 },
                             "twenties": '{ 20, 21 } };

foreach array_2d[key,index]
  $display("array_2d[%s,%0d]: %0d", key, index, array_2d[key,index]);

array_2d[tens,0]: 10
array_2d[tens,1]: 11
array_2d[twenties,0]: 20
array_2d[twenties,1]: 21

Tcl[edit]

Tcl verwendet foreach, um Listen zu durchlaufen. Es ist möglich, mehr als eine Iteratorvariable anzugeben. In diesem Fall werden ihnen sequentielle Werte aus der Liste zugewiesen.

Code druckt 
foreach {i j} {1 2 3 4 5 6} {
    puts "$i $j"
}

1 2
3 4
5 6

Es ist auch möglich, mehrere Listen gleichzeitig zu durchlaufen. Im Folgenden i nimmt sequentielle Werte der ersten Liste an, j sequentielle Werte der zweiten Liste:

Code druckt 
foreach i {1 2 3} j {a b c}  {
    puts "$i $j"
}

1 a
2 b
3 c

Visual Basic .NET[edit]

For Each item In enumerable
    ' Do something with item.
Next

oder ohne Typinferenz 

For Each item As type In enumerable
    ' Do something with item.
Next

Windows[edit]

Herkömmlicher Befehlsprozessor[edit]

Rufen Sie eine Hypothese auf frob Befehl dreimal und gib ihm jedes Mal einen Farbnamen. 

C:>FOR %%a IN ( red green blue ) DO frob %%a

Windows PowerShell[edit]

foreach ($item in $set) {
    # Do something to $item
}

Aus einer Pipeline 

$list | ForEach-Object {Write-Host $_}

# or using the aliases
$list | foreach {write $_}
$list | % {write $_}

Extensible Stylesheet Language (XSL)[edit]

  select="set">

[20]

Siehe auch[edit]

Verweise[edit]


after-content-x4