Foreach loop

<h2 id="syntax">Syntax</h2>
<p>Syntax varies among languages. Most use the simple word for, although other use the more logical word foreach, roughly as follows:
</p>
foreach(key, value) in collection {
  # Do something to value #
}

<h2 id="language-support">Language support</h2>
<p><a href="/facts/Programming_language/cWTYbgWa">Programming languages</a> which support foreach loops include <a href="/facts/ABC_(programming_language)/lgYVS5y4">ABC</a>, <a href="/facts/ActionScript/xtDQb0wR">ActionScript</a>, <a href="/facts/Ada_(programming_language)/Y2yHel4l">Ada</a>, <a href="/facts/C%2B%2B/Et0F2qn9">C++</a> (since <a href="/facts/C%2B%2B11/fI3YCoKQ">C++11</a>), <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>, <a href="/facts/ColdFusion_Markup_Language/AbjNUunm">ColdFusion Markup Language</a> (CFML), <a href="/facts/Cobra_(programming_language)/KoaKnA5c">Cobra</a>, <a href="/facts/D_(programming_language)/4qIzRjkF">D</a>, <a href="/facts/Daplex/w8AG5PSc">Daplex</a> (query language), <a href="/facts/Delphi_(software)/sUFUXQ8r">Delphi</a>, <a href="/facts/ECMAScript/M7nDHsB5">ECMAScript</a>, <a href="/facts/Erlang_(programming_language)/2PuxmzT3">Erlang</a>, <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a> (since 1.5), <a href="/facts/JavaScript/XhhIIEsl">JavaScript</a>, <a href="/facts/Lua_(programming_language)/xkBCgta0">Lua</a>, <a href="/facts/Objective-C/5mM557BW">Objective-C</a> (since 2.0), <a href="/facts/ParaSail_(programming_language)/DS5mhJ8d">ParaSail</a>, <a href="/facts/Perl/fx31kjlT">Perl</a>, <a href="/facts/PHP/vU6YRJX0">PHP</a>, <a href="/facts/Prolog/r5h66Qh1">Prolog</a>,<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a> <a href="/facts/Python_(programming_language)/YbuGqofa">Python</a>, <a href="/facts/R_(programming_language)/LSrkr8K8">R</a>, <a href="/facts/REALbasic/ColkhLN1">REALbasic</a>, <a href="/facts/Rebol/9ooWy78f">Rebol</a>,<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a> <a href="/facts/Red_(programming_language)/wIjLEeSI">Red</a>,<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> <a href="/facts/Ruby_(programming_language)/BeYSaPSR">Ruby</a>, <a href="/facts/Scala_(programming_language)/ebL8o6AK">Scala</a>, <a href="/facts/Smalltalk/Ru2UPVDE">Smalltalk</a>, <a href="/facts/Swift_(programming_language)/A7qHQC32">Swift</a>, <a href="/facts/Tcl/s7fbKYtR">Tcl</a>, <a href="/facts/Tcsh/ot248H7D">tcsh</a>, <a href="/facts/Unix_shell/2G4T2Fb9">Unix shells</a>, <a href="/facts/Visual_Basic_(.NET)/09mPEo4q">Visual Basic (.NET)</a>, and <a href="/facts/Windows_PowerShell/G1d10lwn">Windows PowerShell</a>. Notable languages without foreach are <a href="/facts/C_(programming_language)/Ky2No763">C</a>, and C++ pre-C++11.
</p>
<h3>ActionScript 3.0</h3>
<p><a href="/facts/ActionScript/xtDQb0wR">ActionScript</a> supports the ECMAScript 4.0 Standard<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> for for each .. in<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a> which pulls the value at each index.
</p>
var foo:Object = {
	"apple":1,
	"orange":2
};

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

// returns "1" then "2"

<p>It also supports for .. in<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a> which pulls the key at each index.
</p>
for (var key:String in foo) { 
	trace(key); 
}

// returns "apple" then "orange"

The Wikibook <i>Ada Programming</i> has a page on the topic of: <i>Control</i>

<p><a href="/facts/Ada_(programming_language)/Y2yHel4l">Ada</a> supports foreach loops as part of the normal <a href="/facts/For_loop/cwV2nRzp">for loop</a>. Say X is an <a href="/facts/Array_data_structure/BKGvF8AM">array</a>:
</p>
for I in X'Range loop
   X (I) := Get_Next_Element;
end loop;

<p>This syntax is used on mostly arrays, but will also work with other types when a full iteration is needed.
</p><p>Ada 2012 has generalized loops to foreach loops on any kind of container (array, lists, maps...):
</p>
for Obj of X loop
   -- Work on Obj
end loop;

<h3>C</h3>
<p>The <a href="/facts/C_(programming_language)/Ky2No763">C</a> language does not have collections or a foreach construct. However, it has several standard data structures that can be used as collections, and foreach can be made easily with a <a href="/facts/C_macro/KuhuxKYP">macro</a>.
</p><p>However, two obvious problems occur:
</p>
<ul><li>The macro is unhygienic: it declares a new variable in the existing scope which remains after the loop.</li>
<li>One foreach macro cannot be defined that works with different collection types (e.g., array and linked list) or that is extensible to user types.</li></ul>
<p>C string as a collection of char
</p>
#include <stdio.h>

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

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

