Для цикла

редактировать
оператор потока управления Для диаграммы потока цикла

В информатике, a for-loop (или просто для цикла ) - это поток управления оператор для указания итерации, что позволяет коду быть повторно выполнил. Для указания этого оператора используются различные ключевые слова: потомки АЛГОЛА используют «for», а потомки Fortran используют «do». Существуют и другие возможности, например COBOL, в котором используется "ВЫПОЛНЯТЬ ИЗМЕНЕНИЕ".

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

Название цикла происходит от английского слова for, которое используется в качестве ключевого слова во многих языках программирования для введения цикла for. Термин на английском языке восходит к АЛГОЛу 58 и был популяризирован в влиятельном более позднем АЛГОЛЕ 60 ; это прямой перевод более раннего немецкого für, использованного в Superplan (1949–1951) Хайнцем Рутисхаузером, который также был участвует в определении АЛГОЛА 58 и АЛГОЛА 60. Тело цикла выполняется «для» заданных значений переменной цикла, хотя это более явно указано в версии оператора АЛГОЛ, в котором список возможных могут быть указаны значения и / или приращения.

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

Содержание

  • 1 FOR
    • 1.1 Традиционные циклы for
    • 1.2 Циклы for на основе итератора
    • 1.3 Векторизованные циклы for
    • 1.4 Составные циклы for
  • 2 Счетчики циклов
    • 2.1 Пример
  • 3 Дополнительная семантика и конструкции
    • 3.1 Использование в качестве бесконечных циклов
    • 3.2 Ранний выход и продолжение
    • 3.3 Объем и семантика переменной цикла
      • 3.3.1 Регулировка границ
    • 3.4 Список диапазонов значений
  • 4 Эквивалентность с циклами while
    • 4.1 Теоретически
    • 4.2 На практике
  • 5 Временная шкала синтаксиса цикла for в различных языки программирования
    • 5.1 1957: FORTRAN
    • 5.2 1958: Algol
    • 5.3 1960: COBOL
    • 5.4 1964: BASIC
    • 5.5 1964: PL / I
    • 5.6 1968: Algol 68
    • 5.7 1970: Pascal
    • 5.8 1972: C / C ++
    • 5.9 1972: Smalltalk
    • 5.10 1980: Ada
    • 5.11 1980: Maple
    • 5.12 1982: Maxima CAS
    • 5.13 1982: PostScript
    • 5.14 1983: Ada 83 и выше
    • 5.15 1984: MATLAB
    • 5.16 1987: Perl
    • 5.17 1988: Mathematica
    • 5.18 1989: Bash
    • 5.19 1990: Haskell
    • 5.20 1991: Оберон-2, Оберон-07 или Component Pascal
    • 5.21 1991: Python
    • 5.22 1993: AppleScript
    • 5.23 1993: Lua
    • 5.24 1995: CFML
      • 5.24.1 Синтаксис скрипта
      • 5.24.2 Синтаксис тега
    • 5.25 1995: Java
    • 5.26 1995: JavaScript
    • 5.27 1995: PHP
    • 5.28 1995: Ruby
    • 5.29 1996: OCaml
    • 5.30 1998 : ActionScript 3
    • 5.31 2008: Small Basic
    • 5.32 2010: Rust
    • 5.33 2012: Julia
  • 6 Реализация в интерпретируемых языках программирования
  • 7 См. Также
  • 8 Ссылки

FOR

Для иллюстрации цикла от i = 0 до i = 2, в результате получается data1 = 200

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

Традиционные циклы for

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

для i = от первого до последнего оператора do (* или просто *) для i = first..last do statement

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

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

Инициализация объявляет ( и, возможно, присваивает) любые необходимые переменные. Тип переменной должен быть таким же, если вы используете несколько переменных в части инициализации. Условие проверяет условие и выходит из цикла, если оно ложно. Задержка выполняется ровно один раз каждый раз, когда цикл заканчивается, а затем повторяется.

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

// Выводит числа от 0 до 99 (а не 100), за каждым из которых следует пробел. for (int i = 0; i <100; i++) { System.out.print(i); System.out.print(' '); } System.out.println();

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

Итератор -based for-loops

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

для элемента в some_iterable_object: do_something () do_something_else ()

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

Векторизованные циклы for

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

для i: = 2: N - 1 do A (i): = [А (я - 1) + А (я) + А (я + 1)] / 3; следующий i; для всех i: = 2: N - 1 do A (i): = [A (i - 1) + A (i) + A (i + 1)] / 3;

Разница может быть значительной.

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

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

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

Составные циклы

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

для i: = 1: N, в то время как A (i)>0 выполнить и т. д.

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

