Для цикла

В информатике цикл for или цикл for — это потока управления оператор , определяющий итерацию . В частности, цикл for функционирует путем многократного выполнения фрагмента кода до тех пор, пока не будет выполнено определенное условие.

Циклы for состоят из двух частей: заголовка и тела. Заголовок определяет итерацию, а тело — это код, который выполняется один раз за итерацию. Заголовок часто объявляет явный счетчик цикла или переменную цикла . Это позволяет телу узнать, какая итерация выполняется. Циклы for обычно используются, когда количество итераций известно до входа в цикл. Циклы for можно рассматривать как сокращение циклов while , которые увеличивают и проверяют переменную цикла.

Для обозначения использования цикла for используются различные ключевые слова: потомки АЛГОЛА используют " for ", в то время как потомки Фортрана используют " do ". Есть и другие возможности, например COBOL , который использует PERFORM VARYING.

Название цикла for происходит от слова for . For используется как зарезервированное слово (или ключевое слово) во многих языках программирования для введения цикла for. Этот термин на английском языке появился в Алголе 58 и был популяризирован в Алголе 60 . Это прямой перевод более раннего немецкого слова «für» , использовавшийся в «Суперплане» (1949–1951) Хайнца Рутисхаузера . Рутисхаузер участвовал в определении АЛГОЛА 58 и АЛГОЛА 60. ^[1] Тело цикла выполняется «для» заданных значений переменной цикла. Это более явно проявляется в версиях оператора for на языке ALGOL , где можно указать список возможных значений и приращений.

В Фортране и PL/I ключевое слово DO используется для того же самого и называется do-loop ; это отличается от цикла do- while .

ДЛЯ [ править ]

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

Традиционные циклы for [ править ]

Цикл for в таких языках, как ALGOL , Simula , BASIC , Pascal , Modula , Oberon , Ada , MATLAB , OCaml , F# и т. д., требует управляющей переменной с начальными и конечными значениями, которая выглядит примерно так:

for i = first to last do statement
(* or just *)
for i = first..last do statement

В зависимости от языка может использоваться явный знак присваивания вместо знака равенства (а в некоторых языках требуется слово int даже в числовом случае). Также может быть включено необязательное значение шага (приращение или уменьшение ≠ 1), хотя точный синтаксис, используемый для этого, немного различается в разных языках. Некоторые языки требуют отдельного объявления управляющей переменной, некоторые — нет.

Другая форма была популяризирована C. языком Для этого требуется 3 части: инициализация ( вариант цикла ), условие и переход к следующей итерации. Все эти три части являются необязательными. ^[2] Этот тип «циклов с точкой с запятой» пришел из языка программирования B и первоначально был изобретен Стивеном Джонсоном . ^[3]

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

Вот пример традиционного цикла for в стиле C в Java .

// Prints the numbers from 0 to 99 (and not 100), each followed by a space.

for (int i=0; i<100; i++)
{
    System.out.print(i);
    System.out.print(' ');
}
System.out.println();

Эти циклы также иногда называют числовыми циклами for в отличие от циклов foreach (см. ниже).

Циклы for на основе итератора [ править ]

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

for item in some_iterable_object:
    do_something()
    do_something_else()

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

Векторизованные циклы for [ править ]

Некоторые языки предлагают цикл for, который действует так, как будто все итерации обрабатываются параллельно , например for all ключевое слово в Фортране 95 , которое интерпретируется так, что все выражения в правой части вычисляются до того, как будут сделаны какие-либо присваивания, в отличие от явной формы итерации. Например, в for в следующем фрагменте псевдокода при вычислении нового значения для A(i), кроме первого (с i = 2) ссылка на A(i - 1) получит новое значение, которое было помещено туда на предыдущем шаге. В for all версии, однако каждый расчет относится только к исходной, неизмененной A.

for     i := 2 : N - 1 do A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3; next i;
for all i := 2 : N - 1 do A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3;

Разница может быть существенной.

Некоторые языки (например, PL/I, Fortran 95) также предлагают операторы присваивания массивов, которые позволяют опустить многие циклы for. Таким образом, псевдокод, такой как A := 0; обнулил бы все элементы массива A, независимо от его размера или размерности. Пример цикла можно отобразить как

 A(2 : N - 1) := [A(1 : N - 2) + A(2 : N - 1) + A(3 : N)] / 3;

