Цикл Foreach - Foreach loop

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

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

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

Синтаксис

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

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

Языковая поддержка

Языки программирования которые поддерживают циклы foreach, включают ABC, ActionScript, Ада, C ++ 11, C #, Язык разметки ColdFusion (CFML), Кобра, D, Даплекс (язык запроса), Delphi, ECMAScript, Erlang, Ява (с 1.5), JavaScript, Lua, Цель-C (начиная с версии 2.0), ParaSail, Perl, PHP, Пролог,^[2] Python, REALbasic, Рубин, Scala, Болтовня, Swift, Tcl, tcsh, Оболочки Unix, Visual Basic .NET, и Windows PowerShell. Известные языки без foreach: C, и C ++ до C ++ 11.

ActionScript 3.0

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

вар фу:Объект = {	"яблоко":1,	"оранжевый":2};для каждый (вар ценность:int в фу) { 	след(ценность); }// возвращает "1", затем "2"

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

для (вар ключ:Строка в фу) { 	след(ключ); }// возвращает "яблоко", затем "апельсин"

Ада

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

для я в Икс'Ассортимент петля   Икс (я) := Get_Next_Element;конец петля;

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

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

для Obj из Икс петля   - Работа над Objконец петля;

C

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

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

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

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

 1 #включают <stdio.h> 2  3 / * макрос foreach, просматривающий строку как набор значений char * / 4 #define foreach (ptrvar, strvar)  5 char * ptrvar;  6 для (ptrvar = strvar; (* ptrvar)! = ' 0'; * ptrvar ++) 7  8 int основной(int argc, char** argv) { 9  char* s1 = "abcdefg";10  char* s2 = "123456789";11  для каждого (p1, s1) {12   printf("цикл 1:% c п", *p1);13  }14  для каждого (p2, s2) {15   printf("цикл 2:% c п", *p2);16  }17  вернуть 0;18 }

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

 1 #включают <stdio.h> 2  3 / * макрос foreach, просматривающий массив значений int как коллекцию значений int * / 4 #define foreach (intpvar, intarr)  5 int * intpvar;  6 for (intpvar = intarr; intpvar <(intarr + (sizeof (intarr) / sizeof (intarr [0]))); ++ intpvar) 7  8 int основной(int argc, char** argv) { 9  int а1[] = {1, 1, 2, 3, 5, 8};10  int а2[] = {3, 1, 4, 1, 5, 9};11  для каждого (p1, а1) {12   printf("цикл 1:% d п", *p1);13  }14  для каждого (p2, а2) {15   printf("цикл 2:% d п", *p2);16  }17  вернуть 0;18 }

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

Заметка: idxtype можно удалить и тип (столбец [0]) используется вместо GCC

 1 #включают <stdio.h> 2 #включают <string.h> 3  4 / * макрос foreach, просматривающий массив заданного типа как набор значений заданного типа * / 5 #define arraylen (arr) (sizeof (arr) / sizeof (arr [0])) 6 #define foreach (idxtype, idxpvar, col, colsiz)  7 idxtype * idxpvar;  8 для (idxpvar = col; idxpvar <(col + colsiz); ++ idxpvar) 9 10 int основной(int argc, char** argv) {11  char* c1 = "коллекция";12  int c2[] = {3, 1, 4, 1, 5, 9};13  двойной* c3;14  int c3len = 4;15  c3 = (двойной*)каллок(c3len, размер(двойной)); 16  c3[0] = 1.2; c3[1] = 3.4; c3[2] = 5.6; c3[3] = 7.8;17 18  для каждого (char, p1, c1, Strlen(c1)) {19   printf("цикл 1:% c п", *p1);20  }21  для каждого (int, p2, c2, Arraylen(c2)) {22   printf("цикл 2:% d п", *p2);23  }24  для каждого (двойной, p3, c3, c3len) {25   printf("цикл 3:% .1lf п", *p3);26  }27  вернуть 0;28 }

C #

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

для каждого (int Икс в myArray) { Консоль.WriteLine(Икс); }

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

myArray.К списку().Для каждого(Икс => Консоль.WriteLine(Икс));

C ++

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

#включают <iostream>int основной(){  int Myint[] = {1, 2, 3, 4, 5};  для (int я : Myint)  {    стандартное::cout << я << ' n';  }}

