Цикл по каждому элементу

Для каждого цикла почти всегда используется итерация по элементам в последовательности элементов.

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

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

Синтаксис [ править ]

Синтаксис зависит от языка. Большинство используют это простое слово forпримерно так:

для каждого предмета в коллекции: сделать что-нибудь с предметом

Языковая поддержка [ править ]

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

ActionScript 3.0 [ править ]

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

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

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

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

Ада [ править ]

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

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

для  I  в  X ' Range  петли  X  ( I )  : =  Get_Next_Element ; конец  петли ;

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

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

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

C [ править ]

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

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

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

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

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

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

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

#include  <stdio.h>#include  <string.h>/ * макрос foreach, просматривающий массив заданного типа как коллекцию значений заданного типа * /#define arraylen (arr) (sizeof (arr) / sizeof (arr [0]))#define foreach (idxtype, idxpvar, col, colsiz) \idxtype * idxpvar; \для (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 ; с3  =  ( двойной * ) calloc ( c3len ,  SizeOf ( дважды ));  c3 [ 0 ]  =  1,2 ;  c3 [ 1 ]  =  3,4 ;  c3 [ 2 ]  =  5,6 ;  c3 [ 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 # [ править ]

В C # при условии, что myArray представляет собой массив целых чисел:

foreach  ( int  x  в  myArray )  {  Консоль . WriteLine ( x );  }

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

myArray . ToList (). ForEach ( x  =>  Консоль . WriteLine ( x ));

C ++ [ править ]

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

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

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

Диапазон основы для является синтаксическим сахаром эквивалента:

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

Компилятор использует поиск, зависящий от аргументов, для разрешения функций начала и конца . ^[7]

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

#include  <iostream>#include  <алгоритм> // содержит std :: for_each#include  <вектор>int  main () {  std :: vector < int >  v  { 1 ,  2 ,  3 ,  4 ,  5 }; std :: for_each ( v . begin (),  v . end (),  [ & ] ( int  i )  {  std :: cout  <<  i  <<  '\ n' ;  }); std :: cout  <<  "в обратном порядке, но пропустить 2 элемента: \ n " ; std :: for_each ( v . rbegin () + 2 ,  v . rend (),  [ & ] ( int  i )  {  std :: cout  <<  i  <<  '\ n' ;  }); }

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

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

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

#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 ++ / CLI предлагает конструкцию, аналогичную C #.

Предполагая, что myArray представляет собой массив целых чисел:

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

Язык разметки ColdFusion (CFML) [ править ]

Синтаксис скрипта [ править ]

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

Синтаксис тега [ править ]

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

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

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

Common Lisp [ править ]

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