Но будет ли это отображаться в стиле цикла for, цикла for all или чего-то еще, в руководстве компилятора не может быть четко описано.

Составные циклы for [ править ]

Введенный в АЛГОЛ 68 и сопровождаемый PL/I, он позволяет совмещать итерацию цикла с тестом, как в

for i := 1 : N while A(i) > 0 do etc.

присваивается значение То есть переменной цикла i , и только если выражение while истинно , тело цикла будет выполнено. Если результат был ложным, выполнение цикла for прекращается. Учитывая, что значение переменной цикла определяется после завершения цикла, тогда приведенный выше оператор найдет первый неположительный элемент в массиве A (а если такового нет, его значение будет N + 1 ), или, с подходящими вариациями , первый непустой символ в строке и т. д.

Счетчики циклов [ править ]

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

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

Общее соглашение об именовании идентификаторов заключается в том, что счетчик цикла использует имена переменных i , j и k (и так далее, если необходимо), где i будет самым внешним циклом, j — следующим внутренним циклом и т. д. Обратный порядок: также используется некоторыми программистами. Принято считать, что этот стиль возник на ранних этапах программирования на Фортране. ^{[ нужна ссылка ]}, где имена переменных, начинающиеся с этих букв, были неявно объявлены как имеющие целочисленный тип, и поэтому были очевидным выбором для счетчиков циклов, которые требовались лишь временно. Эта практика восходит к математической записи , где индексами сумм . и умножений часто являются i , j и т. д. Вариантом соглашения является использование дублированных букв для индекса ii , jj и kk , поскольку это упрощает поиск и поиск замена, чем использование одной буквы. ^[4]

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

Пример кода C, включающего вложенные циклы for, где переменными счетчика цикла являются i и j :

for (i = 0; i < 100; i++) {
    for (j = i; j < 10; j++) {
        some_function(i, j);
    }
}

Циклы For в C также можно использовать для печати обратной стороны слова. Как:

for (i = 0; i < 6; i++) {
    scanf("%c", &a[i]);
}
for (i = 4; i >= 0; i--) {
    printf("%c", a[i]);
}

Здесь, если вход apple, результат будет elppa.

Дополнительная семантика и конструкции [ править ]

Использовать как бесконечные циклы [ править ]

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

for (;;)
    //loop body

Этот стиль используется вместо бесконечного while (1) циклы, чтобы избежать предупреждения о преобразовании типа в некоторых компиляторах C/C++. ^[5] Некоторые программисты предпочитают более краткие for (;;) форма вместо семантически эквивалентного, но более многословного while (true) форма.

Ранний продолжение и выход

Некоторые языки также могут предоставлять другие вспомогательные операторы, которые, если они присутствуют, могут изменить ход итерации цикла for. Распространенными среди них являются операторы разрыва и продолжения , встречающиеся в языке C и его производных. Оператор Break приводит к немедленному завершению самого внутреннего цикла при его выполнении. Оператор continue сразу перейдет к следующей итерации без дальнейшего продвижения по телу цикла для текущей итерации. Оператор for также завершается, когда в теле оператора выполняется оператор Break, Goto или Return. [Wells] Другие языки могут иметь аналогичные операторы или иным образом предоставлять средства для изменения хода цикла for; например в Фортране 95:

DO I = 1, N
  statements               !Executed for all values of "I", up to a disaster if any.
  IF (no good) CYCLE       !Skip this value of "I", continue with the next.
  statements               !Executed only where goodness prevails.
  IF (disaster) EXIT       !Abandon the loop.
  statements               !While good and, no disaster.
END DO                     !Should align with the "DO".

Некоторые языки предлагают дополнительные возможности, такие как присвоение имен различным операторам цикла, чтобы при наличии нескольких вложенных циклов не было сомнений в том, какой цикл задействован. Фортран 95, например:

X1:DO I = 1,N
     statements
  X2:DO J = 1,M
       statements
       IF (trouble) CYCLE X1
       statements
     END DO X2
     statements
   END DO X1

Таким образом, когда во внутреннем цикле обнаруживается «проблема», CYCLE X1 (не X2) означает, что переход будет к следующей итерации для I, а не J. Компилятор также будет проверять, что каждый END DO имеет соответствующую метку. за свою позицию: это не просто документальное пособие. Программист все равно должен правильно закодировать задачу, но некоторые возможные ошибки будут заблокированы.

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