Операторы for на основе диапазона C ++ 11 были реализованы в Коллекция компиляторов GNU (GCC) (начиная с версии 4.6), Лязг (начиная с версии 3.0) и Visual C ++ 2012 г. (версия 11 ^[6])

На основе диапазона для является синтаксический сахар эквивалент:

  для (авто __anon = начать(Myint); __anon != конец(Myint); ++__anon)  {    авто я = *__anon;    стандартное::cout << я << ' n';  }

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

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

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

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

#включают <QList>#включают <QDebug>int основной(){  QList<int> список;  список << 1 << 2 << 3 << 4 << 5;  для каждого (int я, список)  {    qDebug() << я;  }}

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

#включают <boost/foreach.hpp>#включают <iostream> int основной(){  int Myint[] = {1, 2, 3, 4, 5};   BOOST_FOREACH(int &я, Myint)  {    стандартное::cout << я << ' n';  }}

C ++ / CLI

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

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

    для каждый (int Икс в myArray)    {        Консоль::WriteLine(Икс);    }

Язык разметки ColdFusion (CFML)

Синтаксис скрипта

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

Синтаксис тега

<!--- arrays ---> показатель="v" массив="# ['a', 'b', 'c', 'd', 'e'] #">  <cfoutput>#v#</cfoutput><!--- a b c d e  ---></cfloop>

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

<!--- structs ---> предмет="к" коллекция="#коллекция#">    <cfoutput>#коллекция[k]#</cfoutput></cfloop>

Common Lisp

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

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

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

