In computer programming, foreach loop (or for-each loop) is a control flow statement for traversing items in a collection. foreach is usually used in place of a standard for loop statement. Unlike other for loop constructs, however, foreach loops[1] usually maintain no explicit counter: they essentially say "do this to everything in this set", rather than "do this x 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 foreach statement in some languages has some defined order, processing each item in the collection from the first to the last. The foreach 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:
Ada supports foreach loops as part of the normal for loop. Say X is an array:
forIinX'RangeloopX(I):=Get_Next_Element;endloop;
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...):
forObjofXloop-- Work on Objendloop;
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<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++)intmain(intargc,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);}return0;}
C int array as a collection of int (array size known at compile-time)
#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)intmain(intargc,char**argv){inta1[]={1,1,2,3,5,8};inta2[]={3,1,4,1,5,9};foreach(p1,a1){printf("loop 1: %d\n",*p1);}foreach(p2,a2){printf("loop 2: %d\n",*p2);}return0;}
Most general: string or array as collection (collection size known at run-time)
idxtype can be removed and typeof(col[0]) used in its place with GCC
#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)intmain(intargc,char**argv){char*c1="collection";intc2[]={3,1,4,1,5,9};double*c3;intc3len=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);}return0;}
C#
In C#, assuming that myArray is an array of integers:
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 [8])
The C++ Standard Library also supports for_each,[10] 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.
#include<iostream>#include<algorithm> // contains std::for_each#include<vector>intmain(){std::vector<int>v{1,2,3,4,5};std::for_each(v.begin(),v.end(),[](inti){std::cout<<i<<'\n';});std::cout<<"reversed but skip 2 elements:\n";std::for_each(v.rbegin()+2,v.rend(),[](inti){std::cout<<i<<'\n';});}
Qt, a C++ framework, offers a macro providing foreach loops[11] using the STL iterator interface:
// arraysarrayeach([1,2,3,4,5],function(v){writeOutput(v);});// orfor(vin[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});// structsfor(kincollection){writeOutput(collection[k]);}// orstructEach(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
<!--- arrays ---><cfloopindex="v"array="#['a','b','c','d','e']#"><cfoutput>#v#</cfoutput><!--- a b c d e ---></cfloop>
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.
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:
acrossmy_listasicloopprint(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:
acrossmy_listasicallic.item.count>3end
The following is true if at least one item has a count greater than three:
acrossmy_listasicsomeic.item.count>3end
Go
Go's foreach loop can be used to loop over an array, slice, string, map, or channel.
Using the two-value form gets the index/key (first element) and the value (second element):
forindex,value:=rangesomeCollection{// Do something to index and value}
Using the one-value form gets the index/key (first element):
forindex:=rangesomeCollection{// Do something to index}
Groovy supports for loops over collections like arrays, lists and ranges:
defx=[1,2,3,4]for(vinx)// loop over the 4-element array x{printlnv}for(vin[1,2,3,4])// loop over 4-element literal list {printlnv}for(vin1..4)// loop over the range 1..4{printlnv}
Groovy also supports a C-style for loop with an array index:
for(i=0;i<x.size();i++){printlnx[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{printlnit}// print every element of the x arrayx.each{i->printlni}// 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) from Control.Monad:
code
prints
mapM_print[1..4]
1 2 3 4
forM_"test"$\char->doputCharcharputCharchar
tteesstt
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 Data.Traversable.
Official sources use several names for the construct. It is referred to as the "Enhanced for Loop",[14] the "For-Each Loop",[15] and the "foreach statement".[16][17]:264
for(Typeitem:iterableCollection){// Do something to item}
Java also provides the stream api since java 8:[17]:294–203
For unordered iteration over the keys in an Object, JavaScript features the for...in loop:
for(varkeyinobject){// Do stuff with object[key]}
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(varkeyinobject){if(object.hasOwnProperty(key)){// Do stuff with object[key]}}
ECMAScript 5 provided Object.keys method, to transfer the own keys of an object into array.[19]
varbook={name:"A Christmas Carol",author:"Charles Dickens"};for(varkeyofObject.keys(book)){alert("PropertyName = "key+" Property Value = "+book[key]);}
importtype/* 'This function is mapped to' * 'each index number i of the' * 'infinitely long list.' */subidentity(x)returnxend/* 'The following creates the list' * '[0, 1, 2, 3, 4, 5, ..., infinity]' */infiniteList=list(identity)foreachelementofinfiniteList/* '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=[NSArraynew];// Any container class can be substitutedfor(idobjina){// 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",[[objdescription]UTF8String]);// Must use UTF8String with %sNSLog(@"%@",obj);// Leave as an object}
NSArrays can also broadcast a message to their members:
The type of collection being iterated will dictate the item returned with each iteration. For example:
NSDictionary*d=[NSDictionarynew];for(idkeyind){NSObject*obj=[dobjectForKey:key];// We use the (unique) key to access the (possibly nonunique) object.NSLog(@"%@",obj);}
OCaml
OCaml is a functional programming language. Thus, the equivalent of a foreach loop can be achieved as a library function over lists and arrays.
For lists:
List.iter(funx->print_intx)[1;2;3;4];;
or in short way:
List.iterprint_int[1;2;3;4];;
For arrays:
Array.iter(funx->print_intx)[|1;2;3;4|];;
or in short way:
Array.iterprint_int[|1;2;3;4|];;
ParaSail
The ParaSail parallel programming language supports several kinds of iterators, including a general "for each" iterator over a container:
varCon:Container<Element_Type>:=...// ...foreachElemofConconcurrentloop// loop may also be "forward" or "reverse" or unordered (the default)// ... do something with Elemendloop
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":
varMy_Map:Map<Key_Type=>Univ_String,Value_Type=>Tree<Integer>>:=...constMy_Set:Set<Univ_String>:=["abc","def","ghi"];foreach[Str=>Tr]ofMy_Map{StrinMy_Set}forwardloop// ... do something with Str or Trendloop
Pascal
In Pascal, ISO standard 10206:1990 introduced iteration over set types, thus:
varelt:ElementType;eltset:setofElementType;{...}foreltineltsetdo{ ... do something with elt }
Perl
In Perl, foreach (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.
List literal example:
foreach(1,2,3,4){print$_;}
Array examples:
foreach(@arr){print$_;}
foreach$x(@arr){#$x is the element in @arrprint$x;}
Hash example:
foreach$x(keys%hash){print$x." = ".$hash{$x};# $x is a key in %hash and $hash{$x} is its value}
Direct modification of collection members:
@arr=('remove-foo','remove-bar');foreach$x(@arr){$x=~s/remove-//;}# Now @arr = ('foo', 'bar');
It is also possible to extract both keys and values using the alternate syntax:
foreach($setas$key=>$value){echo"{$key} has a value of {$value}";}
Direct modification of collection members:
$arr=array(1,2,3);foreach($arras&$value){// The &, $value is a reference to the original value inside $arr$value++;}// Now $arr = array(2, 3, 4);// also works with the full syntaxforeach($arras$key=>&$value){$value++;}
or using the conventional Scheme for-each function:
(for-eachdo-something-witha-list)
do-something-with is a one-argument function.
Raku
In Raku, a sister language to Perl, for must be used to traverse elements of a list (foreach 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).
List literal example:
for1..4 { .say; }
Array examples:
for@arr { .say; }
The for loop in its statement modifier form:
.sayfor@arr;
for@arr -> $x { say$x; }
for@arr -> $x, $y { # more than one item at a timesay"$x, $y"; }
The for loop has the structure for<pattern>in<expression>{/* optional statements */}. It implicitly calls the IntoIterator::into_iter method on the expression, and uses the resulting value, which must implement the Iterator trait. If the expression is itself an iterator, it is used directly by the for loop through an implementation of IntoIterator for all Iterators that returns the iterator unchanged. The loop calls the Iterator::next method on the iterator before executing the loop body. If Iterator::next returns Some(_), the value inside is assigned to the pattern and the loop body is executed; if it returns None, the loop is terminated.
letmutnumbers=vec![1,2,3];// Immutable reference:fornumberin&numbers{// calls IntoIterator::into_iter(&numbers)println!("{}",number);}forsquareinnumbers.iter().map(|x|x*x){// numbers.iter().map(|x| x * x) implements Iteratorprintln!("{}",square);}// Mutable reference:fornumberin&mutnumbers{// calls IntoIterator::into_iter(&mut numbers)*number*=2;}// prints "[2, 4, 6]":println!("{:?}",numbers);// Consumes the Vec and creates an Iterator:fornumberinnumbers{// calls IntoIterator::into_iter(numbers)// ...}// Errors with "borrow of moved value":// println!("{:?}", numbers);
// return list of modified elementsitemsmap{x=>doSomething(x)}itemsmapmultiplyByTwofor{x<-items}yielddoSomething(x)for{x<-items}yieldmultiplyByTwo(x)// return nothing, just perform actionitemsforeach{x=>doSomething(x)}itemsforeachprintlnfor{x<-items}doSomething(x)for{x<-items}println(x)// pattern matching example in for-comprehensionfor((key,value)<-someMap)println(s"$key -> $value")
Swift uses the for…in construct to iterate over members of a collection.[22]
forthinginsomeCollection{// do something with thing}
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.
foriin0..<10{// 0..<10 constructs a half-open range, so the loop body// is repeated for i = 0, i = 1, …, i = 9.}foriin0...10{// 0...10 constructs a closed range, so the loop body// is repeated for i = 0, i = 1, …, i = 9, i = 10.}
SystemVerilog
SystemVerilog supports iteration over any vector or array type of any dimensionality using the foreach keyword.
A trivial example iterates over an array of integers:
Tcl 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.
code
prints
foreach{ij}{123456}{puts"$i $j"}
1 2 3 4 5 6
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:
In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed. It is a kind of lazy evaluation that refers specifically to the instantiation of objects or other resources.
Generic programming is a style of computer programming in which algorithms are written in terms of data types to-be-specified-later that are then instantiated when needed for specific types provided as parameters. This approach, pioneered by the ML programming language in 1973, permits writing common functions or types that differ only in the set of types on which they operate when used, thus reducing duplicate code.
In computer programming, an iterator is an object that progressively provides access to each item of a collection, in order.
In object-oriented (OO) and functional programming, an immutable object is an object whose state cannot be modified after it is created. This is in contrast to a mutable object, which can be modified after it is created. In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses memoization to cache the results of expensive computations could still be considered an immutable object.
In computer programming, a weak reference is a reference that does not protect the referenced object from collection by a garbage collector, unlike a strong reference. An object referenced only by weak references – meaning "every chain of references that reaches the object includes at least one weak reference as a link" – is considered weakly reachable, and can be treated as unreachable and so may be collected at any time. Some garbage-collected languages feature or support various levels of weak references, such as C#, Lua, Java, Lisp, OCaml, Perl, Python and PHP since the version 7.4.
D, also known as dlang, is a multi-paradigm system programming language created by Walter Bright at Digital Mars and released in 2001. Andrei Alexandrescu joined the design and development effort in 2007. Though it originated as a re-engineering of C++, D is now a very different language drawing inspiration from other high-level programming languages, notably Java, Python, Ruby, C#, and Eiffel.
In computer science, a for-loop or for loop is a control flow statement for specifying iteration. Specifically, a for-loop functions by running a section of code repeatedly until a certain condition has been satisfied.
In computer programming, a function object is a construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax. In some languages, particularly C++, function objects are often called functors.
In computer science, a generator is a routine that can be used to control the iteration behaviour of a loop. All generators are also iterators. A generator is very similar to a function that returns an array, in that a generator has parameters, can be called, and generates a sequence of values. However, instead of building an array containing all the values and returning them all at once, a generator yields the values one at a time, which requires less memory and allows the caller to get started processing the first few values immediately. In short, a generator looks like a function but behaves like an iterator.
In computing, aliasing describes a situation in which a data location in memory can be accessed through different symbolic names in the program. Thus, modifying the data through one name implicitly modifies the values associated with all aliased names, which may not be expected by the programmer. As a result, aliasing makes it particularly difficult to understand, analyze and optimize programs. Aliasing analysers intend to make and compute useful information for understanding aliasing in programs.
The syntax of Java is the set of rules defining how a Java program is written and interpreted.
In mathematics and in computer programming, a variadic function is a function of indefinite arity, i.e., one which accepts a variable number of arguments. Support for variadic functions differs widely among programming languages.
In computer programming, a sentinel value is a special value in the context of an algorithm which uses its presence as a condition of termination, typically in a loop or recursive algorithm.
C++11 is a version of the ISO/IEC 14882 standard for the C++ programming language. C++11 replaced the prior version of the C++ standard, called C++03, and was later replaced by C++14. The name follows the tradition of naming language versions by the publication year of the specification, though it was formerly named C++0x because it was expected to be published before 2010.
In computer programming, an anonymous function is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed to higher-order functions or used for constructing the result of a higher-order function that needs to return a function. If the function is only used once, or a limited number of times, an anonymous function may be syntactically lighter than using a named function. Anonymous functions are ubiquitous in functional programming languages and other languages with first-class functions, where they fulfil the same role for the function type as literals do for other data types.
Generics are a facility of generic programming that were added to the Java programming language in 2004 within version J2SE 5.0. They were designed to extend Java's type system to allow "a type or method to operate on objects of various types while providing compile-time type safety". The aspect compile-time type safety required that parametrically polymorphic functions are not implemented in the Java virtual machine, since type safety is impossible in this case.
This article describes the syntax of the C# programming language. The features described are compatible with .NET Framework and Mono.
This comparison of programming languages (associative arrays) compares the features of associative array data structures or array-lookup processing for over 40 computer programming languages.
The syntax and semantics of PHP, a programming language, form a set of rules that define how a PHP program can be written and interpreted.
In C++, associative containers are a group of class templates in the standard library of the C++ programming language that implement ordered associative arrays. Being templates, they can be used to store arbitrary elements, such as integers or custom classes. The following containers are defined in the current revision of the C++ standard: set, map, multiset, multimap. Each of these containers differ only on constraints placed on their elements.
This page is based on this Wikipedia article Text is available under the CC BY-SA 4.0 license; additional terms may apply. Images, videos and audio are available under their respective licenses.