.

Счетчики циклов

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

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

Общее соглашение об именах идентификаторов заключается в том, что счетчик цикла использует имена переменных i, jи k (и т. Д., Если необходимо), где i будет самым внешним циклом, j следующим внутренним циклом и т. д. Некоторые программисты также используют обратный порядок. Обычно считается, что этот стиль возник из раннего программирования FORTRAN, где эти имена переменных, начинающиеся с этих букв, были неявно объявлены как имеющие целочисленный тип, и поэтому были очевидным выбором для счетчиков циклов, которые были только временно требуется. Эта практика восходит к математической системе обозначений, где индексы для сумм и умножения часто равны i, jи т. Д. использование повторяющихся букв для индекса, ii, jjи kk, так как это упрощает поиск и замену при поиске, чем использование одной буквы.

Пример

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

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

Было показано, что вложенный Цикл for, как в приведенном выше примере, выполняет больше вычислений в единицу времени, чем цикл без него. Эта машинно-независимая оптимизация означает, что вложенный цикл for завершится быстрее при том же количестве вычислений, которые необходимо выполнить. Это преимущество вложенного цикла for имеет более вложенный цикл while, который ведет себя по-другому.

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

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

Здесь, если вход t is apple, на выходе будет elppa.

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

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

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

for (;;) // тело цикла

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

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

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

DO I = 1, N операторов! Выполняется для всех значений «I», вплоть до аварии, если таковая имеется. ЕСЛИ (не годится) ЦИКЛ! Пропустите это значение «I», перейдите к следующему. Заявления! Исполняются только там, где преобладает добро. ЕСЛИ (катастрофа) ВЫЙТИ! Прекратить цикл. заявления! Пока и хорошо, беды нет. КОНЕЦ ДЕЛАТЬ! Должен совпадать с «ДЕЛАТЬ».

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

X1: DO I = 1, N операторов X2: DO J = 1, M операторов IF (проблема) CYCLE X1 операторов END DO X2 операторов END DO X1

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

Объем и семантика переменной цикла

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

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

DO I = 1, N I = 7! Отклонить настройку переменной цикла. Вероятна жалоба компилятора. Z = ADJUST (I)! Функция «ADJUST» может изменять «I» с неопределенным эффектом. нормальные операторы! Память может исчезнуть из-за того, что «I» - это переменная цикла. PRINT (A (I), B (I), I = 1, N, 2)! Неявный цикл for для печати нечетных элементов массивов A и B, повторно используя «I»... PRINT I! Какое значение будет представлено ? END DO! Сколько раз будет выполняться цикл?

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

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

Регулировка границ

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

для i: = first: last: step do A (i): = A (i) / A (last);

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

Список диапазонов значений

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

do i = 1, 7, 12-15; / * операторы * / end;

Эквивалентность циклам while

Теоретически

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

factorial: = 1 для счетчика от 1 до 5 factorial: = factorial * counter

легко переводится в следующий цикл while :

factorial: = 1 counter: = 1 while counter <= 5 factorial := factorial * counter counter := counter + 1

Этот перевод немного усложняется языками, которые позволяют оператору переходить к следующей итерации цикла (например, оператор «continue» в C). Эти операторы обычно неявно увеличивают счетчик цикла for, но не эквивалентного цикла while (поскольку в последнем случае счетчик не является неотъемлемой частью конструкции цикла). Любой перевод должен будет помещать все такие операторы в блок, который увеличивает явный счетчик перед запуском оператора.

На практике

Формальная эквивалентность применима только постольку, поскольку компьютерная арифметика также следует аксиоме математики, в частности, что x + 1>x. Фактическая компьютерная арифметика страдает от переполнения ограниченных представлений, так что, например, в шестнадцатиразрядной беззнаковой арифметике 65535 + 1 получается как ноль, потому что 65536 не может быть представлен в шестнадцатиразрядной беззнаковой. Подобные проблемы возникают для других размеров, знаковых или беззнаковых, а также для насыщенной арифметики, где 65535 + 1 даст 65535. Авторы компилятора будут обрабатывать подобные для counter: = от 0 до 65535 do... следующий счетчик, возможно, путем создания кода, который проверяет состояние индикатора «переполнения» оборудования, но если не предусмотрено какое-либо положение для эквивалентной проверки после вычисления counter: = counter + 1;the while- эквивалентность цикла не удастся, потому что счетчик никогда не превысит 65535, и поэтому цикл никогда не закончится - если только не произойдет другой несчастный случай.

Временная шкала синтаксиса цикла for в различных языках программирования

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

1957: FORTRAN