<p>C int array as a collection of int (array size known at compile-time)
</p>
#include <stdio.h>

/* 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: %d\n", *p1);
 }
 foreach (p2, a2) {
  printf("loop 2: %d\n", *p2);
 }
 return 0;
}

<p>Most general: string or array as collection (collection size known at run-time)
</p>
<i>idxtype can be removed and <a href="/facts/Typeof/mCIKwDuQ">typeof</a>(col[0]) used in its place with <a href="/facts/GNU_Compiler_Collection/t07jh01k">GCC</a></i>
#include <stdio.h>
#include <string.h>

/* 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: %c\n", *p1);
 }
 foreach (int, p2, c2, arraylen(c2)) {
  printf("loop 2: %d\n", *p2);
 }
 foreach (double, p3, c3, c3len) {
  printf("loop 3: %.1lf\n", *p3);
 }
 return 0;
}

<h3>C#</h3>
<p>In <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a>, assuming that myArray is an array of integers:
</p>
foreach (int x in myArray) { Console.WriteLine(x); }

<p><a href="/facts/Language_Integrated_Query/qz61xeUf">Language Integrated Query</a> (LINQ) provides the following syntax, accepting a <a href="/facts/Delegate_(CLI)/xkPGllm2">delegate</a> or <a href="/facts/Lambda_(programming)/2vdyE4zL">lambda expression</a>:
</p>
myArray.ToList().ForEach(x => Console.WriteLine(x));

<h3>C++</h3>
<p><a href="/facts/C%2B%2B11/fI3YCoKQ">C++11</a> provides a foreach loop. The syntax is similar to that of Java:
</p>
#include <iostream>

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

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

<p>C++11 range-based for statements have been implemented in <a href="/facts/GNU_Compiler_Collection/t07jh01k">GNU Compiler Collection</a> (GCC) (since version 4.6), <a href="/facts/Clang/MH7cjC67">Clang</a> (since version 3.0) and <a href="/facts/Visual_C%2B%2B/RM3sbYw5">Visual C++</a> 2012 (version 11 <a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a>)
</p><p>The range-based for is <a href="/facts/Syntactic_sugar/FYkNSdTI">syntactic sugar</a> equivalent to:
</p>
  for (auto __anon = begin(myint); __anon != end(myint); ++__anon)
  {
    auto i = *__anon;
    std::cout << i << '\n';
  }

<p>The compiler uses <a href="/facts/Argument-dependent_lookup/SdqQE9DD">argument-dependent lookup</a> to resolve the begin and end functions.<a class="footnote-ref" id="fnref:9" href="#fn:9"><sup>9</sup></a>
</p><p>The <a href="/facts/C%2B%2B_Standard_Library/A5vQNSAD">C++ Standard Library</a> also supports for_each,<a class="footnote-ref" id="fnref:10" href="#fn:10"><sup>10</sup></a> that applies each element to a function, which can be any predefined function or a lambda expression. While range-based for is only from the start to the end, the range or direction can be changed by altering the first two parameters.
</p>
#include <iostream>
#include <algorithm> // contains std::for_each
#include <vector>

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';
  });
}

<p><a href="/facts/Qt_(software)/gVhwlQnJ">Qt</a>, a C++ framework, offers a macro providing foreach loops<a class="footnote-ref" id="fnref:11" href="#fn:11"><sup>11</sup></a> using the STL iterator interface:
</p>
#include <QList>
#include <QDebug>

int main()
{
  QList<int> list;

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

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

<p><a href="/facts/Boost_(C%2B%2B_libraries)/vGLGG51A">Boost</a>, a set of free peer-reviewed portable C++ libraries also provides foreach loops:<a class="footnote-ref" id="fnref:12" href="#fn:12"><sup>12</sup></a>
</p>
#include <boost/foreach.hpp>
#include <iostream>
 
int main()
{
  int myint[] = {1, 2, 3, 4, 5};
 
  BOOST_FOREACH(int &i, myint)
  {
    std::cout << i << '\n';
  }
}

<h3>C++/CLI</h3>
<p>The <a href="/facts/C%2B%2B/CLI/3HtoUSrY">C++/CLI</a> language proposes a construct similar to C#.
</p><p>Assuming that myArray is an array of integers:
</p>
for each (int x in myArray)
{
    Console::WriteLine(x);
}

<h3>ColdFusion Markup Language (CFML)</h3>
<p class="note">Main article: <a href="/facts/ColdFusion_Markup_Language/AbjNUunm">ColdFusion Markup Language</a></p>
<h4>Script syntax</h4>
// 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#;");
});

<h4>Tag syntax</h4>

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

<p>CFML incorrectly identifies the value as "index" in this construct; the index variable does receive the actual value of the array element, not its index.
</p>

<cfloop item="k" collection="#collection#">
    <cfoutput>#collection[k]#</cfoutput>
</cfloop>

<h3>Common Lisp</h3>
<p><a href="/facts/Common_Lisp/mq1pRbSF">Common Lisp</a> provides foreach ability either with the <i>dolist</i> macro:
</p>
(dolist (i '(1 3 5 6 8 10 14 17))
  (print i))

<p>or the powerful <i>loop</i> macro to iterate on more data types
</p>
(loop for i in '(1 3 5 6 8 10 14 17)
      do (print i))

<p>and even with the <i>mapcar</i> function:
</p>
(mapcar #'print '(1 3 5 6 8 10 14 17))

<h3>D</h3>
<p class="note">Main article: <a href="/facts/D_(programming_language)/4qIzRjkF">D (programming language)</a></p>
foreach(item; set) {
  // do something to item
}

<p>or
</p>
foreach(argument) {
  // pass value
}

<h3>Dart</h3>
<p class="note">Main article: <a href="/facts/Dart_(programming_language)/xJ8tE6Tl">Dart (programming language)</a></p>
for (final element in someCollection) {
  // do something with element
}

<h3>Object Pascal, Delphi</h3>
<p class="note">Main articles: <a href="/facts/Object_Pascal/cuGkuISv">Object Pascal</a> and <a href="/facts/Delphi_(software)/sUFUXQ8r">Delphi (software)</a></p>
<p>Foreach support was added in <a href="/facts/Delphi_(software)/sUFUXQ8r">Delphi</a> 2005, and uses an enumerator variable that must be declared in the <i>var</i> section.
</p>
for enumerator in collection do
begin
  //do something here
end;

<h3>Eiffel</h3>
<p>The iteration (foreach) form of the <a href="/facts/Eiffel_(programming_language)/gEzPjzmn">Eiffel</a> loop construct is introduced by the keyword across.
</p><p>In this example, every element of the structure my_list is printed:
</p>
            across my_list as ic loop print (ic.item) end

<p>The local entity ic is an instance of the library class ITERATION_CURSOR. The cursor's feature item provides access to each structure element. Descendants of class ITERATION_CURSOR can be created to handle specialized iteration algorithms. The types of objects that can be iterated across (my_list in the example) are based on classes that inherit from the library class ITERABLE.
</p><p>The iteration form of the Eiffel loop can also be used as a boolean expression when the keyword loop is replaced by either all (effecting <a href="/facts/Universal_quantification/agNmvJKN">universal quantification</a>) or some (effecting <a href="/facts/Existential_quantification/hHveaBYo">existential quantification</a>).
</p><p>This iteration is a boolean expression which is true if all items in my_list have counts greater than three:
</p>
            across my_list as ic all ic.item.count > 3 end

<p>The following is true if at least one item has a count greater than three:
</p>
            across my_list as ic some ic.item.count > 3 end

<h3>Go</h3>
<p><a href="/facts/Go_(programming_language)/oWlsmAFJ">Go</a>'s foreach loop can be used to loop over an array, slice, string, map, or channel.
</p><p>Using the two-value form gets the index/key (first element) and the value (second element):
</p>
for index, value := range someCollection {
	// Do something to index and value
}

<p>Using the one-value form gets the index/key (first element):
</p>
for index := range someCollection {
	// Do something to index
}
<p><a class="footnote-ref" id="fnref:13" href="#fn:13"><sup>13</sup></a>
</p><h3>Groovy</h3>
<p><a href="/facts/Groovy_(programming_language)/vGAckbte">Groovy</a> supports <i>for</i> loops over collections like arrays, lists and ranges:
</p>
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
}

<p>Groovy also supports a C-style for loop with an array index:
</p>
for (i = 0; i < x.size(); i++)
{
    println x[i]
}

<p>Collections in Groovy can also be iterated over using the <i>each</i> keyword
and a closure. By default, the loop dummy is named <i>it</i>
</p>
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"

<h3>Haskell</h3>
<p><a href="/facts/Haskell/ydEsHuGy">Haskell</a> allows looping over lists with <a href="/facts/Monad_(functional_programming)/kYazRoF1">monadic</a> actions using mapM_ and forM_ (mapM_ with its arguments flipped) from <a href="http://hackage.haskell.org/package/base-4.6.0.1/docs/Control-Monad.html">Control.Monad</a>:
</p>
<table><tbody><tr><th>code</th><th>prints</th></tr><tr><td>mapM_ print [1..4]</td><td>1234</td></tr><tr><td>forM_ "test" $ \char -> do     putChar char    putChar char</td><td>tteesstt</td></tr></tbody></table>
<p>It's also possible to generalize those functions to work on applicative functors rather than monads and any data structure that is traversable using traverse (for with its arguments flipped) and mapM (forM with its arguments flipped) from <a href="http://hackage.haskell.org/package/base-4.6.0.1/docs/Data-Traversable.html">Data.Traversable</a>.
</p>
<h3>Haxe</h3>
<p class="note">Main article: <a href="/facts/Haxe/jp87sM7P">Haxe</a></p>
for (value in iterable) {
    trace(value);
}

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

<h3>Java</h3>
<p>In <a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a>, a foreach-construct was introduced in <a href="/facts/Java_Development_Kit/qL5cDos6">Java Development Kit</a> (JDK) 1.5.0.<a class="footnote-ref" id="fnref:14" href="#fn:14"><sup>14</sup></a>
</p><p>Official sources use several names for the construct. It is referred to as the "Enhanced for Loop",<a class="footnote-ref" id="fnref:15" href="#fn:15"><sup>15</sup></a> the "For-Each Loop",<a class="footnote-ref" id="fnref:16" href="#fn:16"><sup>16</sup></a> and the "foreach statement".<a class="footnote-ref" id="fnref:17" href="#fn:17"><sup>17</sup></a><a class="footnote-ref" id="fnref:18" href="#fn:18"><sup>18</sup></a>: 264 
</p>
for (Type item : iterableCollection) {
    // Do something to item
}

<p>Java also provides the stream api since java 8:<a class="footnote-ref" id="fnref:19" href="#fn:19"><sup>19</sup></a>: 294–203 
</p>
   List<Integer> intList = List.of(1, 2, 3, 4);
   intList.stream().forEach(i -> System.out.println(i));

<h3>JavaScript</h3><p>
In <a href="/facts/ECMAScript_5/M7nDHsB5">ECMAScript 5</a>, a callback-based forEach() method was added to the array <a href="/facts/Prototype-based_programming/x9oNIYPG">prototype</a>:<a class="footnote-ref" id="fnref:20" href="#fn:20"><sup>20</sup></a></p>myArray.forEach(function (item, index) {
    // Do stuff with item and index 
    // The index variable can be omitted from the parameter list if not needed
});
<p>The <a href="/facts/ECMAScript_6/M7nDHsB5">ECMAScript 6</a> standard introduced a more conventional <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for...of">for..of</a> syntax that works on all <a href="/facts/Iterator/f0HhTBWz">iterables</a> rather than operating on only array instances. However, no index variable is available with the syntax.
</p>for (const item of myArray) {
    // Do stuff with item
}

<p>For unordered iteration over the keys in an object, <a href="/facts/JavaScript/XhhIIEsl">JavaScript</a> features the for..in loop:
</p>
for (const key in myObject) {
    // Do stuff with myObject[key]
}

<p>To limit the iteration to the object's own properties, excluding those inherited through the prototype chain, it's often useful to add a hasOwnProperty() test (or a hasOwn() test if supported).<a class="footnote-ref" id="fnref:21" href="#fn:21"><sup>21</sup></a>
</p>
for (const key in myObject) {
    // Available in older browsers
    if (myObject.hasOwnProperty(key)) {
        // Do stuff with object[key]
    }
    // Preferred in modern browsers
    if (Object.hasOwn(myObject, key)) {
        // Do stuff with object[key]
    }
}

<p>Alternatively, the Object.keys() method combined with the for..of loop can be used for a less verbose way to iterate over the keys of an object.<a class="footnote-ref" id="fnref:22" href="#fn:22"><sup>22</sup></a>
</p>
const book = { 
    name: "A Christmas Carol", 
    author: "Charles Dickens" 
}; 
for (const key of Object.keys(book)) {
    console.log(`Key: ${key}, Value: ${book[key]}`);
}

<h3>Lua</h3>
<p class="note">Main article: <a href="/facts/Lua_(programming_language)/xkBCgta0">Lua (programming language)</a></p>
<p>Source:<a class="footnote-ref" id="fnref:23" href="#fn:23"><sup>23</sup></a>
</p><p>
Iterate only through numerical index values:</p>for index, value in ipairs(array) do
	-- do something
end
<p>Iterate through all index values:</p>for index, value in pairs(array) do
	-- do something
end

<h3>Mathematica</h3>
<p>In <a href="/facts/Mathematica/dRwoGFG2">Mathematica</a>, Do will simply evaluate an expression for each element of a list, without returning any value.
</p>
In[]:= Do[doSomethingWithItem, {item, list}]

<p>It is more common to use Table, which returns the result of each evaluation in a new list.
</p>
In[]:= list = {3, 4, 5};

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

<h3>MATLAB</h3>
<p class="note">Main article: <a href="/facts/MATLAB/qPjLISCk">MATLAB</a></p>
for item = array
%do something
end

<h3>Mint</h3>
<p>For each loops are supported in Mint, possessing the following syntax:
</p>
for each element of list
    /* 'Do something.' */