Разные языки определяют разные правила относительно того, какое значение будет хранить переменная цикла после завершения цикла, и действительно, некоторые считают, что она «становится неопределенной». Это позволяет компилятору генерировать код, который оставляет любое значение в переменной цикла или, возможно, даже оставляет его неизменным, поскольку значение цикла хранится в регистре и никогда не сохраняется в памяти. Реальное поведение может даже варьироваться в зависимости от настроек оптимизации компилятора, как в случае с компилятором Honywell Fortran66.

В некоторых языках (кроме C или C++ ) переменная цикла является неизменяемой в пределах тела цикла, и любая попытка изменить ее значение рассматривается как семантическая ошибка. Такие модификации иногда являются следствием ошибки программиста, которую бывает очень сложно идентифицировать. Однако компилятор, скорее всего, обнаружит только явные изменения. Ситуации, когда адрес переменной цикла передается в качестве аргумента подпрограмме, очень затрудняют проверку, поскольку поведение подпрограммы обычно неизвестно компилятору. Несколько примеров в стиле Фортрана:

DO I = 1, N
  I = 7                           !Overt adjustment of the loop variable. Compiler complaint likely.
  Z = ADJUST(I)                   !Function "ADJUST" might alter "I", to uncertain effect.
  normal statements               !Memory might fade that "I" is the loop variable.
  PRINT (A(I), B(I), I = 1, N, 2) !Implicit for-loop to print odd elements of arrays A and B, reusing "I"...
  PRINT I                         !What value will be presented?
END DO                            !How many times will the loop be executed?

Распространенный подход заключается в вычислении количества итераций в начале цикла (с особым вниманием к переполнению, как в for i := 0 : 65535 do ... ; в шестнадцатибитной целочисленной арифметике) и с каждой итерацией уменьшать этот счетчик, одновременно корректируя значение Я : Результаты двойного подсчета. Однако корректировки стоимости Я внутри цикла не буду менять количество выполненных итераций.

Еще одна возможность заключается в том, что сгенерированный код может использовать вспомогательную переменную в качестве переменной цикла, возможно, хранящуюся в машинном регистре, значение которого может быть скопировано или не скопировано в него. Я на каждой итерации. И снова модификации Я бы не затрагивал управление циклом, но сейчас возможна дизъюнкция: внутри цикла ссылки на значение Я мог бы получить (возможно, измененное) текущее значение I или вспомогательной переменной (защищенной от неправильной модификации), и запутанные результаты гарантированы. Например, внутри цикла ссылка на элемент Для массива, скорее всего, использовалась бы вспомогательная переменная (особенно если бы она хранилась в машинном регистре), но если I является параметром некоторой процедуры (например, оператора печати , раскрывающего его значение), скорее всего, это будет ссылка на соответствующую переменную. Я вместо этого. Лучше всего избегать таких возможностей.

Корректировка границ [ править ]

Точно так же, как индексная переменная может быть изменена в цикле for, также могут быть изменены ее границы и направление. Но с неопределенным эффектом. Компилятор может предотвратить такие попытки, они могут не иметь никакого эффекта или даже работать должным образом - хотя многие заявляют, что это было бы неправильно. Рассмотрим такое утверждение, как

for i := first : last : step do
  A(i) := A(i) / A(last);

Если бы подход к составлению такого цикла заключался в оценке первый , последний и шаг и вычисление количества итераций с помощью чего-то вроде (last - first)/step только один раз в начале, то если бы эти элементы были простыми переменными и их значения каким-то образом корректировались во время итераций, это не повлияло бы на количество итераций, даже если элемент, выбранный для деления на A(last) измененный.

Список диапазонов значений [ править ]

PL/I и ALGOL 68 допускают циклы, в которых переменная цикла повторяется по списку диапазонов значений вместо одного диапазона. Следующий пример PL/I выполнит цикл с шестью значениями i: 1, 7, 12, 13, 14, 15:

do i = 1, 7, 12 to 15;
  /*statements*/
end;

Эквивалентность с циклами while [ править ]

Цикл for обычно эквивалентен циклу while:

factorial := 1
 for counter from 2 to 5
     factorial := factorial * counter
counter := counter - 1
print counter + "! equals " + factorial

эквивалентно:

factorial := 1
counter := 1
 while counter < 5
    counter := counter + 1
    factorial := factorial * counter
print counter + "! equals " + factorial