( долист  ( i  ' ( 1  3  5  6  8  10  14  17 ))  ( печать  i ))

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

( цикл  для  i  in  ' ( 1  3  5  6  8  10  14  17 )  do  ( print  i ))

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

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

D [ править ]

foreach ( item ;  set )  {  // что-то делаем с элементом } или foreach ( аргумент )  {  // передаем значение }

Дротик [ править ]

for  ( последний  элемент  в  someCollection )  {  // что-то делаем с элементом }

Object Pascal, Delphi [ править ]

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

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

Эйфель [ править ]

Итерационная (foreach) форма конструкции цикла Eiffel вводится с помощью ключевого слова across.

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

 через  my_list  как  ic  loop  print  ( ic . item )  end

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

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

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

 через  my_list  как  ic  все  ic . пункт . count  >  3  конец

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

 через  my_list  как  ic  some  ic . пункт . count  >  3  конец

Перейти [ править ]

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

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

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

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

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

^[11]

Groovy [ править ]

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 с индексом массива:

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

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

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

Haskell [ править ]

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

mapM_  print  [ 1 .. 4 ]

1234

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

Tteesstt

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

Haxe [ править ]

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

Java [ править ]

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

Официальные источники используют несколько названий конструкции. Он упоминается как «Расширенный цикл» ^[12], «цикл для каждого», ^[13] и «оператор foreach». ^[14]

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

JavaScript [ править ]

ECMAScript 6 стандарт имеет for..ofдля индекса менее итераций над генераторами, массивами и многим другим:

for  ( var  item  of  array ) {  // Что делать }

В качестве альтернативы, стиль на основе функций: ^[15]

массив . forEach ( item  =>  {  // Что делать })

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

for  ( var  key  in  object )  {  // Что-то делать с объектом [key] }

Чтобы ограничить итерацию собственными свойствами объекта, за исключением тех, которые унаследованы через цепочку прототипов, иногда полезно добавить тест hasOwnProperty (), если он поддерживается механизмом JavaScript (для WebKit / Safari это означает «в версии 3 или более поздней. ").

for  ( var  key  in  object )  {  if  ( object . hasOwnProperty ( key ))  {  // Что-то делать с объектом [key]  } }

ECMAScript 5 предоставил метод Object.keys для передачи собственных ключей объекта в массив. ^[16]

var  book  =  {  name :  "Рождественская история" ,  автор :  "Чарльз Диккенс"  };  для ( вар  ключ  от  объекта . ключей ( книга )) {  тревога ( "PropertyName ="  ключ  +  "Свойство Value ="  +  книга [ ключ ]); }

Lua ^[17] [ править ]

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

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

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

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

Математика [ править ]

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

In [] : = Сделайте [ doSomethingWithItem , { item , list }]   

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

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

MATLAB [ править ]

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

Монетный двор [ править ]

Для каждого цикла поддерживаются в Mint со следующим синтаксисом:

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

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

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

Objective-C [ править ]

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

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

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

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

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

[ myArray  enumerateObjectsUsingBlock : ^ ( id  obj ,  NSUInteger  idx ,  BOOL  * stop ) { NSLog ( @ "obj% @" ,  obj ); если  ([ объект  долженStopIterationNow ]) * стоп  =  ДА ; }];

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

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

OCaml [ править ]

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

Для списков:

Список . iter  ( удовольствие  x  ->  print_int  x )  [ 1 ; 2 ; 3 ; 4 ] ;;

или короче:

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

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

Массив . iter  ( удовольствие  x  ->  print_int  x )  [| 1 ; 2 ; 3 ; 4 |] ;;

или короче:

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

ParaSail [ править ]

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

вар  Con  :  Контейнер < ELEMENT_TYPE >  : =  .. . // ... для  каждого  Элем  из  Con  параллельного  контура  // петли также может быть «вперед» или «назад» или неупорядоченный (по умолчанию)  // ... сделать что - то с Элем конца  цикла

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

вар  My_Map  :  Карта < key_type  =>  Univ_String ,  VALUE_TYPE  =>  Дерево < Integer >>  : =  .. . const  My_Set  :  Set < Univ_String >  : =  [ "abc" ,  "def" ,  "ghi" ];для  каждого  [ Str  =>  Tr ]  из  My_Map  { Str  в  My_Set }  вперед  цикла  // ... сделать что - то с ул или Tr конец  цикла

Паскаль [ править ]

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

var  elt :  ElementType ;  eltset :  набор  из  ElementType ;{...}для  еи  в  eltset  делать  {... делать что - то с ELT}

Perl [ править ]

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

Буквальный пример списка:

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

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

foreach  ( @arr )  {  print  $ _ ; }

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

Пример хеша:

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

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

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

PHP [ править ]

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

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

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

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

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

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

Python [ править ]

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

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

для  ключа ,  значение  в  some_dict . items ():  # Прямая итерация по dict выполняет итерацию по ее ключам  # Делаем что-нибудь

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

for  i  in  range ( len ( seq )):  # Что-нибудь сделать с seq [i]

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

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

Ракетка [ править ]

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

или используя обычную for-eachфункцию Scheme :

( для каждого  дела-что-нибудь со  списком )

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

Раку [ править ]

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

Буквальный пример списка:

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

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

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

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

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

for  @arr -> $ x { скажем,  $ x ;}

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

Пример хеша:

для  ключей  % hash -> $ key { скажем  "$ key: $ hash {$ key}" ;}

или же

для  % хэша . kv -> $ key , $ value { скажем  "$ key: $ value" ;}

или же

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

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

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

Руби [ править ]

набор . каждый  делать  | пункт |  # сделать что-нибудь до конца элемента

или же

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

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

набор . каждый  делать  | элемент , значение |  # сделайте что-нибудь с элементом  # сделайте что-нибудь, чтобы получить значение end

Ржавчина [ править ]

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

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

Scala [ править ]

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

Схема [ править ]

( для каждого дела-что-нибудь со  списком )

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

Smalltalk [ править ]

сбор  do: [ : item |  "сделать что-нибудь с предметом" ]

Swift [ править ]

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

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

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

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

SystemVerilog [ править ]

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

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

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

array_1d [0]: 3array_1d [1]: 2array_1d [2]: 1array_1d [3]: 0

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

int  array_2d [ строка ] []  =  '{  "десятки" :  ' {  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 [ править ]

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 bc }  {  помещает  "$ i $ j" }

1 а2 б3 с

Visual Basic .NET [ править ]

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

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

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

Windows [ править ]

Обычный командный процессор [ править ]

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

C: \> FOR  %% a IN  ( красный, зеленый, синий )  DO frob %% a

Windows PowerShell [ править ]

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

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

$ список  |  ForEach -Object  { Write-Host  $ _ }# или используя псевдонимы $ list  |  foreach  { write $ _ } $ list  |  %  { write $ _ }

Расширяемый язык таблиц стилей (XSL) [ править ]

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

^[20]

См. Также [ править ]

• Сделать цикл while
• Для цикла
• Пока цикл
• Карта (функция высшего порядка)

Ссылки [ править ]