end

<p>The for (;;) or while (true) <a href="/facts/Infinite_loop/NG4b7SFa">infinite loop</a>
in Mint can be written using a for each loop and an <a href="/facts/Infinite_set/9rTN0xGH">infinitely long list</a>.<a class="footnote-ref" id="fnref:24" href="#fn:24"><sup>24</sup></a>
</p>
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

<h3>Objective-C</h3>
<p>Foreach loops, called <a href="/facts/Objective-C/5mM557BW">Fast enumeration</a>, are supported starting in <a href="/facts/Objective-C/5mM557BW">Objective-C</a> 2.0. They can be used to iterate over any object that implements the NSFastEnumeration protocol, including NSArray, NSDictionary (iterates over keys), NSSet, etc.
</p>
NSArray *a = [NSArray new];       // Any container class can be substituted

for(id obj in a) {                // Dynamic typing is used. The type of object stored
                                  // in 'a' can be unknown. The array can hold many different 
                                  // types of object.

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

<p>NSArrays can also broadcast a message to their members:
</p>
NSArray *a = [NSArray new];

[a makeObjectsPerformSelector:@selector(printDescription)];

<p>Where <a href="/facts/Blocks_(C_language_extension)/gD2cN9X4">blocks</a> are available, an NSArray can automatically perform a block on every contained item:
</p>
[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop)
	{
		NSLog(@"obj %@", obj);
		if ([obj shouldStopIterationNow])
			*stop = YES;
	}];

