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

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

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

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

Содержание

  • 1 Синтаксис
  • 2 Поддержка языков
    • 2.1 ActionScript 3.0
    • 2.2 Ada
    • 2.3 C
    • 2.4 C #
    • 2.5 C ++
    • 2.6 C ++ / CLI
    • 2.7 Язык разметки ColdFusion (CFML)
      • 2.7.1 Синтаксис скрипта
      • 2.7.2 Синтаксис тега
    • 2.8 Common Lisp
    • 2.9 D
    • 2.10 Dart
    • 2.11 Object Pascal, Delphi
    • 2.12 Eiffel
    • 2.13 Go
    • 2.14 Groovy
    • 2.15 Haskell
    • 2.16 Haxe
    • 2.17 Java
    • 2.18 JavaScript
    • 2.19 Lua
    • 2.20 Mathematica
    • 2.21 MATLAB
    • 2.22 Mint
    • 2.23 Objective-C
    • 2.24 OCaml
    • 2.25 ParaSail
    • 2.26 Pascal
    • 2.27 Perl
    • 2.28 PHP
    • 2.29 Python
    • 2.30 Racket
    • 2.31 Raku
    • 2.32 Ruby
    • 2.33 Rust
    • 2.34 Scala
    • 2.35 Scheme
    • 2.36 Smalltalk
    • 2.37 Swift
    • 2.38 SystemVerilog
    • 2.39 Tcl
    • 2.40 Visual Basic.NET
    • 2.41 Windows
      • 2.41.1 Обычный командный процессор
      • 2.41.2 Windows PowerShell
    • 2.42 Extensible Stylesheet Language (XSL)
  • 3 См. Также
  • 4 Ссылки

Синтаксис

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

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

Поддержка языков

Языки программирования, которые поддержка циклов 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, Python, REALbasic, Ruby, Scala, Smalltalk, Swift, Tcl, tcsh, оболочки Unix, Visual Basic.NET и Windows PowerShell. Известными языками без foreach являются C и C ++ pre-C ++ 11.

ActionScript 3.0

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

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

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

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

Ада

В Wikibook Программирование на Аде есть страница по теме: Управление

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

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

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

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

для цикла Obj of X - работа с циклом завершения Obj;

C

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

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

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

Строка C как набор char

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

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

1 #include 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 main(int argc, char** argv) { 9 int a1 = {1, 1, 2, 3, 5, 8}; 10 int a2 = {3, 1, 4, 1, 5, 9}; 11 foreach (p1, a1) { 12 printf("loop 1: %d\n", *p1); 13 } 14 foreach (p2, a2) { 15 printf("loop 2: %d\n", *p2); 16 } 17 return 0; 18 }

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

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

C #

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

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

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

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

C ++

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

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

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

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

для (авто __anon = начало (myint); __anon! = конец (myint); ++ __ анон) {авто я = * __ анон; std :: cout << i << '\n'; }

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

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

#include #include // содержит std :: for_each #include int main () {std :: vector v {1, 2, 3, 4, 5}; std :: for_each (v.begin (), v.end (), [] (int i) {std :: cout << i << '\n'; }); std::cout << "reversed but skip 2 elements:\n"; std::for_each(v.rbegin()+2, v.rend(), [](int i) { std::cout << i << '\n'; }); }

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

#include #include int main () {QList list; list << 1 << 2 << 3 << 4 << 5; foreach (int i, list) { qDebug() << i; } }

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

#include #include 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) {Консоль :: WriteLine (x);}

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

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

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

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

# v #

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

#collection [k] #

Common Lisp

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

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

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