Эквивалент цикла for в Фортране - это цикл DO с использованием ключевого слова do вместо for. Синтаксис цикла DO в Фортране: :

DO label counter = first, last, step операторы label statement

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

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

В Fortran 77 (или новее) это также может быть записано как:

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

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

* Пример цикла DO. ГЛАВНАЯ СУММА ПРОГРАММЫ SQ = 0 DO 199 I = 1, 9999999 IF (SUM SQ.GT.1000) ПЕРЕХОДИТЕ К 200199 SUM SQ = SUM SQ + I ** 2 200 PRINT 206, SUMSQ 206 FORMAT (I2) END

Пробелы не имеют значения в операторах Fortran фиксированной формы, поэтому SUM SQ совпадает с SUMSQ. В современном стиле Fortran свободной формы пробелы имеют значение.

В Fortran 90 GO TO можно избежать с помощью оператора EXIT.

* Пример цикла DO. программа основная неявная 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: Algol

Алгол был впервые формализован в отчете Алгол58.

1960: COBOL

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

ВЫПОЛНЯЙТЕ SQ-ROUTINE ИЗМЕНЯЯ I ОТ 1 НА 1 ДО I>1000 SQ-ROUTINE ДОБАВИТЬ I ** 2 К SUM-SQ.

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

ВЫПОЛНЯЙТЕ ИЗМЕНЕНИЕ I ОТ 1 НА 1 ДО I>1000 ДОБАВИТЬ I ** 2 К SUM-SQ. END-PERFORM

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

1964: BASIC

Циклы в BASIC иногда вызываются для следующих циклов.

10 УДАЛИТЬ ЭТО ДЛЯ ПЕЧАТИ ЦИКЛА НЕЧЕТНЫЕ НОМЕРА ОТ 1 ДО 15 20 ДЛЯ I = 1 ДО 15 ШАГ 2 30 ПЕЧАТЬ I 40 ДАЛЕЕ I

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

1964: PL / I

do counter = от 1 до 5 на 1; / * по умолчанию, если не указано иное, "на 1" * / / * операторы * /; конец;

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

1968: Algol 68

Algol68 имеет то, что считалось универсальным циклом, полный синтаксис:

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

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

  • есть несколько необычных аспектов, только часть do ~ odбыла обязательной, и в этом случае цикл будет повторяться бесконечно.
  • таким образом, предложение to 100 выполняет ~ od, будет повторяться ровно 100 раз.
  • синтаксический элемент whileпозволял программисту преждевременно выйти из цикла for, например:
INT сумма sq: = 0; FOR i WHILE print (("Пока:", i, новая строка)); # Вставлен для отслеживания. # sum sq ≠ 70 ↑ 2 # Это тест WHILE # DO sum sq +: = i ↑ 2 OD

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

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

1970: Pascal

for Counter: = от 1 до 5 делать (* оператор *);

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

для счетчика: = 5 вниз до 1 do (* оператор *);

Числовой диапазон для цикла несколько больше.

1972: C / C ++

для оператора (инициализация; условие; увеличение / уменьшение)

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

// Использование циклов for для сложения чисел 1–5 int sum = 0; for (int i = 1; i < 6; ++i) { sum += i; }

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

1972: Smalltalk

1 к: 5 do: [: counter | "statement"]

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

1980: Ada

для счетчика в 1.. 5 цикле - операторы end loop;

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

Счетчик: для счетчика в 1.. 5 цикле Треугольник: для Secondary_Index в 2.. Цикл счетчика - операторы выходят из счетчика; - операторы завершают цикл Треугольник; конец цикла подсчета;

1980: Maple

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

для i из f byb tot в то время как w do# тело цикла od;

Все части, кроме doи od, являются необязательными. Часть для i, если присутствует, должна быть первой. Остальные части (из f, byb, tot, и w) могут появляться в любом порядке.

Итерация по контейнеру выполняется с использованием этой формы цикла:

для e inc while w do# тело цикла od;

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

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

1982: Maxima CAS

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

для x: 0,5 шаг от 0,1 до 0,9 do / * "Сделайте что-нибудь с x" * /

1982: PostScript

The for -loop, записанный как [начальный] [приращение] [предел] {...} дляинициализирует внутреннюю переменную, выполняет тело до тех пор, пока внутренняя переменная не превышает предел (или не меньше, если инкремент отрицательный) и в конце каждой итерации увеличивает внутреннюю переменную. Перед каждой итерацией значение внутренней переменной помещается в стек.

1 1 6 {STATEMENTS} for

Существует также простой цикл повтора. Цикл repeat, записанный как X {...} repeat, повторяет тело ровно X раз.

