Foreach loop

In computer programming, foreach loop (or for each loop) is a control flow statement for traversing items in a collection. is usually used in place of a standard loop statement. Unlike other loop constructs, however, loops usually maintain no explicit counter: they essentially say "do this to everything in this set", rather than "do this times". This avoids potential off-by-one errors and makes code simpler to read. In object-oriented languages, an iterator, even if implicit, is often used as the means of traversal.

The statement in some languages has some defined order, processing each item in the collection from the first to the last.
The statement in many other languages, especially array programming languages, does not have any particular order. This simplifies loop optimization in general and in particular allows vector processing of items in the collection concurrently.

Syntax

Syntax varies among languages. Most use the simple word for, roughly as follows:

for each item in collection:
do something to item

Language support

Programming languages which support foreach loops include ABC, ActionScript, Ada, C++11, C#, ColdFusion Markup Language (CFML), Cobra, D, Daplex (query language), Delphi, ECMAScript, Erlang, Java (since 1.5), JavaScript, Lua, Objective-C (since 2.0), ParaSail, Perl, PHP, Prolog, Python, R, REALbasic, Rebol, Red, Ruby, Scala, Smalltalk, Swift, Tcl, tcsh, Unix shells, Visual Basic .NET, and Windows PowerShell. Notable languages without foreach are C, and C++ pre-C++11.

ActionScript 3.0

ActionScript supports the ECMAScript 4.0 Standard for for each .. in which pulls the value at each index.

var foo:Object = ;

for each (var value:int in foo)

// returns "1" then "2"

It also supports for .. in which pulls the key at each index.

for (var key:String in foo)

// returns "apple" then "orange"

Ada

Ada supports foreach loops as part of the normal for loop. Say X is an array:

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

This syntax is used on mostly arrays, but will also work with other types when a full iteration is needed.

Ada 2012 has generalized loops to foreach loops on any kind of container (array, lists, maps...):

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

C

The C 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 macro.

However, two obvious problems occur:
* The macro is unhygienic: it declares a new variable in the existing scope which remains after the loop.
* 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.

C string as a collection of char

#include