как показано на выходе переменных.

Хронология синтаксиса цикла for в различных языках программирования [ править ]

Если действие необходимо повторить, например, пять раз, циклы for в разных языках будут записываться по-разному. Синтаксис цикла for из трех выражений практически идентичен во всех языках, в которых он есть, с учетом разных стилей завершения блока и так далее.

1957: ФОРТРАН [ править ]

Фортрановый эквивалент for - это цикл цикл ДЕЛАТЬ , используя ключевое слово do вместо for, Синтаксис Фортрана DO Цикл — это:

        DO label counter = first, last, step
          statements
label     statement

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

        DO 9, COUNTER = 1, 5, 1
          WRITE (6,8) COUNTER
    8     FORMAT( I2 )
    9   CONTINUE

В Фортране 77 (или более поздних версиях) это также может быть записано как:

do counter = 1, 5
  write(*, '(i2)') counter
end do

Шаговая часть может быть опущена, если шаг один. Пример:

* DO loop example.
       PROGRAM MAIN
         SUM SQ = 0
         DO 199 I = 1, 9999999
           IF (SUM SQ.GT.1000) GO TO 200
199        SUM SQ = SUM SQ + I**2
200      PRINT 206, SUMSQ
206      FORMAT( I2 )
       END

Пробелы не имеют значения в операторах Фортрана фиксированной формы, поэтому SUM SQ то же самое, что и СУМСК . В современном стиле Фортрана свободной формы пробелы имеют большое значение.

В Фортране 90 GO TO можно избежать, используя Оператор EXIT .

* DO loop example.
       program main
         implicit none

         integer :: sumsq
         integer :: i

         sumsq = 0
         do i = 1, 9999999
           if (sumsq > 1000.0) exit
           sumsq = sumsq + i**2
          end do
         print *, sumsq

       end program

1958: АЛГОЛ [ править ]

Алгол 58 представил for заявление, используя форму Суперплана:

 FOR Identifier = Base (Difference) Limit

Например, чтобы напечатать от 0 до 10 с приращением 1:

FOR x = 0 (1) 10 BEGIN
PRINT (FL) = x END

1960: КОБОЛ [ править ]

COBOL был формализован в конце 1959 года и претерпел множество усовершенствований. Он использует глагол PERFORM, который имеет множество вариантов. Первоначально все циклы должны были находиться вне строки, а итерируемый код занимал отдельный параграф. Игнорируя необходимость объявления и инициализации переменных, COBOL-эквивалент цикла for будет таким.

      PERFORM SQ-ROUTINE VARYING I FROM 1 BY 1 UNTIL I > 1000

      SQ-ROUTINE
             ADD I**2 TO SUM-SQ.

В 1980-х годах добавление встроенных циклов и операторов структурированного программирования, таких как END-PERFORM, привело к появлению цикла for с более знакомой структурой.

      PERFORM VARYING I FROM 1 BY 1 UNTIL I > 1000
             ADD I**2 TO SUM-SQ.
      END-PERFORM

Если глагол PERFORM имеет необязательное предложение TEST AFTER, результирующий цикл немного отличается: тело цикла выполняется как минимум один раз перед любым тестом.

1964: БЕЙСИК [ править ]

В BASIC цикл иногда называют циклом for-next .

10 REM THIS FOR LOOP PRINTS ODD NUMBERS FROM 1 TO 15
20 FOR I = 1 TO 15 STEP 2
30 PRINT I
40 NEXT I

Маркер конца цикла указывает имя индексной переменной, которое должно соответствовать имени индексной переменной в начале цикла for. Некоторые языки (PL/I, Fortran 95 и более поздние версии) допускают метку оператора в начале цикла for, которую компилятор может сопоставить с тем же текстом в соответствующем операторе конца цикла. Фортран также позволяет EXIT и CYCLE утверждения, чтобы назвать этот текст; в множестве циклов это дает понять, какой цикл предназначен. Однако в этих языках метки должны быть уникальными, поэтому последовательные циклы, включающие одну и ту же индексную переменную, не могут использовать один и тот же текст, а метка не может совпадать с именем переменной, например индексной переменной для цикла.

1964: PL/I [ править ]

do counter = 1 to 5 by 1; /* "by 1" is the default if not specified */
  /*statements*/;
  end;