<p>The type of collection being iterated will dictate the item returned with each iteration.
For example:
</p>
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);
}

<h3>OCaml</h3>
<p><a href="/facts/OCaml/ThBGLND8">OCaml</a> is a <a href="/facts/Functional_programming/cdxqPEIM">functional programming</a> language. Thus, the equivalent of a foreach loop can be achieved as a library function over lists and arrays.
</p><p>For lists:
</p>
List.iter (fun x -> print_int x) [1;2;3;4];;

<p>or in short way:
</p>
List.iter print_int [1;2;3;4];;

<p>For arrays:
</p>
Array.iter (fun x -> print_int x) [|1;2;3;4|];;

<p>or in short way:
</p>
Array.iter print_int [|1;2;3;4|];;

<h3>ParaSail</h3>
<p>The <a href="/facts/ParaSail_(programming_language)/DS5mhJ8d">ParaSail</a> parallel programming language supports several kinds of iterators, including a general "for each" iterator over a container:
</p>
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

<p>ParaSail also supports filters on iterators, and the ability to refer to both the key and the value of a map. Here is a forward iteration over the elements of "My_Map" selecting only elements where the keys are in "My_Set":
</p>
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

<h3>Pascal</h3>
<p>In <a href="/facts/Pascal_(programming_language)/b3yvp8bF">Pascal</a>, ISO standard 10206:1990 introduced iteration over <a href="/facts/Pascal_(programming_language)/b3yvp8bF">set types</a>, thus:
</p>
var
  elt: ElementType;
  eltset: set of ElementType;