(петля для я в '(1 3 5 6 8 10 14 17)      делать (Распечатать я))

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

(mapcar #'Распечатать '(1 3 5 6 8 10 14 17))

D

для каждого(предмет; набор) {  // делаем что-нибудь с элементом}илидля каждого(аргумент) {  // передать значение}

Дротик

для (окончательный элемент в someCollection) {  // что-то делаем с элементом}

Object Pascal, Delphi

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

для счетчик в коллекция делатьначать  // здесь что-то делаемконец;

Эйфель

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

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

            через мой список так как IC петля Распечатать (IC.предмет) конец

Местная организация IC является экземпляром библиотечного класса ITERATION_CURSOR. Особенности курсора предмет обеспечивает доступ к каждому элементу структуры. Потомки класса ITERATION_CURSOR могут быть созданы для обработки специализированных итерационных алгоритмов. Типы объектов, которые можно повторять по (мой список в примере) основаны на классах, которые наследуются от класса библиотеки ИТЕРАБЕЛЬНЫЙ.

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

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

            через мой список так как IC все IC.предмет.считать > 3 конец

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

            через мой список так как IC немного IC.предмет.считать > 3 конец

Идти

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

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

для показатель, ценность := ассортимент someCollection {	// Делаем что-нибудь для индексации и значения}

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

для показатель := ассортимент someCollection {	// Делаем что-нибудь для индексации}

^[11]

Groovy

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

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

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

для (я = 0; я < Икс.размер(); я++){    println Икс[я]}

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

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

Haskell

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

код	отпечатки
mapM_ Распечатать [1..4]	1234
forM_ "тестовое задание" $ \char -> делать putChar char putChar char	Tteesstt

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

Haxe

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

Ява

В Ява, конструкция foreach была введена в Комплект для разработки Java (JDK) 1.5.0.^[12]

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

для (Тип предмет : iterableCollection) {    // Что-то делаем с элементом}

JavaScript

В EcmaScript 6 стандарт имеет для .. из для безиндексной итерации по генераторам, массивам и многому другому:

для (вар предмет из массив){    // Делаем что-нибудь}

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

массив.для каждого(предмет => {    // Делаем что-нибудь})

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

для (вар ключ в объект) {    // Что-то делать с объектом [ключ]}

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

для (вар ключ в объект) {    если (объект.hasOwnProperty(ключ)) {        // Что-то делать с объектом [ключ]    }}

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

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

Lua^[17]

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

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

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

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

Mathematica

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

В[]:=Делать[doSomethingWithItem,{предмет,список}]

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

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

MATLAB

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

Мята

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

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

В для (;;) или пока (правда) бесконечная петля в Mint можно написать, используя для каждого цикла и бесконечно длинный список.^[18]

импорт тип/ * 'Эта функция сопоставлена с' * 'каждый порядковый номер i из' * "бесконечно длинный список". */суб идентичность(Икс)    вернуть Иксконец/ * 'Следующее создает список' * '[0, 1, 2, 3, 4, 5, ..., бесконечность]' */infiniteList = список(идентичность)для каждый элемент из infiniteList    / * 'Делай что-нибудь вечно.' * /конец

Цель-C

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

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

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

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

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

[myArray enumerateObjectsUsingBlock:^(мне бы объект, NSUInteger idx, BOOL *Стоп)	{		NSLog(@ "obj% @", объект);		если ([объект shouldStopIterationNow])			*Стоп = ДА;	}];

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

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

OCaml

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

Для списков:

Список.iter (весело Икс -> print_int Икс) [1;2;3;4];;

или короче:

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

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

Массив.iter (весело Икс -> print_int Икс) [|1;2;3;4|];;

или короче:

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

ParaSail

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

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

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

вар Моя_Карта : карта<Key_Type => Univ_String, Тип значения => Дерево<Целое число>> := ...const My_Set : Набор<Univ_String> := ["abc", "def", "ги"];для каждый [Ул. => Тр] из Моя_Карта {Ул. в My_Set} вперед петля   // ... делаем что-нибудь с Str или Trконец петля

Паскаль

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

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

Perl

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

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

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

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

для каждого (@arr) {    Распечатать $_;}

для каждого $ x (@arr) { # $ x - это элемент в @arr    Распечатать $ x;}

Пример хеша:

для каждого $ x (ключи % хэш) {    Распечатать $ x . " = " . $ hash{$ x}; # $ x - ключ в% hash, а $ hash {$ x} - его значение}

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

@arr = ( 'remove-foo', 'remove-bar' );для каждого $ x (@arr){    $ x =~ s / remove - //;}# Теперь @arr = ('foo', 'bar');

PHP

для каждого ($ set так как $ значение) {    // Что-нибудь делаем с $ value;}

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

для каждого ($ set так как $ ключ => $ значение) {    эхо "{$ ключ} имеет ценность {$ значение}";}

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

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

Больше информации

Python

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

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

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

Так как для ... в - единственный вид цикла for в Python, эквивалент цикла "counter" в других языках: ...

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

... хотя с помощью перечислять функция считается более «питонической»:

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

Ракетка

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

или используя обычную схему для каждого функция:

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

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

Раку

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

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

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

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

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

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

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

для @arr -> $ x {    сказать $ x;}

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

Пример хеша:

для ключи % хэш -> $ ключ {    сказать "$ key: $ hash {$ key}";}

или

для % хэш.кв -> $ ключ, $ значение {    сказать "$ ключ: $ значение";}

или

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

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

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

Рубин

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

или

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

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

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

Ржавчина

В для петля имеет структуру for в {/ * необязательные операторы * /}. Он неявно вызывает IntoIterator :: into_iter в выражении и использует полученное значение, которое должно реализовывать Итератор черта характера. Если выражение само является итератором, оно используется непосредственно для пройти через реализация IntoIterator для всех Итераторs который возвращает итератор без изменений. Цикл вызывает Итератор :: следующий на итераторе перед выполнением тела цикла. Если Итератор :: следующий возвращается Немного(_), значение внутри присваивается шаблон и тело цикла выполняется; если он вернется Никто, цикл завершен.

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

Scala

// возвращаем список измененных элементовПредметы карта { Икс => сделай что-нибудь(Икс) }Предметы карта multiplyByTwoдля {Икс <- Предметы} Уступать сделай что-нибудь(Икс)для {Икс <- Предметы} Уступать multiplyByTwo(Икс)// ничего не возвращаем, просто выполняем действиеПредметы для каждого { Икс => сделай что-нибудь(Икс) }Предметы для каждого printlnдля {Икс <- Предметы} сделай что-нибудь(Икс)для {Икс <- Предметы} println(Икс)// пример сопоставления с образцом в for-complationдля ((ключ, ценность) <- someMap) println(s "$ ключ -> $ значение")

Схема

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

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

Болтовня

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

Swift

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

для вещь в someCollection {    // что-то делаем с вещью}

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

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

SystemVerilog

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

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

код

отпечатки

int  array_1d[] = '{ 3, 2, 1, 0 };для каждого array_1d[показатель]  $ display("массив_1d [% 0d]:% 0d", показатель, array_1d[показатель]);

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

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

код