The Оператор LEAVE может использоваться для выхода из цикла. Циклы могут быть помечены , а отпуск может оставить определенный помеченный цикл в группе вложенных циклов. Некоторые диалекты PL/I включают Оператор ITERATE для завершения текущей итерации цикла и начала следующей.

1968: АЛГОЛ 68 [ править ]

В АЛГОЛе 68 есть то, что считалось универсальным циклом, полный синтаксис:

FOR i FROM 1 BY 2 TO 3 WHILE i≠4 DO ~ OD

Кроме того, единый диапазон итераций можно заменить списком таких диапазонов. Есть несколько необычных аспектов конструкции.

только do ~ od часть была обязательной, и в этом случае цикл будет повторяться бесконечно.
таким образом, пункт to 100 do ~ od, выполнится ровно 100 раз.
тот while синтаксический элемент позволял программисту оторваться от for цикл раньше, например:

INT sum sq := 0;
FOR i
 WHILE
  print(("So far:", i, new line)); # Interposed for tracing purposes. #
  sum sq ≠ 70↑2                    # This is the test for the WHILE   #
DO
  sum sq +:= i↑2
OD

Последующие расширения стандарта АЛГОЛ 68 позволили to синтаксический элемент, который необходимо заменить на upto и downto добиться небольшой оптимизации. Те же компиляторы также включили:

until: для позднего завершения цикла.
foreach: работы с массивами для параллельной .

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

for Counter := 1 to 5 do
  (*statement*);

Уменьшение (отсчет в обратном направлении) осуществляется с помощью downto ключевое слово вместо to, как в:

for Counter := 5 downto 1 do
  (*statement*);

Числовой диапазон цикла for варьируется несколько сильнее.

1972: C, C++ [ править ]

for (initialization; condition; increment/decrement)
    statement

The оператор часто является оператором блока; примером этого может быть:

//Using for-loops to add numbers 1 - 5
int sum = 0;
for (int i = 1; i <= 5; ++i) {
    sum += i;
}

Публикация ISO/IEC 9899:1999 (широко известная как C99 ) также допускает первоначальные объявления в for петли. Все три раздела цикла for являются необязательными, а пустое условие эквивалентно true.

1972: Smalltalk [ править ]

1 to: 5 do: [ :counter | "statements" ]

В отличие от других языков, в Smalltalk цикл for не является языковой конструкцией , а определен в классе Number как метод с двумя параметрами: конечным значением и замыканием , использующим self в качестве начального значения.

1980: Там [ править ]

for Counter in 1 .. 5 loop
   -- statements
end loop;

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

Counting:
    for Counter in 1 .. 5 loop
   Triangle:
       for Secondary_Index in 2 .. Counter loop
          -- statements
          exit Counting;
          -- statements
       end loop Triangle;
    end loop Counting;

1980: Клен [ править ]

В Maple есть две формы цикла for: одна для перебора диапазона значений, а другая — для перебора содержимого контейнера. Форма диапазона значений следующая:

for i from f by b to t while w do
    # loop body
od;

Все части, кроме do и od являются необязательными. for i часть, если она присутствует, должна быть первой. Остальные части( from f, by b, to t, while w) могут появляться в любом порядке.

Перебор контейнера выполняется с использованием следующей формы цикла:

for e in c while w do
    # loop body
od;

The in c Предложение определяет контейнер, который может быть списком, набором, суммой, продуктом, невычисляемой функцией, массивом или объектом, реализующим итератор.

Цикл for может быть завершен командой od, end, или end do.

: CAS Максима 1982

В Maxima CAS можно использовать и нецелые значения:

for x:0.5 step 0.1 thru 0.9 do
    /* "Do something with x" */

1982: Постскриптум [ править ]

Цикл for, записанный как [initial] [increment] [limit] { ... } for инициализирует внутреннюю переменную, выполняет тело, пока внутренняя переменная не превышает предел (или не меньше, если приращение отрицательное), и в конце каждой итерации увеличивает внутреннюю переменную. Перед каждой итерацией значение внутренней переменной помещается в стек. ^[6]

1 1 6 {STATEMENTS} for

Существует также простой цикл повторения. Повторяющийся цикл, записанный как X { ... } repeat, повторяет тело ровно X раз. ^[7]

5 { STATEMENTS } repeat

: Ада 83 выше и 1983

procedure Main is
  Sum_Sq : Integer := 0;
begin
  for I in 1 .. 9999999 loop
    if Sum_Sq <= 1000 then
      Sum_Sq := Sum_Sq + I**2
    end if;
  end loop;