{...}

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

<h3>Perl</h3>
<p>In <a href="/facts/Perl/fx31kjlT">Perl</a>, <i>foreach</i> (which is equivalent to the shorter for) can be used to traverse elements of a list.  The expression which denotes the collection to loop over is evaluated in list-context and each item of the resulting list is, in turn, aliased to the loop variable.
</p><p>List literal example:
</p>
foreach (1, 2, 3, 4) {
    print $_;
}

<p>Array examples:
</p>
foreach (@arr) {
    print $_;
}

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

<p>Hash example:
</p>
foreach $x (keys %hash) {
    print $x . " = " . $hash{$x}; # $x is a key in %hash and $hash{$x} is its value
}

<p>Direct modification of collection members:
</p>
@arr = ( 'remove-foo', 'remove-bar' );
foreach $x (@arr){
    $x =~ s/remove-//;
}
# Now @arr = ('foo', 'bar');

<h3>PHP</h3>
<p class="note">Main article: <a href="/facts/PHP_syntax_and_semantics/KBbGt8pr">PHP syntax and semantics</a></p>
foreach ($set as $value) {
    // Do something to $value;
}

<p>It is also possible to extract both keys and values using the alternate syntax:
</p>
foreach ($set as $key => $value) {
    echo "{$key} has a value of {$value}";
}

<p>Direct modification of collection members:
</p>
$arr = array(1, 2, 3);
foreach ($arr as &$value) { // 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++;
}

<ul><li><a href="https://php.net/foreach">More information</a></li></ul>
<h3>Python</h3>
<p class="note">Main article: <a href="/facts/Python_(programming_language)/YbuGqofa">Python (programming language)</a></p>
for item in iterable_collection:
    # Do something with item

<p>Python's tuple assignment, fully available in its foreach loop, also makes it trivial to iterate on (key, value) pairs in <a href="/facts/Associative_array/IFGd2xcP">dictionaries</a>:
</p>
for key, value in some_dict.items():  # Direct iteration on a dict iterates on its keys
    # Do stuff

<p>As for ... in is the only kind of for loop in Python, the equivalent to the "counter" loop found in other languages is...
</p>
for i in range(len(seq)):
    # Do something to seq[i]

<p>... although using the enumerate function is considered more "Pythonic":
</p>
for i, item in enumerate(seq):
    # Do stuff with item
    # Possibly assign it back to seq[i]

<h3>R</h3>
<p class="note">Main article: <a href="/facts/R_(programming_language)/LSrkr8K8">R (programming language)</a></p>
for (item in object) {
    # Do something with item
}

<p>As for ... in is the only kind of for loop in R, the equivalent to the "counter" loop found in other languages is...
</p>
for (i in seq_along(object)) {
    # Do something with object[[i]]
}

<h3>Racket</h3>
<p class="note">Main article: <a href="/facts/Racket_(programming_language)/5n7LW08b">Racket (programming language)</a></p>
(for ([item set])
  (do-something-with item))

<p>or using the conventional Scheme for-each function:
</p>
(for-each do-something-with a-list)