5 {STATEMENTS} repeat

1983: Ada 83 и выше

procedure Main это Sum_Sq: Integer: = 0; начало для I в 1.. 9999999 цикле, если Sum_Sq <= 1000 then Sum_Sq := Sum_Sq + I**2 end if; end loop; end;

1984: MATLAB

для n = 1: 5 - инструкции end

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

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

1987: Perl

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: Mathematica

Конструкция, соответствующая циклу 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: Bash

# первая форма для i in 1 2 3 4 5 do # должен иметь хотя бы одну команду в цикле echo $ i # просто вывести значение i done
# вторая форма 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) является синтаксической ошибкой. Если указанные выше циклы содержат только комментарии, выполнение приведет к сообщению «синтаксическая ошибка рядом с неожиданным токеном 'done'».

1990: Haskell

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

forM_ [1..5] $ \ indx ->инструкции do

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

списке_результатов_выполнения <- forM [1..5] $ \indx ->операторы do

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

import Control.Monad как 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 где next = incr indx

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

forLoopM_ (0 :: Int) (< len) (+1) $ \indx ->do - - все с индексом

1991: Oberon-2, Oberon-07 или Component Pascal

FOR Counter: = 1 TO 5 DO (* последовательность операторов *) END

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

1991: Python

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

для i в диапазоне (1, 6): # дает i значения от 1 до 5 включительно (но не 6) # операторы print (i) # если мы хотим 6 мы должны сделать следующее для i в диапазоне (1, 6 + 1): # дает i значения от 1 до 6 # операторы print (i)

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

1993: AppleScript

повторять с i от 1 до 5 - журнал операторов i end repeat

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

установить x равным {1, "waffles", "bacon", 5.1, false} повторить с i в x log i end repeat

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

1993: Lua

для i = start, stop, interval do - statement end

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

для i = 1, 5, 2 do print (i) end

напечатает:

1 3 5

Циклы For также могут выполнять цикл по таблице, используя

ipairs ()

для числовой итерации по массивам и

пар ()

для итерации случайно через словари.

Общий цикл for с использованием замыканий :

для имени, телефона, адреса в contacts () do - contacts () должен быть итератором end

1995: CFML

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

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

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

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

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

Using a list of string values:

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

The above listexample is only available in the dialect of CFML used by Lucee and Railo.

Tag syntax

Simple index loop:

Using an array:

Using a "list" of string values:

1995: Java

for (int i = 0; i < 5; i++) { //perform functions within the loop; //can use the statement 'break;' to exit early; //can use the statement 'continue;' to skip the current iteration }

For the extended for-loop, see Foreach loop

1995: JavaScript

JavaScript supports C-style "three-expression" loops. The breakand continuestatements are supported inside loops.

for (var i = 0; i < 5; i++) { //... }

Alternatively, it is possible to iterate over all keys of an array.

for (var ke y in array) { // also works for assoc. arrays // use array[key]... }

1995: PHP

This prints out a triangle of *

for ($i = 0; $i <= 5; $i++) { for ($j = 0; $j <= $i; $j++) { echo "*"; } echo " "; }

1995: Ruby

for counter in 1..5 # statements end 5.times do |counter| # counter iterates from 0 to 4 # statements end 1.upto(5) do |counter| # statements end

Ruby has several possible syntaxes, including the above samples.

1996: OCaml

See expression syntax.

(* for_statement := "for" ident '=' expr ( "to" ∣ "downto") expr "do" expr "done" *) for i = 1 to 5 do (* statements *) done ;; for j = 5 downto 0 do (* statements *) done ;;

1998: ActionScript 3

for (var counter:uint = 1; counter <= 5; counter++){ //statement; }

2008: Small Basic

For i = 1 To 10 ' Statements EndFor

2010: Rust

for i in 0..10 { // statements }

2012: Julia

for j = 1:10 # statements end

Implementation in interpreted programming languages

In interpreted programming languages, for-loops can be implemented in many ways. Oftentimes, the for-loops are directly translated to assembly -like compare instructions and conditional jump instructions. However, this is not always so. In some interpreted programming languages, for-loops are simply translated to while-loops. For instance, take the following Mint/Horchata code:

for i = 0; i < 100; i++ print i end for each item of sequence print item end /* 'Translated traditional for-loop' */ i = 0 while i < 100 print i i++ end /* 'Translated for each loop' */ SYSTEM_VAR_0000 = 0 while SYSTEM_VAR_0000 < sequence.length() item = sequence[SYSTEM_VAR_0000] print item SYSTEM_VAR_0000++ end

See also

References

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