Цикл foreach

В компьютерном программировании цикл foreach (или цикл for-each ) — это оператор потока управления для обхода элементов в коллекции . Обычно foreach используется вместо стандартного оператора цикла for . Однако в отличие от других конструкций цикла for , циклы foreach ^[1] обычно не поддерживают явного счетчика: они по сути говорят «сделай это со всем в этом наборе», а не «сделай это x раз». Это позволяет избежать потенциальных ошибок с несоответствием одному элементу и упрощает чтение кода. В объектно-ориентированных языках итератор , даже если он неявный, часто используется как средство обхода.

Оператор foreach в некоторых языках имеет определенный порядок, обрабатывая каждый элемент в коллекции от первого до последнего. Оператор foreach во многих других языках, особенно в языках программирования массивов , не имеет определенного порядка. Это упрощает оптимизацию цикла в целом и, в частности, позволяет выполнять векторную обработку элементов в коллекции одновременно.

Синтаксис различается в зависимости от языка. Большинство используют простое слово for, хотя другие используют более логичное слово foreach, примерно так:

foreach(ключ, значение) в коллекции { # Сделайте что-нибудь ценное #}

Языки программирования , которые поддерживают циклы foreach, включают ABC , ActionScript , Ada , C++ (начиная с C++11 ), C# , ColdFusion Markup Language (CFML), Cobra , D , Daplex (язык запросов), Delphi , ECMAScript , Erlang , Java (начиная с версии 1.5), JavaScript , Lua , Objective-C (начиная с версии 2.0), ParaSail , Perl , PHP , Prolog , ^[2] Python , R , REALbasic , Rebol , ^[3] Red , ^[4] Ruby , Scala , Smalltalk , Swift , Tcl , tcsh , оболочки Unix , Visual Basic (.NET) и Windows PowerShell . Известные языки без foreach — C и C++ до C++11.

ActionScript поддерживает стандарт ECMAScript 4.0 ^[5] для for each .. in^[6], который извлекает значение по каждому индексу.

var foo : Object = { "яблоко" : 1 , "апельсин" : 2 };   для каждого ( var value : int in foo ) { trace ( value ); }        // возвращает "1", затем "2"

Он также поддерживает for .. in^[7], который извлекает ключ из каждого индекса.

для ( var key : String in foo ) { trace ( key ); }       // возвращает "яблоко", затем "апельсин"

В Wikibook Ada Programming есть страница по теме: Управление

Ada поддерживает циклы foreach как часть обычного цикла for . Допустим, X — это массив :

for  I  in  X ' Range  loop  X  ( I )  :=  Get_Next_Element ; конец  цикла ;

Этот синтаксис используется в основном для массивов, но также будет работать и с другими типами, когда требуется полная итерация.

В Ada 2012 имеются обобщенные циклы для циклов foreach для любого типа контейнера (массив, списки, карты...):

для  Obj  цикла  X  - Работа над конечным циклом Obj ;  

В языке C нет коллекций или конструкции foreach. Однако в нем есть несколько стандартных структур данных, которые можно использовать как коллекции, а foreach можно легко создать с помощью макроса .

Однако возникают две очевидные проблемы:

• Макрос негигиеничен: он объявляет новую переменную в существующей области видимости, которая остается после цикла.
• Невозможно определить один макрос foreach, работающий с различными типами коллекций (например, массив и связанный список) или расширяемый для пользовательских типов.

Строка C как набор символов

#include <stdio.h> /* макрос foreach, просматривающий строку как набор значений символов */#определить foreach(ptrvar, strvar) \char* ptrvar; \для (ptrvar = strvar; (*ptrvar) != '\0'; *ptrvar++)int main ( int argc , char ** argv ) {      символ * s1 = "abcdefg" ;    символ * s2 = "123456789" ;    для каждого ( p1 , s1 ) {    printf ( "цикл 1: %c \n " , * p1 );  } для каждого ( p2 , s2 ) {    printf ( "цикл 2: %c \n " , * p2 );  } вернуть 0 ; }

Массив C int как коллекция int (размер массива известен во время компиляции)

#include <stdio.h> /* макрос foreach, просматривающий массив значений int как коллекцию значений int */#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 };         для каждого ( p1 , a1 ) {    printf ( "цикл 1: %d \n " , * p1 );  } для каждого ( p2 , a2 ) {    printf ( "цикл 2: %d \n " , * p2 );  } вернуть 0 ; }

Наиболее общий: строка или массив как коллекция (размер коллекции известен во время выполнения)

idxtypeможно удалить и typeof(col[0])использовать вместо него GCC

#include <stdio.h> #include <строка.h> /* макрос foreach, просматривающий массив заданного типа как коллекцию значений заданного типа */#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 = "коллекция" ;    int c2 [] = { 3 , 1 , 4 , 1 , 5 , 9 };         двойной * c3 ;  int c3len = 4 ;    c3 = ( double * ) calloc ( c3len , sizeof ( double ));     с3 [ 0 ] знак равно 1,2 ; с3 [ 1 ] = 3,4 ; с3 [ 2 ] = 5,6 ; с3 [ 3 ] = 7,8 ;            foreach ( char , p1 , c1 , strlen ( c1 )) {      printf ( "цикл 1: %c \n " , * p1 );  } foreach ( int , p2 , c2 , arraylen ( c2 )) {      printf ( "цикл 2: %d \n " , * p2 );  } foreach ( double , p3 , c3 , c3len ) {      printf ( "цикл 3: %.1lf \n " , * p3 );  } вернуть 0 ; }

В C# , предполагая, что myArray — это массив целых чисел:

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

Язык интегрированных запросов (LINQ) предоставляет следующий синтаксис, принимающий делегат или лямбда-выражение :

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

C++11 предоставляет цикл foreach. Синтаксис похож на Java:

#include <iostream> int main () { int myint [] = { 1 , 2 , 3 , 4 , 5 };          для ( int i : myint ) { std :: cout << i << '\n' ; } }           

Операторы for на основе диапазона C++11 реализованы в GNU Compiler Collection (GCC) (начиная с версии 4.6), Clang (начиная с версии 3.0) и Visual C++ 2012 (версия 11 ^[8] )

Диапазон на основе forсинтаксического сахара эквивалентен:

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

Компилятор использует зависимый от аргументов поиск для разрешения функций beginи end. ^[9]

Стандартная библиотека C ++ также поддерживает for_each, ^[10] , которая применяет каждый элемент к функции, которая может быть любой предопределенной функцией или лямбда-выражением. В то время как основанный на диапазоне for действует только от начала до конца, диапазон или направление можно изменить, изменив первые два параметра.

#include <iostream> #include <algorithm> // содержит 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 << "перевернуто, но пропущено 2 элемента: \n " ;   std :: for_each ( v . rbegin () + 2 , v . rend (), []( int i ) { std :: cout << i << '\n' ; }); }          

Qt , фреймворк C++, предлагает макрос, реализующий циклы foreach ^[11] с использованием интерфейса итератора STL:

#include <QList> #include <QDebug>  int main () { QList < int > список ;    список << 1 << 2 << 3 << 4 << 5 ;           foreach ( int i , list ) { qDebug () << i ; } }        

Boost , набор бесплатных рецензируемых переносимых библиотек C++, также предоставляет циклы foreach: ^[12]

#include <boost/foreach.hpp> #include <iostream> int main () { int myint [] = { 1 , 2 , 3 , 4 , 5 }; BOOST_FOREACH ( int & i , myint ) { std :: cout << i << '\n' ; } }                       

Язык C++/CLI предлагает конструкцию, похожую на C#.

Предположим, что myArray — это массив целых чисел:

для каждого ( int x in myArray ) { Console :: WriteLine ( x ); }      

// массивы arrayeach ( [ 1,2,3,4,5 ] , function ( v ) { writeOutput ( v ) ; } ) ;​  // илидля  ( v  in  [ 1 , 2 , 3 , 4 , 5 ]) {  writeOutput ( v ); }// или// (Только Railo; не поддерживается в ColdFusion) letters  =  [ "a" , "b" , "c" , "d" , "e" ]; letters.each ( function ( v ) {  writeOutput ( v );  // abcde });// структуры для  ( k  в  коллекции ){  writeOutput ( коллекция [ k ]); }// илиstructEach ( коллекция ,  функция ( k , v ){  writeOutput ( "ключ: #k# , значение: #v# ;" ); });// или // (только Railo; не поддерживается в ColdFusion) collection.each ( function ( k , v ) {  writeOutput ( "key: #k# , value: #v# ;" ); });

<!--- массивы ---> <cfloop  индекс = "v"  массив = " #['a','b','c','d','e']# " >  <cfoutput> # v # </cfoutput> <!--- abcde ---> </cfloop>

CFML неправильно идентифицирует значение как «индекс» в этой конструкции; indexпеременная получает фактическое значение элемента массива, а не его индекс.

<!--- структуры ---> <cfloop  item = "k"  collection = " #collection# " >  <cfoutput> # collection [ k ]# </cfoutput> </cfloop>

Common Lisp предоставляет возможность foreach с помощью макроса dolist :

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

или мощный макрос цикла для итерации большего количества типов данных

( цикл для i в ' ( 1 3 5 6 8 10 14 17 ) сделать ( напечатать i ))              

и даже с функцией mapcar :

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

foreach ( item ; set ) { // сделать что-то с элементом }   

или

foreach ( аргумент ) { // передать значение }  

for ( final element in someCollection ) { // сделать что-то с элементом }      

Поддержка Foreach была добавлена ​​в Delphi 2005 и использует переменную-перечислитель, которая должна быть объявлена ​​в разделе var .

для перечислителя в коллекции do begin //сделать что-то здесь end ;     

Итерационная форма (foreach) конструкции цикла Эйфеля вводится ключевым словом across.

my_listВ этом примере печатается каждый элемент структуры :

 через my_list как ic loop print ( ic . item ) конец       

Локальная сущность icявляется экземпляром класса библиотеки ITERATION_CURSOR. Функция курсора itemобеспечивает доступ к каждому элементу структуры. Потомки класса ITERATION_CURSORмогут быть созданы для обработки специализированных алгоритмов итерации. Типы объектов, которые могут быть итерированы ( my_listв примере), основаны на классах, которые наследуются от класса библиотеки ITERABLE.

Итеративную форму цикла Эйфеля можно также использовать как логическое выражение, если loopзаменить ключевое слово на all(выполняя универсальную квантификацию ) или some(выполняя экзистенциальную квантификацию ).

Эта итерация представляет собой логическое выражение, которое истинно, если все элементы my_listимеют количество больше трех:

 по всему my_list как ic все ic . item . count > 3 конец        

Следующее утверждение верно, если хотя бы один элемент имеет количество больше трех:

 через my_list как ic некоторый ic . item . count > 3 конец        

Цикл foreach в Go можно использовать для обхода массива, среза, строки, карты или канала.

Используя двухзначную форму, получаем индекс/ключ (первый элемент) и значение (второй элемент):

for index , value := range someCollection { // Сделать что-нибудь с index и value }      

Используя форму с одним значением, получаем индекс/ключ (первый элемент):

for index := range someCollection { // Сделайте что-нибудь для индекса }     

^[13]

Groovy поддерживает циклы для таких коллекций, как массивы, списки и диапазоны:

def x = [ 1 , 2 , 3 , 4 ] for ( v in x ) // цикл по 4-элементному массиву x { println v }         for ( v in [ 1 , 2 , 3 , 4 ]) // цикл по 4-элементному литеральному списку { println v }      for ( v in 1 .. 4 ) // цикл по диапазону 1..4 { println v }      

Groovy также поддерживает цикл for в стиле C с индексом массива:

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

Коллекции в Groovy также могут быть итерированы с использованием ключевого слова each и замыкания. По умолчанию фиктивный цикл называется it

x . each { println it } // распечатать каждый элемент массива x x . each { i -> println i } // эквивалентно строке выше, только фиктивный цикл явно назван "i"       

Haskell позволяет выполнять циклы по спискам с помощью монадических действий, используя mapM_and forM_( mapM_с переставленными аргументами) из Control.Monad:

mapM_ печать [ 1 .. 4 ]  

1234

forM_ "тест" $ \ символ -> do putChar символ putChar символ          

ттиесстт

Также возможно обобщить эти функции для работы с аппликативными функторами, а не с монадами и любой структурой данных, которую можно обходить, используя traverse( forс перевернутыми аргументами) и mapM( forMс перевернутыми аргументами) из Data.Traversable.

для ( значение в итерируемом ) { трассировка ( значение ); }     Лямбда . iter ( итератор , функция ( значение ) трассировка ( значение ));  

В Java конструкция foreach была введена в Java Development Kit (JDK) 1.5.0. ^[14]

Официальные источники используют несколько названий для этой конструкции. Она упоминается как «Enhanced for Loop», ^[14] «For-Each Loop», ^[15] и «foreach statement». ^{[16] [17] : 264}

for ( Type item : iterableCollection ) { // Сделать что-нибудь с элементом }      

Java также предоставляет потоковый API, начиная с Java 8: ^{[17] : 294–203}

 Список < Целое число > intList = Список . of ( 1 , 2 , 3 , 4 ); intList . stream (). forEach ( i -> System . out . println ( i ));         

В ECMAScript 5 к прототипуforEach() массива был добавлен метод, основанный на обратном вызове : ^[18]

myArray . forEach ( function ( item , index ) { // Выполняем действия с item и index // Переменная index может быть исключена из списка параметров, если она не нужна });     

Стандарт ECMAScript 6 ввел более традиционный for..ofсинтаксис, который работает со всеми итерируемыми объектами , а не только с экземплярами массива. Однако индексная переменная недоступна с этим синтаксисом.

for ( const item of myArray ) { // Делаем что-нибудь с элементом }      

Для неупорядоченной итерации по ключам в объекте в JavaScript предусмотрен for..inцикл:

for ( const key in myObject ) { // Делаем что-нибудь с myObject[key] }      

Чтобы ограничить итерацию собственными свойствами объекта, за исключением тех, которые унаследованы через цепочку прототипов, часто бывает полезно добавить hasOwnProperty()тест (или hasOwn()тест, если он поддерживается). ^[19]

for ( const key in myObject ) { // Доступно в старых браузерах if ( myObject . hasOwnProperty ( key )) { // Выполнение действий с object[key] } // Предпочтительно в современных браузерах if ( Object . hasOwn ( myObject , key )) { // Выполнение действий с object[key] } }                  

В качестве альтернативы Object.keys()метод в сочетании с for..ofциклом можно использовать для менее сложного способа перебора ключей объекта. ^[20]

const book = { name : "Рождественская песнь" , author : "Чарльз Диккенс" }; for ( const key of Object . keys ( book )) { console . log ( `Key: ${ key } , Value: ${ book [ key ] } ` ); }                 

Источник: ^[21]

Выполнять итерацию только по числовым значениям индекса:

для  индекса ,  значение  в  ipairs ( массив )  do -- сделать что-то end

Перебрать все значения индекса:

для  индекса ,  значение  в  парах ( массив )  do -- сделать что-то end

В системе Mathematica просто Doвычисляет выражение для каждого элемента списка, не возвращая никакого значения.

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

Чаще используется Table, который возвращает результат каждой оценки в новом списке.

В [] := список = { 3 , 4 , 5 };     В [] := Таблица [ элемент ^ 2 , { элемент , список }] Выходит [] = { 9 , 16 , 25 }      

для элемента = массив %сделать что-то конец   

В Mint поддерживаются циклы For each, имеющие следующий синтаксис:

для каждого элемента списка /* 'Сделать что-нибудь.' * / конец     

for (;;)Бесконечный цикл в Mint можно записать с использованием цикла for each и бесконечно длинного списка . ^[22 while (true) ]

import type /* 'Эта функция сопоставлена' * 'каждому индексу i' * 'бесконечно длинного списка.' */ sub identity ( x ) return x end /* 'Следующий код создает список' * '[0, 1, 2, 3, 4, 5, ..., бесконечность]' */ infiniteList = list ( identity ) for each element of infiniteList /* 'Делаем что-то вечно.' */ end           

Циклы Foreach, называемые Fast enumeration , поддерживаются начиная с Objective-C 2.0. Их можно использовать для итерации по любому объекту, реализующему протокол NSFastEnumeration, включая NSArray, NSDictionary (итерация по ключам), NSSet и т. д.

NSArray * a = [ NSArray new ]; // Любой класс контейнера может быть заменен     for ( id obj in a ) { // Используется динамическая типизация. Тип объекта, хранящегося // в 'a', может быть неизвестен. Массив может содержать много различных // типов объектов.        printf ( "%s \n " , [[ obj description ] UTF8String ]); // Необходимо использовать UTF8String с %s NSLog ( @"%@" , obj ); // Оставить как объект }       

NSArrays также может транслировать сообщение своим членам:

NSArray * a = [ NSArray новый ];    [ a makeObjectsPerformSelector : @selector ( printDescription )]; 

При наличии блоков NSArray может автоматически выполнить блокировку для каждого содержащегося элемента:

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

Тип итерируемой коллекции будет определять элемент, возвращаемый при каждой итерации. Например:

NSDictionary * d = [ NSDictionary новый ];    for ( id key in d ) { NSObject * obj = [ d objectForKey : key ]; // Мы используем (уникальный) ключ для доступа к (возможно, неуникальному) объекту. NSLog ( @"%@" , obj ); }            

OCaml — это функциональный язык программирования . Таким образом, эквивалент цикла foreach может быть реализован как библиотечная функция над списками и массивами.

Для списков:

Список.iter ( fun x - > print_int x ) [ 1 ; 2 ; 3 ; 4 ] ;;      

или короче:

Список . iter  print_int  [ 1 ; 2 ; 3 ; 4 ];;

Для массивов:

Массив . iter  ( fun  x  ->  print_int  x )  [| 1 ; 2 ; 3 ; 4 |];;

или короче:

Массив . iter  print_int  [| 1 ; 2 ; 3 ; 4 |];;

Параллельный язык программирования ParaSail поддерживает несколько видов итераторов , включая общий итератор «for each» по контейнеру:

var  Con  :  Container < Element_Type >  :=  .. . // ... для  каждого  Elem  Con  параллельный  цикл // цикл  также  может быть "прямым" или "обратным" или неупорядоченным (по умолчанию)  // ... что-то сделать с Elem конец  цикла

ParaSail также поддерживает фильтры для итераторов и возможность ссылаться как на ключ, так и на значение карты. Вот прямая итерация по элементам "My_Map", выбирающая только те элементы, где ключи находятся в "My_Set":

var  My_Map  :  Map < Key_Type  =>  Univ_String ,  Value_Type  =>  Tree < Integer >>  :=  .. . const  My_Set  :  Set < Univ_String >  :=  [ "abc" ,  "def" ,  "ghi" ];для  каждого  [ Str  =>  Tr ]  из  My_Map  { Str  in  My_Set }  прямой  цикл  // ... сделать что-то со Str или Tr конец  цикла

В языке Паскаль стандарт ISO 10206:1990 ввел итерацию по типам множеств , таким образом:

вар элт : ТипЭлемента ; eltset : набор ElementType ;​      {...}для elt в eltset do { ... сделать что-то с elt }     

В Perl foreach (эквивалент более короткого for) может использоваться для обхода элементов списка. Выражение, которое обозначает коллекцию для цикла, вычисляется в контексте списка, и каждый элемент полученного списка, в свою очередь, сопоставляется с переменной цикла .

Пример буквального списка:

для каждого ( 1 , 2 , 3 , 4 ) { печать $_ ; }       

Примеры массивов:

foreach ( @arr ) { print $_ ; }    

foreach $x ( @arr ) { #$x — элемент в @arr print $x ; }      

Пример хеша:

foreach $x ( keys %hash ) { print $x . " = " . $hash { $x }; # $x — это ключ в %hash, а $hash{$x} — его значение }           

Прямая модификация членов коллекции:

@arr = ( 'remove-foo' , 'remove-bar' ); foreach $x ( @arr ){ $x =~ s/remove-// ; } # Теперь @arr = ('foo', 'bar');          

foreach  ( $set  as  $value )  {  // Сделать что-нибудь с $value; }

Также возможно извлечь как ключи, так и значения, используя альтернативный синтаксис:

foreach  ( $set  as  $key  =>  $value )  {  echo  " { $key } имеет значение { $value } " ; }

Прямая модификация членов коллекции:

$arr  =  array ( 1 ,  2 ,  3 ); foreach  ( $arr  as  & $value )  {  // &, $value — это ссылка на исходное значение внутри $arr  $value ++ ; } // Теперь $arr = array(2, 3, 4);// также работает с полным синтаксисом foreach  ( $arr  as  $key  =>  & $value )  {  $value ++ ; }

• Дополнительная информация

для  элемента  в  iterable_collection :  # Сделать что-нибудь с элементом

Присваивание кортежей в Python, полностью доступное в цикле foreach, также упрощает итерацию пар (ключ, значение) в словарях :

for  key ,  value  in  some_dict . items ():  # Прямая итерация по словарю итерирует по его ключам  # Делаем что-нибудь

Поскольку for ... inэто единственный тип цикла for в Python, эквивалентом цикла «counter», встречающегося в других языках, является...

для  i  в  диапазоне ( len ( seq )):  # Сделать что-нибудь с seq[i]

... хотя использование enumerateфункции считается более «питоновским»:

для  i ,  элемент  в  enumerate ( seq ):  # Выполнить что-то с элементом  # Возможно присвоить его обратно seq[i]

для ( элемент в объекте ) { # Сделать что-то с элементом }    

Поскольку for ... inэто единственный тип forцикла в R, эквивалентом цикла «counter», встречающегося в других языках, является...

for ( i in seq_along ( object )) { # Сделать что-нибудь с object[[i]] }    

( для ([ набор элементов ]) ( сделать-что-то-с -элементом ))    

или с использованием обычной for-eachфункции Scheme:

( for-each сделать-что-то-со -списком )  

do-something-withявляется функцией с одним аргументом.

В Raku , языке-побратиме Perl, for должен использоваться для обхода элементов списка ( foreach не допускается). Выражение, обозначающее коллекцию для цикла, вычисляется в контексте списка, но по умолчанию не сглаживается, и каждый элемент результирующего списка, в свою очередь, сопоставляется с переменной(ыми) цикла.

Пример буквального списка:

для  1 .. 4 { . сказать ;}

Примеры массивов:

для  @arr { . сказать ;}

Цикл for в форме модификатора оператора:

. скажите  для  @arr ;

для  @arr -> $x { скажем  $x ;}

for  @arr -> $x , $y { # более одного элемента одновременно  say  "$x, $y" ;}

Пример хеша:

для  ключей  %хэш -> $key { say  "$key: $hash{$key}" ;}

или

для  %хэш . kv -> $key , $value { say  "$key: $value" ;}

или

for  %hash -> $x { say  "$x.key(): $x.value()" ; # Скобки нужны для встраивания в строку в двойных кавычках}

Прямая модификация элементов коллекции с помощью двухточечного блока, <-> :

мой  @arr = 1 , 2 , 3 ; для  @arr <-> $x { $x *= 2 ;}# Теперь @arr = 2,4,6;

set . each do | item | # сделать что-то с концом элемента   

или

для элемента в наборе # сделать что-то с концом элемента    

Это также можно использовать с хэшем.

set . each do | key , value | # сделать что-то с key # сделать что-то со value end    

Цикл forимеет структуру . Он неявно вызывает метод IntoIterator::into_iter для выражения и использует полученное значение, которое должно реализовывать черту Iterator. Если выражение само по себе является итератором, оно используется непосредственно циклом через реализацию IntoIterator для всех Iterators, которая возвращает итератор без изменений. Цикл вызывает метод для итератора перед выполнением тела цикла. Если возвращает , значение внутри присваивается шаблону , и тело цикла выполняется; если возвращает , цикл завершается.for <pattern> in <expression> { /* optional statements */ }forIterator::nextIterator::nextSome(_)None

пусть mut числа = vec! [ 1 , 2 , 3 ];      // Неизменяемая ссылка: for number in & numbers { // вызывает IntoIterator::into_iter(&numbers) println! ( "{}" , number ); }       для квадрата в числах . iter (). map ( | x | x * x ) { // numbers.iter().map(|x| x * x) реализует итератор println! ( "{}" , square ); }          // Изменяемая ссылка: для числа в & mut числах { // вызывает IntoIterator::into_iter(&mut числа) * число *= 2 ; }         // печатает "[2, 4, 6]": println! ( "{:?}" , numbers ); // Использует Vec и создает Iterator: for number in numbers { // вызывает IntoIterator::into_iter(numbers) // ... }      // Ошибки с «заимствованием перемещенного значения»: // println!("{:?}", numbers);

// вернуть список измененных элементов items map { x => doSomething ( x ) } items map multiplyByTwo        для { x <- элементы } выход doSomething ( x ) для { x <- элементы } выход multiplyByTwo ( x )          // ничего не возвращать, просто выполнить действия items foreach { x => doSomething ( x ) } items foreach println        для { x <- элементы } doSomething ( x ) для { x <- элементы } println ( x )        // пример сопоставления с образцом в for-comprehension for (( key , value ) <- someMap ) println ( s" $ key -> $ value " )     

( for-each сделать-что-то-со -списком )  

do-something-withявляется функцией с одним аргументом.

коллекция  сделать: [ : элемент |  "сделать что-то с элементом" ]

Swift использует конструкцию for… inдля перебора членов коллекции. ^[23]

for thing in someCollection { // сделать что-то с thing }     

Цикл for… inчасто используется с конструкциями замкнутого и полуоткрытого диапазона для итерации по телу цикла определенное количество раз.

for i in 0. . < 10 { // 0..<10 создает полуоткрытый диапазон, поэтому тело цикла // повторяется для i = 0, i = 1, …, i = 9. }      for i in 0. . .10 { // 0...10 создает замкнутый диапазон, поэтому тело цикла // повторяется для i = 0, i = 1, …, i = 9, i = 10. }      

SystemVerilog поддерживает итерацию по любому вектору или массиву любой размерности с помощью foreachключевого слова.

Тривиальный пример перебирает массив целых чисел:

int array_1d [] = '{ 3 , 2 , 1 , 0 };        foreach array_1d [ индекс ] $ display ( "array_1d[%0d]: %0d" , индекс , array_1d [ индекс ]);    

массив_1d[0]: 3массив_1d[1]: 2массив_1d[2]: 1массив_1d[3]: 0

Более сложный пример перебирает ассоциативный массив массивов целых чисел:

int array_2d [ string ][] = '{ "десятки" : '{ 10 , 11 }, "двадцатки" : '{ 20 , 21 } };              foreach array_2d [ ключ , индекс ] $ display ( "array_2d[%s,%0d]: %0d" , ключ , индекс , array_2d [ ключ , индекс ]);     

array_2d[десятки,0]: 10array_2d[десятки,1]: 11array_2d[двадцатые,0]: 20array_2d[двадцатые,1]: 21

Tcl использует foreach для итерации по спискам. Можно указать более одной переменной-итератора, в этом случае им присваиваются последовательные значения из списка.

foreach { i j } { 1 2 3 4 5 6 } { помещает "$i $j" }           

1 23 45 6

Также возможно выполнять итерацию по нескольким спискам одновременно. В следующем примере iпредполагается, что последовательные значения первого списка, jпоследовательные значения второго списка:

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

1 а2 б3 с

Для каждого элемента в enumerable ' Сделать что-нибудь с элементом. Далее     

или без вывода типа

Для каждого элемента As type In enumerable ' Сделать что-нибудь с элементом. Далее       

Вызовите гипотетическую frobкоманду три раза, каждый раз называя ей название цвета.

C : \> ДЛЯ  %% а В  ( красный зеленый синий )  ДО %% а

foreach  ( $item  in  $set )  {  # Сделать что-нибудь с $item }

Из трубопровода

$list  |  ForEach -Object  { Write-Host  $_ }# или с помощью псевдонимов $list  |  foreach  { write $_ } $list  |  %  { write $_ }

 <xsl:for-each select= "set" > <!-- сделать что-нибудь для элементов в <set> --> </xsl:for-each>   

^[24]

• Цикл «выполнить пока»
• Для цикла
• Цикл While
• Карта (функция высшего порядка)