<p>do-something-with is a one-argument function.
</p>
<h3>Raku</h3>
<p>In <a href="/facts/Raku_(programming_language)/9eYW7vRJ">Raku</a>, a sister language to Perl, <i>for</i> must be used to traverse elements of a list (<i>foreach</i> is not allowed). The expression which denotes the collection to loop over is evaluated in list-context, but not flattened by default, and each item of the resulting list is, in turn, aliased to the loop variable(s).
</p><p>List literal example:
</p>
for 1..4 {
    .say;
}

<p>Array examples:
</p>
for @arr {
    .say;
}

<p>The for loop in its statement modifier form:
</p>
.say for @arr;

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

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

<p>Hash example:
</p>
for keys %hash -> $key {
    say "$key: $hash{$key}";
}

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

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

<p>
Direct modification of collection members with a doubly pointy block, <i><-></i>: 
</p>
my @arr = 1,2,3;
for @arr <-> $x {
    $x *= 2;
}
# Now @arr = 2,4,6;

<h3>Ruby</h3>
<p class="note">Main article: <a href="/facts/Ruby_(programming_language)/BeYSaPSR">Ruby (programming language)</a></p>
set.each do |item|
  # do something to item
end

<p>or
</p>
for item in set
  # do something to item
end

<p>This can also be used with a hash.
</p>
set.each do |key,value|
  # do something to key
  # do something to value
end

<h3>Rust</h3>
<p class="note">Main article: <a href="/facts/Rust_(programming_language)/8JNMV19F">Rust (programming language)</a></p>
<p>The for loop has the structure for <pattern> in <expression> { /* optional statements */ }. It implicitly calls the <a href="https://doc.rust-lang.org/std/iter/trait.IntoIterator.html">IntoIterator::into_iter</a> method on the expression, and uses the resulting value, which must implement the <a href="https://doc.rust-lang.org/std/iter/trait.Iterator.html">Iterator</a> trait. If the expression is itself an iterator, it is used directly by the for loop through an <a href="https://doc.rust-lang.org/std/iter/trait.IntoIterator.html#impl-IntoIterator-25">implementation of IntoIterator for all Iterators</a> that returns the iterator unchanged. The loop calls the Iterator::next method on the iterator before executing the loop body. If Iterator::next returns <a href="/facts/Option_type/B0QX5wGB">Some(_)</a>, the value inside is assigned to the <a href="/facts/Pattern_matching/CEwptMs9">pattern</a> and the loop body is executed; if it returns None, the loop is terminated.
</p>
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);

<h3>Scala</h3>
<p class="note">Main article: <a href="/facts/Scala_(programming_language)/ebL8o6AK">Scala (programming language)</a></p>
// 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")

<h3>Scheme</h3>
<p class="note">Main article: <a href="/facts/Scheme_(programming_language)/0aGdf3SC">Scheme (programming language)</a></p>
(for-each do-something-with a-list)

<p>do-something-with is a one-argument function.
</p>
<h3>Smalltalk</h3>
<p class="note">Main article: <a href="/facts/Smalltalk/Ru2UPVDE">Smalltalk</a></p>
collection do: [:item| "do something to item" ]

<h3>Swift</h3>
<p><a href="/facts/Swift_(programming_language)/A7qHQC32">Swift</a> uses the for…in construct to iterate over members of a collection.<a class="footnote-ref" id="fnref:25" href="#fn:25"><sup>25</sup></a>
</p>
for thing in someCollection {
    // do something with thing
}

<p>The for…in loop is often used with the closed and half-open range constructs to iterate over the loop body a certain number of times.
</p>
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.
}

<h3>SystemVerilog</h3>
<p><a href="/facts/SystemVerilog/wkBdc179">SystemVerilog</a> supports iteration over any vector or array type of any dimensionality using the foreach keyword.
</p><p>A trivial example iterates over an array of integers:
</p>
<table><tbody><tr><th>code</th><th>prints</th></tr><tr><td>int  array_1d[] = '{ 3, 2, 1, 0 };foreach array_1d[index]  $display("array_1d[%0d]: %0d", index, array_1d[index]);</td><td>array_1d[0]: 3array_1d[1]: 2array_1d[2]: 1array_1d[3]: 0</td></tr></tbody></table>
<p>A more complex example iterates over an associative array of arrays of integers:
</p>
<table><tbody><tr><th>code</th><th>prints</th></tr><tr><td>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]);</td><td>array_2d[tens,0]: 10array_2d[tens,1]: 11array_2d[twenties,0]: 20array_2d[twenties,1]: 21</td></tr></tbody></table>
<h3>Tcl</h3>
<p><a href="/facts/Tcl/s7fbKYtR">Tcl</a> uses foreach to iterate over lists. It is possible to specify more than one iterator variable, in which case they are assigned sequential values from the list. 
</p>
<table><tbody><tr><th>code</th><th>prints</th></tr><tr><td>foreach {i j} {1 2 3 4 5 6} {    puts "$i $j"}</td><td>1 23 45 6</td></tr></tbody></table>
<p>It is also possible to iterate over more than one list simultaneously. In the following i assumes sequential values of the first list, j sequential values of the second list:
</p>
<table><tbody><tr><th>code</th><th>prints</th></tr><tr><td>foreach i {1 2 3} j {a b c}  {    puts "$i $j"}</td><td>1 a2 b3 c</td></tr></tbody></table>
<h3>Visual Basic (.NET)</h3>
<p class="note">Main article: <a href="/facts/Visual_Basic_(.NET)/09mPEo4q">Visual Basic (.NET)</a></p>
For Each item In enumerable
    ' Do something with item.
