Для цикла - For loop

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

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

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

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

В FORTRAN и PL / I, ключевое слово ДЕЛАТЬ используется для того же и называется петля; это отличается от цикл do-while.

ДЛЯ

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

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

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

Цикл for таких языков, как АЛГОЛ, Симула, БАЗОВЫЙ, Паскаль, Modula, Оберон, Ада, Matlab, Ocaml, F # и так далее, требуется управляющая переменная с начальным и конечным значениями и выглядит примерно так:

за я = первый к последний делать заявление(* или просто *)за я = первый..последний делать заявление

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

Другая форма была популяризирована Язык программирования C. Требуется 3 части: инициализация, то условие, а запоздалая мысль и все эти три части необязательны.[1] Этот тип "петель с запятой" пришел из Язык программирования B и изначально он был изобретен Стивен Джонсон.[2]

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

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

// Печатает числа от 0 до 99 (а не 100), за каждым из которых следует пробел.за (int я=0; я<100; я++)  {    Система.вне.Распечатать(я);    Система.вне.Распечатать(' ');}Система.вне.println();

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

Циклы for на основе итераторов

Основная статья: Цикл Foreach

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

за предмет в some_iterable_object:    сделай что-нибудь()    do_something_else()

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

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

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

за     я: = 2: N - 1 делать А (я): = [А (я - 1) + А (я) + А (я + 1)] / 3; Следующий я;для всех я: = 2: N - 1 делать А (я): = [А (я - 1) + А (я) + А (я + 1)] / 3;

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

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

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

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

Соединение для петель

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

для i: = 1: N, а A (i)> 0 делаем и т.п.

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


Счетчики петель

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

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

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

пример

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

за (я = 0; я < 100; я++) {    за (j = я; j < 10; j++) {        some_function(я, j);    }}

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

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

за (я = 0; я < 6; я++) {    сканф("% c", &а[я]);}за (я = 4; я >= 0; я--) {    printf("% c", а[я]);}

Здесь, если на входе яблоко, вывод будет Elppa.

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

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

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

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

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

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

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

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

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

X1:ДЕЛАТЬ я = 1,N     заявления  X2:ДЕЛАТЬ J = 1,M       заявления       ЕСЛИ (беда) ЦИКЛ X1       заявления     КОНЕЦ ДЕЛАТЬ X2     заявления   КОНЕЦ ДЕЛАТЬ X1

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

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

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

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

ДЕЛАТЬ я = 1, N  я = 7                           ! Отклонить регулировку переменной цикла. Вероятна жалоба компилятора.  Z = РЕГУЛИРОВАТЬ(я)                   ! Функция «ADJUST» может изменить «I» с неопределенным эффектом.  нормальный заявления               ! Память может исчезнуть из-за того, что «I» - это переменная цикла.  РАСПЕЧАТАТЬ (А(я), B(я), я = 1, N, 2) ! Неявный цикл for для печати нечетных элементов массивов A и B с повторным использованием "I" ...  РАСПЕЧАТАТЬ я                         ! Какая ценность будет представлена?КОНЕЦ ДЕЛАТЬ                            ! Сколько раз будет выполняться цикл?

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

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

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

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

за i: = first: last: step делать  A (i): = A (i) / A (последний);

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

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

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

делатья=1,7,12к15;/*заявления*/конец;

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

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

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

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

факториал: = 1 счетчик: = 1 пока счетчик <= 5 факториал: = факториал * счетчик счетчика: = счетчик + 1

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

Хронология for-loop синтаксис на разных языках программирования

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

1957: Фортран

Эквивалент Fortran за петля ДЕЛАТЬ цикл, используя ключевое слово do вместо for. Синтаксис Фортрана ДЕЛАТЬ цикл:

   ДЕЛАТЬ метка счетчик = первый, последний, шаг     заявленияметка     заявление

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

   ДЕЛАТЬ 9, ПРИЛАВОК = 1, 5, 1     ЗАПИСЫВАТЬ (6,8) ПРИЛАВОК    8     ФОРМАТ( I2 )    9   ПРОДОЛЖИТЬ

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

делать счетчик = 1, 5  записывать(*, '(i2)') счетчикконец делать

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

* Пример цикла DO.  ПРОГРАММА ОСНОВНОЙ    СУММ SQ = 0    ДЕЛАТЬ 199 я = 1, 9999999      ЕСЛИ (СУММ SQ.GT.1000) ИДТИ К 200199        СУММ SQ = СУММ SQ + я**2200      РАСПЕЧАТАТЬ 206, СУММК206      ФОРМАТ( I2 )  КОНЕЦ

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

В Fortran 90 ИДТИ К можно избежать, используя ВЫХОД заявление.