/* 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)

C int array as a collection of int (array size known at compile-time)

#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 )); ++intpvar)

int main(int argc, char** argv)

Most general: string or array as collection (collection size known at run-time)
: ''Note: can be removed and typeof(col used in its place with GCC''

#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 )
#define foreach(idxtype, idxpvar, col, colsiz) \
idxtype* idxpvar; \
for (idxpvar = col; idxpvar < (col + colsiz); ++idxpvar)

int main(int argc, char** argv)

C#

In C#, assuming that myArray is an array of integers:

foreach (int x in myArray)

Language Integrated Query (LINQ) provides the following syntax, accepting a delegate or lambda expression:

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

C++

C++11 provides a foreach loop. The syntax is similar to that of Java:

#include

int main()

C++11 range-based for statements have been implemented in GNU Compiler Collection (GCC) (since version 4.6), Clang (since version 3.0) and Visual C++ 2012 (version 11 )

The range-based for is syntactic sugar equivalent to:

for (auto __anon = begin(myint); __anon != end(myint); ++__anon)

The compiler uses argument-dependent lookup to resolve the begin and end functions.

The C++ Standard Library also supports for_each, 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 beginning to the end, the range and direction you can change the direction or range by altering the first two parameters.

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

int main()

Qt, a C++ framework, offers a macro providing foreach loops using the STL iterator interface:

#include
#include

int main()

Boost, a set of free peer-reviewed portable C++ libraries also provides foreach loops:

#include
#include

int main()

C++/CLI

The C++/CLI language proposes a construct similar to C#.

Assuming that myArray is an array of integers:

for each (int x in myArray)

ColdFusion Markup Language (CFML)

Script syntax

// arrays
arrayeach( ,2,3,4,5 function(v));

// or

for (v in ,2,3,4,5

// or

// (Railo only; not supported in ColdFusion)
letters = a","b","c","d","e"
letters.each(function(v));

// structs
for (k in collection)

// or

structEach(collection, function(k,v));

// or
// (Railo only; not supported in ColdFusion)
collection.each(function(k,v));

Tag syntax

a','b','c','d','e'">
#v#


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.

#collection

Common Lisp

Common Lisp provides foreach ability either with the ''dolist'' macro:

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

or the powerful ''loop'' macro to iterate on more data types

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

and even with the ''mapcar'' function:

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

D

foreach(item; set)

or

foreach(argument)

Dart

for (final element in someCollection)

Object Pascal, Delphi

Foreach support was added in Delphi 2005, and uses an enumerator variable that must be declared in the ''var'' section.

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

Eiffel

The iteration (foreach) form of the Eiffel loop construct is introduced by the keyword across.

In this example, every element of the structure my_list is printed:

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

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.

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 universal quantification) or some (effecting existential quantification).

This iteration is a boolean expression which is true if all items in my_list have counts greater than three:

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

The following is true if at least one item has a count greater than three:

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

Go

Go's foreach loop can be used to loop over an array, slice, string, map, or channel.

Using the two-value form, we get the index/key (first element) and the value (second element):

for index, value := range someCollection

Using the one-value form, we get the index/key (first element):

for index := range someCollection

Groovy

Groovy supports ''for'' loops over collections like arrays, lists and ranges:

def x = ,2,3,4for (v in x) // loop over the 4-element array x

for (v in ,2,3,4 // loop over 4-element literal list

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

Groovy also supports a C-style for loop with an array index:

for (i = 0; i < x.size(); i++)

Collections in Groovy can also be iterated over using the ''each'' keyword
and a closure. By default, the loop dummy is named ''it''

x.each // print every element of the x array
x.each // equivalent to line above, only loop dummy explicitly named "i"

Haskell

Haskell allows looping over lists with monadic actions using mapM_ and forM_ (mapM_ with its arguments flipped) fro
Control.Monad

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) fro

Haxe

for (value in iterable)

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

Java

In Java, a foreach-construct was introduced in Java Development Kit (JDK) 1.5.0.
"Enhanced for Loop - This new language construct ..

Official sources use several names for the construct. It is referred to as the "Enhanced for Loop", the "For-Each Loop", and the "foreach statement".

for (Type item : iterableCollection)

Java also provides the stream api since java 8:

List intList = List.of(1, 2, 3, 4);
intList.stream().forEach(i -> System.out.println(i));

JavaScript

The ECMAScript 6 standard has for..of
/code> for index-less iteration over generators, arrays and more:

for (var item of array)

Alternatively, function-based style:

array.forEach(item => )

For unordered iteration over the keys in an Object, JavaScript features the for...in loop:

for (var key in object)

To limit the iteration to the object's own properties, excluding those inherited through the prototype chain, it is sometimes useful to add a hasOwnProperty() test, if supported by the JavaScript engine (for WebKit/Safari, this means "in version 3 or later").

for (var key in object)

ECMAScript 5 provided Object.keys method, to transfer the own keys of an object into array.

var book = ;
for(var key of Object.keys(book))

Lua

Iterate only through numerical index values:
for index, value in ipairs(array) do
-- do something
end
Iterate through all index values:
for index, value in pairs(array) do
-- do something
end

Mathematica

In Mathematica, Do will simply evaluate an expression for each element of a list, without returning any value.

In[]:= Do[doSomethingWithItem, ]

It is more common to use Table, which returns the result of each evaluation in a new list.

In[]:= list = ;

In[]:= Table[item^2, ]
Out[]=

MATLAB

for item = array
%do something
end

Mint

For each loops are supported in Mint, possessing the following syntax:

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

The for (;;) or while (true) infinite loop
in Mint can be written using a for each loop and an infinitely long list.

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'
* ' , 1, 2, 3, 4, 5, ..., infinity
*/
infiniteList = list(identity)
for each element of infiniteList
/* 'Do something forever.' */
end

Objective-C

Foreach loops, called Fast enumeration, are supported starting in Objective-C 2.0. They can be used to iterate over any object that implements the NSFastEnumeration protocol, including NSArray, NSDictionary (iterates over keys), NSSet, etc.

NSArray *a = SArray new // Any container class can be substituted

for(id obj in a)

NSArrays can also broadcast a message to their members:

NSArray *a = SArray new

makeObjectsPerformSelector:@selector(printDescription)

Where blocks are available, an NSArray can automatically perform a block on every contained item:

yArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop)

The type of collection being iterated will dictate the item returned with each iteration.
For example:

NSDictionary *d = SDictionary new

for(id key in d)

OCaml

OCaml is a functional language. Thus, the equivalent of a foreach loop can be achieved as a library function over lists and arrays.

For lists:

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

or in short way:

List.iter print_int ;2;3;4;

For arrays:

Array.iter (fun x -> print_int x)
Array.iter_print_int_ 1;2;3;4, ;

__ParaSail_

The_ParaSail_

Parasailing,_also_known_as_parascending,_paraskiing_or_parakiting,_is_a_recreational__kiting_activity_where_a_person_is_towed_behind_a_vehicle_while_attached_to_a_specially_designed_canopy_wing_that_resembles_a_parachute,_known_as_a_parasail_w_...