Next

<p>or without <a href="/facts/Type_inference/vX9K8Qhf">type inference</a>
</p>
For Each item As type In enumerable
    ' Do something with item.
Next

<h3>Windows</h3>
<h4>Conventional command processor</h4>
<p class="note">Main articles: <a href="/facts/COMMAND.COM/06Sz5wle">COMMAND.COM</a> and <a href="/facts/Cmd.exe/FUmTvew6">cmd.exe</a></p>
<p>Invoke a hypothetical frob command three times, giving it a color name each time.
</p>
C:\>FOR %%a IN ( red green blue ) DO frob %%a

<h4>Windows PowerShell</h4>
<p class="note">Main article: <a href="/facts/Windows_PowerShell/G1d10lwn">Windows PowerShell</a></p>
foreach ($item in $set) {
    # Do something to $item
}

<p>From a pipeline
</p>
$list | ForEach-Object {Write-Host $_}

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

<h3>XSLT</h3>
<p class="note">Main article: <a href="/facts/XSLT/0gw4WVyJ">XSLT</a></p>
 <xsl:for-each select="set">
   
 </xsl:for-each>
<p><a class="footnote-ref" id="fnref:26" href="#fn:26"><sup>26</sup></a>
</p><h2 id="see-also">See also</h2>
<ul><li><a href="/facts/Do_while_loop/5v1RKByr">Do while loop</a></li>
<li><a href="/facts/For_loop/cwV2nRzp">For loop</a></li>
<li><a href="/facts/While_loop/hLrKdAFo">While loop</a></li>
<li><a href="/facts/Map_(higher-order_function)/GdzN4UJl">Map (higher-order function)</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>"D Programming Language foreach Statement Documentation". Digital Mars. Retrieved 2008-08-04. <a href="http://www.digitalmars.com/d/statement.html#ForeachStatement" target="_blank">http://www.digitalmars.com/d/statement.html#ForeachStatement</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"SWI-Prolog – foreach/2". Swi-prolog.org. Retrieved 2020-02-10. <a href="https://www.swi-prolog.org/pldoc/man?predicate=foreach/2" target="_blank">https://www.swi-prolog.org/pldoc/man?predicate=foreach/2</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"Rebol". <a href="http://www.rebol.com/" target="_blank">http://www.rebol.com/</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"Red Programming Language". <a href="https://www.red-lang.org/" target="_blank">https://www.red-lang.org/</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>"Proposed ECMAScript 4th Edition – Language Overview" (PDF). Retrieved 2020-02-21. <a href="https://www.ecma-international.org/activities/Languages/Language%20overview.pdf" target="_blank">https://www.ecma-international.org/activities/Languages/Language%20overview.pdf</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>"for each..in". Retrieved 2020-02-21. <a href="https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/statements.html#for_each..in" target="_blank">https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/statements.html#for_each..in</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>"for..in". Retrieved 2020-02-21. <a href="https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/statements.html#for..in" target="_blank">https://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/statements.html#for..in</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>"C++11 Features in Visual C++ 11 - Visual C++ Team Blog - Site Home - MSDN Blogs". Blogs.msdn.com. 2011-09-12. Retrieved 2013-08-04. <a href="http://blogs.msdn.com/b/vcblog/archive/2011/09/12/10209291.aspx" target="_blank">http://blogs.msdn.com/b/vcblog/archive/2011/09/12/10209291.aspx</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
<li id="fn:9"><p>"Range-based for loop (since C++11)". en.cppreference.com. Retrieved 2018-12-03. <a href="https://en.cppreference.com/w/cpp/language/range-for" target="_blank">https://en.cppreference.com/w/cpp/language/range-for</a> <a href="#fnref:9" class="footnote-back-ref">↩</a></p></li>
<li id="fn:10"><p>"std::for_each - cppreference". en.cppreference.com. Retrieved 2017-09-30. <a href="http://en.cppreference.com/w/cpp/algorithm/for_each" target="_blank">http://en.cppreference.com/w/cpp/algorithm/for_each</a> <a href="#fnref:10" class="footnote-back-ref">↩</a></p></li>
<li id="fn:11"><p>"Qt 4.2: Generic Containers". Doc.qt.digia.com. Archived from the original on 2015-11-23. Retrieved 2013-08-04. <a href="https://web.archive.org/web/20151123090839/http://doc.qt.digia.com/4.2/containers.html#the-foreach-keyword" target="_blank">https://web.archive.org/web/20151123090839/http://doc.qt.digia.com/4.2/containers.html#the-foreach-keyword</a> <a href="#fnref:11" class="footnote-back-ref">↩</a></p></li>
<li id="fn:12"><p>Eric Niebler (2013-01-31). "Chapter 9. Boost.Foreach - 1.53.0". Boost.org. Retrieved 2013-08-04. <a href="http://www.boost.org/doc/libs/1_53_0/doc/html/foreach.html" target="_blank">http://www.boost.org/doc/libs/1_53_0/doc/html/foreach.html</a> <a href="#fnref:12" class="footnote-back-ref">↩</a></p></li>
<li id="fn:13"><p>"Range Clause". The Go Programming Language Specification. The Go Programming Language. Retrieved October 20, 2013. <a href="https://golang.org/ref/spec#RangeClause" target="_blank">https://golang.org/ref/spec#RangeClause</a> <a href="#fnref:13" class="footnote-back-ref">↩</a></p></li>
<li id="fn:14"><p>"Enhanced for Loop - This new language construct[...]"
"Java Programming Language, Section: Enhancements in JDK 5". Sun Microsystems, Inc. 2004. Retrieved 2009-05-26. <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/index.html" target="_blank">http://java.sun.com/j2se/1.5.0/docs/guide/language/index.html</a> <a href="#fnref:14" class="footnote-back-ref">↩</a></p></li>
<li id="fn:15"><p>"Enhanced for Loop - This new language construct[...]"
"Java Programming Language, Section: Enhancements in JDK 5". Sun Microsystems, Inc. 2004. Retrieved 2009-05-26. <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/index.html" target="_blank">http://java.sun.com/j2se/1.5.0/docs/guide/language/index.html</a> <a href="#fnref:15" class="footnote-back-ref">↩</a></p></li>
<li id="fn:16"><p>"The For-Each Loop"
"The For-Each Loop". Sun Microsystems, Inc. 2008. Retrieved 2009-05-10. <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/foreach.html" target="_blank">http://java.sun.com/j2se/1.5.0/docs/guide/language/foreach.html</a> <a href="#fnref:16" class="footnote-back-ref">↩</a></p></li>
<li id="fn:17"><p>"Implementing this interface allows an object to be the target of the "foreach" statement."
"Iterable (Java Platform SE 6)". Sun Microsystems, Inc. 2004. Retrieved 2009-05-12. <a href="http://java.sun.com/javase/6/docs/api/java/lang/Iterable.html" target="_blank">http://java.sun.com/javase/6/docs/api/java/lang/Iterable.html</a> <a href="#fnref:17" class="footnote-back-ref">↩</a></p></li>
<li id="fn:18"><p>Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991. <a href="978-0134685991" target="_blank">978-0134685991</a> <a href="#fnref:18" class="footnote-back-ref">↩</a></p></li>
<li id="fn:19"><p>Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991. <a href="978-0134685991" target="_blank">978-0134685991</a> <a href="#fnref:19" class="footnote-back-ref">↩</a></p></li>
<li id="fn:20"><p>"Array.prototype.forEach() - JavaScript | MDN". developer.mozilla.org. 2024-07-25. Retrieved 2024-12-03. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach" target="_blank">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach</a> <a href="#fnref:20" class="footnote-back-ref">↩</a></p></li>
<li id="fn:21"><p>"Object.hasOwn() - JavaScript | MDN". developer.mozilla.org. 2023-09-25. Retrieved 2024-12-03. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn#description" target="_blank">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn#description</a> <a href="#fnref:21" class="footnote-back-ref">↩</a></p></li>
<li id="fn:22"><p>"Object.keys". Mozilla Developer Network. Retrieved May 7, 2014. <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys" target="_blank">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys</a> <a href="#fnref:22" class="footnote-back-ref">↩</a></p></li>
<li id="fn:23"><p>"Lua Programming/Tables - Wikibooks, open books for an open world". en.wikibooks.org. Retrieved 2017-12-06. <a href="https://en.wikibooks.org/wiki/Lua_Programming/Tables#Foreach_loop" target="_blank">https://en.wikibooks.org/wiki/Lua_Programming/Tables#Foreach_loop</a> <a href="#fnref:23" class="footnote-back-ref">↩</a></p></li>
<li id="fn:24"><p>Chu, Oliver. "Mint Tutorial". Retrieved 20 October 2013. <a href="http://prezi.com/ougvv1wzx2lb/mint-tutorial-part-0/" target="_blank">http://prezi.com/ougvv1wzx2lb/mint-tutorial-part-0/</a> <a href="#fnref:24" class="footnote-back-ref">↩</a></p></li>
<li id="fn:25"><p>"Control Flow — the Swift Programming Language (Swift 5.5)". <a href="https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/ControlFlow.html#//apple_ref/doc/uid/TP40014097-CH9-XID_153" target="_blank">https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/ControlFlow.html#//apple_ref/doc/uid/TP40014097-CH9-XID_153</a> <a href="#fnref:25" class="footnote-back-ref">↩</a></p></li>
<li id="fn:26"><p>"XSLT <xsl:for-each> Element". W3Schools.com. <a href="https://www.w3schools.com/xsl/xsl_for_each.asp" target="_blank">https://www.w3schools.com/xsl/xsl_for_each.asp</a> <a href="#fnref:26" class="footnote-back-ref">↩</a></p></li>
</ol>

Foreach loop open-in-new

Foreach loop