* Пример цикла DO.  программа основной    неявный нет    целое число :: сумма    целое число :: я    сумма = 0    делать я = 1, 9999999      если (сумма > 1000.0) выход      сумма = сумма + я**2     конец делать    Распечатать *, сумма  конец программы

1958: Алгол

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

1960: КОБОЛ

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

ВЫПОЛНЯТЬ SQ-ROUTINE РАЗЛИЧНЫЕ я ИЗ 1 ОТ 1 ДО ТОГО КАК я > 1000SQ-ROUTINE       ДОБАВИТЬ я**2 К SUM-SQ.

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

ВЫПОЛНЯТЬ РАЗЛИЧНЫЕ я ИЗ 1 ОТ 1 ДО ТОГО КАК я > 1000ДОБАВИТЬ я**2 К SUM-SQ.КОНЕЦ ВЫПОЛНЕНИЯ

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

1964: ОСНОВНОЙ

Петли в БАЗОВЫЙ иногда вызываются для следующих циклов.

10ЗАПОМНИТЕ ЭТО ДЛЯ ПЕЧАТИ ПЕТЛИ НЕЧЕТНЫМИ НОМЕРАМИ ОТ 1 ДО 1520ДЛЯя=1К15ШАГ230РАСПЕЧАТАТЬя40СЛЕДУЮЩИЙя

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

1964: PL / I

делатьсчетчик=1к5к1;/ * "на 1" по умолчанию, если не указано * //*заявления*/;конец;

В ПОКИНУТЬ оператор может использоваться для выхода из цикла. Петли могут быть помечены, и уехать может оставить конкретный помеченный цикл в группе вложенных циклов. Некоторые диалекты PL / I включают ИТЕРАЦИЯ оператор, чтобы завершить текущую итерацию цикла и начать следующую.

1968: Алгол 68

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

ДЛЯ i ОТ 1 НА 2 ДО 3, ПОКА i 4 DO ~ OD

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

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

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

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

1970: Паскаль

за Счетчик := 1 к 5 делать  (*утверждение*);

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

за Счетчик := 5 вниз 1 делать  (*утверждение*);

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

1972: C / C ++

Дальнейшая информация: Синтаксис C § Операторы итерации
за (инициализация; условие; приращение/декремент)    заявление

В заявление часто является блок-оператором; пример этого:

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

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

1972: Smalltalk

1 кому: 5 делать: [ :счетчик | "заявления" ]

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

1980: Ада

за Счетчик в 1 .. 5 петля   -- заявленияконец петля;

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

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

1980: Клен

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

за я из ж к б к т пока ш делать    # тело циклаod;

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

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

за е в c пока ш делать    # тело циклаod;

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

Цикл for может быть прерван od, конец, или же конец делать.

1982: Maxima CAS

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

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

1982: PostScript

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

1 1 6 {ЗАЯВЛЕНИЯ} за

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

5 { ЗАЯВЛЕНИЯ } повторение

1983: Ada 83 и выше

процедура Главный является  Sum_Sq : Целое число := 0;начинать  за я в 1 .. 9999999 петля     если Sum_Sq <= 1000 тогда      Sum_Sq := Sum_Sq + я**2    конец если;  конец петля;конец;

1984: MATLAB

за п = 1:5      -- заявленияконец

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

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

1987: Perl