end;

1984: МАТЛАБ [ править ]

for n = 1:5
     -- statements
end

После цикла, n в этом примере будет 5.

Как i используется для мнимой единицы , ее использование в качестве переменной цикла не рекомендуется.

1987: Перл [ править ]

for ($counter = 1; $counter <= 5; $counter++) { # implicitly or predefined variable
    # statements;
}
for (my $counter = 1; $counter <= 5; $counter++) { # variable private to the loop
    # statements;
}
for (1..5) { # variable implicitly called $_; 1..5 creates a list of these 5 elements
    # statements;
}
statement for 1..5; # almost same (only 1 statement) with natural language order
for my $counter (1..5) { # variable private to the loop
    # statements;
}

« Есть несколько способов сделать это » — девиз программирования на Perl.

: Математика 1988

Конструкция, соответствующая циклу for в большинстве других языков, называется Do. в системе Mathematica

Do[f[x], {x, 0, 1, 0.1}]

В Mathematica также есть конструкция For, имитирующая цикл for в C-подобных языках.

For[x= 0 , x <= 1, x += 0.1,
    f[x]
]

1989: Баш [ править ]

# first form
for i in 1 2 3 4 5
do
    # must have at least one command in loop
    echo $i  # just print value of i
done

# second form
for (( i = 1; i <= 5; i++ ))
do
    # must have at least one command in loop
    echo $i  # just print value of i
done

Пустой цикл (т. е. цикл без команд между do и done) является синтаксической ошибкой. Если бы приведенные выше циклы содержали только комментарии, выполнение привело бы к сообщению «синтаксическая ошибка рядом с неожиданным токеном «готово»».

1990: Хаскелл [ править ]

Встроенный императив forM_ отображает монадическое выражение в список, как

forM_ [1..5] $ \indx -> do statements

или получить результат каждой итерации в виде списка в

statements_result_list <- forM [1..5] $ \indx -> do statements

Но чтобы сэкономить место в списке [1..5], более аутентичную монадическую конструкцию forLoop_ можно определить как

import Control.Monad as M

forLoopM_ :: Monad m => a -> (a -> Bool) -> (a -> a) -> (a -> m ()) -> m ()
forLoopM_ indx prop incr f = do
        f indx
        M.when (prop next) $ forLoopM_ next prop incr f
  where
    next = incr indx

и используется как:

  forLoopM_ (0::Int) (< len) (+1) $ \indx -> do -- whatever with the index

: Оберон-2, Оберон-07, Компонентный Паскаль 1991

FOR Counter := 1 TO 5 DO
  (* statement sequence *)
END

В исходном языке Оберона цикл for был опущен в пользу более общей конструкции цикла Оберон. Цикл for был вновь введен в Оберон-2.

1991: Питон [ править ]

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

for i in range(1, 6):  # gives i values from 1 to 5 inclusive (but not 6)
    # statements
    print(i)
# if we want 6 we must do the following
for i in range(1, 6 + 1):  # gives i values from 1 to 6
    # statements
    print(i)

С использованием range(6) будет запускать цикл от 0 до 5.

1993: AppleScript [ править ]

repeat with i from 1 to 5
	-- statements
	log i
end repeat

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

set x to {1, "waffles", "bacon", 5.1, false}
repeat with i in x
	log i
end repeat

А exit repeat также может использоваться для выхода из цикла в любой момент. В отличие от других языков, в AppleScript в настоящее время нет команды для перехода к следующей итерации цикла.

1993: Кристалл [ править ]

for i = start, stop, interval do
  -- statements
end

Итак, этот код

for i = 1, 5, 2 do
  print(i)
end

напечатает:

1 3 5

Циклы for также могут проходить по таблице, используя

ipairs()

численно перебирать массивы и

pairs()

для случайного перебора словарей.

Общий цикл for, использующий замыкания:

for name, phone, address in contacts() do
  -- contacts() must be an iterator function
end

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

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

Простой индексный цикл:

for (i = 1; i <= 5; i++) {
	// statements
}

Использование массива:

for (i in [1,2,3,4,5]) {
	// statements
}

Использование списка строковых значений:

loop index="i" list="1;2,3;4,5" delimiters=",;" {
	// statements
}

Выше list Пример доступен только на диалекте CFML, используемом Люси и Райло .

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