(loop for 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 (аргумент) {// передаем value}

Dart

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

Object Pascal, Delphi

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

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

Eiffel

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

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

в my_list как ic loop print (ic.item) end

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

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

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

в my_list как ic all ic.item.count>3 end

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

в my_list как ic some ic.item.count>3 end

Цикл foreach Go

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

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

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

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

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

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

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

Haskell

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

codeпечатает
mapM_ print [1..4]
1 2 3 4
forM_ "test" $ \ char ->do putChar char putChar char
tteesstt

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

Haxe

for (значение в итерируемом) {trace ( значение); } Lambda.iter (итерация, функция (значение) трассировка (значение));

Java

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

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

for (Type item: iterableCollection) {// Что-то делать с элементом}

JavaScript

В стандарте есть for..of для безиндексной итерации по генераторам, массивам и т. Д.:

for (var item of array) {// Do stuff}

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

array.forEach (item =>{// Do stuff})

Для неупорядоченной итерации по ключам в объекте, JavaScript features цикл 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 для передачи собственного ключи объекта в массив.

var book = {name: "Рождественский гимн", автор: "Charles Dickens"}; for (var key of Object.keys (book)) {alert ("PropertyName =" key + "Property Value =" + book [key]); }

Lua

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

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

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

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

Mathematica

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

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

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

В: = список = {3, 4, 5}; In: = Table [item ^ 2, {item, list}] Out = {9, 16, 25}

MATLAB

для item = array% do something end

Mint

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

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

for (;;)или while (true)бесконечный цикл в Mint можно записать, используя для каждого цикла и бесконечно длинный список.

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

Objective-C

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

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

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

NSArray * a = [NSArray new]; [makeObjectsPerformSelector: @selector (printDescription)];

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

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

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

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

OCaml

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

Для списков:

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

или коротко:

List.iter print_int [1; 2; 3; 4] ;;

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

Array.iter (fun x ->print_int x) [| 1; 2; 3; 4 |] ;;

или коротко:

Array.iter print_int [| 1; 2; 3; 4 |] ;;

ParaSail

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

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

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

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

Pascal

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

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

Perl

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

Пример литерала списка:

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

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

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

Пример хэша:

foreach $ x (keys% 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 = array (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 в Python, эквивалент цикла "counter" в других языках:...

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

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

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

Racket

(for ([item set]) (do-something-with item))

или с помощью стандартной схемы для-каждой функции:

(для-каждого do- something-with a-list)

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

Raku

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

Пример литерала списка:

для 1..4 {.say; }

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

для @arr {.say; }

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

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

Пример хеша:

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

или

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

или

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

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

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

Ruby

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

или

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

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

set.each do | элемент, значение | # сделать что-нибудь с элементом # сделать что-нибудь для значения end

Rust

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

пусть числа mut = vec! [1, 2, 3]; // Неизменяемая ссылка: для числа в numbers {// вызывает IntoIterator :: into_iter (numbers) println! ("{}", Number); } для квадрата в numbers.iter (). map (| x | x * x) {// numbers.iter (). map (| x | x * x) реализует Iterator println! ("{}", square); } // Изменяемая ссылка: для числа в mut числах {// вызывает 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 for {x <- items} yield doSomething(x) for {x <- items} yield multiplyByTwo(x) // return nothing, just perform action items foreach { x =>doSomething (x)} items foreach println for {x <- items} doSomething(x) for {x <- items} println(x) // pattern matching example in for-comprehension for ((key, value) <- someMap) println(s"$key ->$ value ")

Схема

(для-каждого-что-то-со списком)

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

Smalltalk

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

Swift

Swift использует конструкцию forinдля перебора элементов коллекции.

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

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

for i in 0.. <10 { // 0..<10 constructs a half-open range, so the loop body // is repeated for i = 0, i = 1, …, i = 9. } for i in 0...10 { // 0...10 constructs a closed range, so the loop body // is repeated for i = 0, i = 1, …, i = 9, i = 10. }

SystemVerilog

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

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

codeпечатает
int array_1d = '{3, 2, 1, 0}; foreach array_1d [index] $ display ("array_1d [ % 0d]:% 0d ", индекс, массив_1d [индекс]);
array_1d [0]: 3 array_1d [1]: 2 array_1d [2]: 1 array_1d [3]: 0

В более сложном примере выполняется итерация по ассоциативному массиву массивов целых чисел:

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

Tcl

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

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

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

codeпечатает
foreach i {1 2 3} j {abc} {помещает "$ i $ j"}
1 a 2 b 3 c

Visual Basic.NET

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

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

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

Windows

Обычный командный процессор

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

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

Windows PowerShell

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

From конвейер

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

Extensible Stylesheet Language (XSL)

См. также

Ссылки

Последняя правка сделана 2021-05-20 11:10:01
Содержание доступно по лицензии CC BY-SA 3.0 (если не указано иное).
Обратная связь: support@alphapedia.ru
Соглашение
О проекте