за ($ counter = 1; $ counter <= 5; $ counter++) { # неявно или предопределенная переменная    # заявления;}за (мой $ counter = 1; $ counter <= 5; $ counter++) { # переменная, закрытая для цикла    # заявления;}за (1..5) { # переменная, вызываемая неявно $ _; 1..5 создает список из этих 5 элементов    # заявления;}заявление за 1..5; # почти то же самое (только 1 утверждение) с порядком естественного языказа мой $ counter (1..5) { # переменная, закрытая для цикла    # заявления;}

(Обратите внимание, что "есть несколько способов сделать это "- девиз программирования Perl.)

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

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

Делать[ж[Икс], {Икс, 0, 1, 0.1}]

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

За[Икс= 0 , Икс <= 1, Икс += 0.1,    ж[Икс]]

1989: Баш

# первая формаза я в 1 2 3 4 5делать    # в цикле должна быть хотя бы одна команда    эхо $ i  # просто напечатайте значение iсделано
# вторая формаза (( я = 1; я <= 5; я ++ ))делать    # в цикле должна быть хотя бы одна команда    эхо $ i  # просто напечатайте значение iсделано

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

1990: Haskell

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

форма_ [1..5] $ \индекс -> делать заявления

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

statement_result_list <- форма [1..5] $ \индекс -> делать заявления

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

импорт Control.Monad так как MforLoopM_ :: Монада м => а -> (а -> Bool) -> (а -> а) -> (а -> м ()) -> м ()forLoopM_ индекс опора incr ж = делать        ж индекс        M.когда (опора Следующий) $ forLoopM_ Следующий опора incr ж  где          Следующий = incr индекс

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

  forLoopM_ (0::Int) (< len) (+1) $ \индекс -> делать - что угодно с индексом

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

ДЛЯ Счетчик := 1 К 5 ДЕЛАТЬ  (* последовательность операторов *)КОНЕЦ

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

1991: Python

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

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

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

1993: AppleScript

повторение с я из 1 к 5	-- заявления	бревно яконец повторение

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

набор Икс к {1, "вафли", "бекон", 5.1, ложный}повторение с я в Икс	бревно яконец повторение

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

1993: Lua

за я = Начните, Стоп, интервал делать  -- заявленияконец

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

за я = 1, 5, 2 делать  Распечатать(я)конец

напечатает:

1 3 5

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

ipairs()

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

пары()

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

Общий цикл for, использующий закрытие:

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

1995: CFML

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

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

за (я = 1; я <= 5; я++) {	// заявления}

Используя массив:

за (я в [1,2,3,4,5]) {	// заявления}

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

петля показатель="я" список="1;2,3;4,5" разделители=",;" {	// заявления}

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

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

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

 показатель="я" из="1" к="5">	<!--- statements ---></cfloop>

Используя массив:

 показатель="я" массив="#[1,2,3,4,5]#">	<!--- statements ---></cfloop>

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

 показатель="я" список="1;2,3;4,5" разделители=",;">	<!--- statements ---></cfloop>

1995: Java

за (int я = 0; я < 5; я++) {    // выполнять функции внутри цикла;    // можно использовать оператор break; выйти рано;    // можно использовать оператор continue; чтобы пропустить текущую итерацию}

Для расширенного цикла for см. Цикл Foreach

1995: JavaScript

JavaScript поддерживает циклы с «тремя выражениями» в стиле C. В перемена и Продолжать операторы поддерживаются внутри циклов.

за (вар я = 0; я < 5; я++) {    // ...}

В качестве альтернативы можно перебирать все ключи массива.

за (вар ключ в массив) {  // также работает для доц. массивы    // используем массив [ключ]    ...}

1995: PHP

Это распечатает треугольник *

за ($ i = 0; $ i <= 5; $ i++) {    за ($ j = 0; $ j <= $ i; $ j++) {        эхо "*";    }    эхо ";}

"

1995: Рубин за счетчик 1..5  в# заявления5.конец раз |делать|  счетчик  # счетчик выполняет итерацию от 0 до 4# заявления1.конец(5) вплоть до |делать|  счетчик# заявления

конец Рубин

имеет несколько возможных синтаксисов, включая приведенные выше примеры.

1996: OCaml[8]

 См. Синтаксис выражения.(* for_statement: = "for" identifier '=' expr ("to" ∣ "downo") expr "do" expr "done" *) за = 1 я 5 к    делать  (* заявления *) ;;сделано за = 5 j 0 вниз    делать  (* заявления *) ;;

сделано

1998: ActionScript 3 (за вар:счетчик = 1; uint <= 5; счетчик++){    счетчик}

//утверждение;

2008: Small Basic За = 1 я 10    К' Заявления

EndFor

2008: Ним Ним имеетдля каждого[9]:

-type цикл и различные операции для создания итераторов. за я 5 .. 10:  в

# заявления

2010: Ржавчиназая0..10{в}

// заявления

2012: Юлия за = 1:10    j# заявления

конец

Пока цикл

  1. ^ Рекомендации.
  2. ^ «Для циклов в C ++» Кен Томпсон.«VCF East 2019 - Брайан Керниган берет интервью у Кена Томпсона» 2020-11-16. . Получено
  3. ^ Я видел версию цикла for с точкой с запятой Джонсона и вставил ее в [B], я ее украл. http://www.knosof.co.uk/vulnerabilities/loopcntrl.pdf
  4. ^ Анализ переменных управления циклом в C
  5. ^ Конструкция программы внутреннего цикла: более быстрый способ выполнения программы «Предупреждение компилятора (уровень 4) C4127». Microsoft . Получено 2011.
  6. ^ 29 июнСправочник по языку PostScript . Издательство Эддисон-Уэсли. п. 596.  0-201-37922-8.
  7. ^ ISBN.
  8. ^ «Учебное пособие по PostScript - циклы»
  9. ^ Синтаксис выражения OCaml https://nim-lang.org/docs/system.html#...i%2CT%2CT