для ( я = 0 ; я < 5 ; я ++ ) printf ( "*" ); В информатике цикл for или цикл for — это оператор потока управления для указания итерации . В частности, цикл for функционирует, многократно выполняя раздел кода до тех пор, пока не будет выполнено определенное условие.
Циклы for состоят из двух частей: заголовка и тела. Заголовок определяет итерацию, а тело — это код, который выполняется один раз за итерацию. Заголовок часто объявляет явный счетчик цикла или переменную цикла . Это позволяет телу знать, какая итерация выполняется. Циклы for обычно используются, когда число итераций известно до входа в цикл. Циклы for можно рассматривать как сокращения для циклов while, которые увеличивают и проверяют переменную цикла.
Для указания использования цикла for используются различные ключевые слова: потомки ALGOL используют " for ", а потомки Fortran используют " do ". Существуют и другие возможности, например, COBOL , который использует .PERFORM VARYING
Название for-loop происходит от слова for. For используется как зарезервированное слово (или ключевое слово) во многих языках программирования для введения for-loop. Термин в английском языке относится к ALGOL 58 и был популярен в ALGOL 60. Это прямой перевод более раннего немецкого für и использовался в Superplan (1949–1951) Хайнцем Рутисхаузером . Рутисхаузер принимал участие в определении ALGOL 58 и ALGOL 60. [1] Тело цикла выполняется «для» заданных значений переменной цикла. Это более явно в версиях оператора for на ALGOL , где можно указать список возможных значений и приращений.
В Fortran и PL/I ключевое слово DO используется для одного и того же и называется do-loop ; это отличается от цикла do while .
Оператор цикла for доступен в большинстве императивных языков программирования. Даже игнорируя незначительные различия в синтаксисе , существует множество различий в том, как работают эти операторы и какой уровень выразительности они поддерживают. Обычно циклы for попадают в одну из четырех категорий:
Цикл for в таких языках, как ALGOL , Simula , BASIC , Pascal , Modula , Oberon , Ada , MATLAB , OCaml , F# и т. д., требует управляющей переменной с начальными и конечными значениями, которая выглядит примерно так:
для i = от первого до последнего оператора do (* или просто *) для i = от первого до последнего оператора do В зависимости от языка вместо знака равенства может использоваться явный знак присваивания (а некоторые языки требуют этого слова даже в числовом случае). Также может быть включено необязательное значение шага (инкремент или декремент ≠ 1), хотя точный синтаксис, используемый для этого, немного отличается в разных языках. Некоторые языки требуют отдельного объявления управляющей переменной, некоторые — нет.int
Другая форма была популяризирована языком C. Она требует 3 частей: инициализация ( вариант цикла ), условие и переход к следующей итерации. Все эти три части являются необязательными. [2] Этот тип «циклов с точкой с запятой» пришел из языка программирования B и был первоначально изобретен Стивеном Джонсоном . [3]
В части инициализации объявляются все необходимые переменные (и им обычно присваиваются значения). Если объявляется несколько переменных, все они должны быть одного типа. Часть условия проверяет определенное условие и выходит из цикла, если оно ложно, даже если цикл никогда не выполняется. Если условие истинно, то выполняются строки кода внутри цикла. Переход к следующей части итерации выполняется ровно один раз каждый раз, когда цикл заканчивается. Затем цикл повторяется, если условие оценивается как истинное.
Вот пример традиционного цикла for в стиле C в Java .
// Выводит числа от 0 до 99 (а не 100), каждое из которых заканчивается пробелом.for ( int i = 0 ; i < 100 ; i ++ ) { System.out.print ( i ) ; System.out.print ( ' ' ) ; } System.out.println ( ) ; Эти циклы также иногда называют числовыми циклами for в отличие от циклов foreach (см. ниже).
Этот тип цикла for является обобщением типа числового диапазона цикла for, поскольку он позволяет перечислять наборы элементов, отличные от числовых последовательностей. Обычно он характеризуется использованием неявного или явного итератора , в котором переменная цикла принимает каждое из значений в последовательности или другой коллекции данных. Типичный пример на Python :
для элемента в some_iterable_object : do_something () do_something_else ()Где some_iterable_objectлибо коллекция данных, которая поддерживает неявную итерацию (например, список имен сотрудников), либо может быть фактически итератором. Некоторые языки имеют это в дополнение к другому синтаксису цикла for; в частности, PHP имеет этот тип цикла под именем for each, а также цикл for из трех выражений (см. ниже) под именем for.
Некоторые языки предлагают for-loop, который действует так, как будто обрабатывает все итерации параллельно , например, for allключевое слово в Fortran 95 , которое имеет интерпретацию, что все выражения правой стороны вычисляются до того, как будут сделаны какие-либо назначения, в отличие от явной формы итерации. Например, в forоператоре в следующем фрагменте псевдокода при вычислении нового значения для A(i), за исключением первого (с i = 2), ссылка на A(i - 1)получит новое значение, которое было помещено туда на предыдущем шаге. В for allверсии, однако, каждое вычисление относится только к исходному, неизмененному A.
для i := 2 : N - 1 сделать A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3; следующий i; для всех i := 2 : N - 1 сделать A(i) := [A(i - 1) + A(i) + A(i + 1)] / 3;
Разница может быть существенной.
Некоторые языки (например, PL/I, Fortran 95) также предлагают операторы присваивания массива, которые позволяют опустить многие циклы for. Таким образом, псевдокод, такой как A := 0;установит все элементы массива A в ноль, независимо от его размера или размерности. Пример цикла может быть отображен как
А ( 2 : N - 1 ) : = [ А ( 1 : N - 2 ) + А ( 2 : N - 1 ) + А ( 3 : N )] / 3 ; Однако в руководстве по компилятору может быть неясно, будет ли это представлено в стиле цикла for, цикла for all или как-то еще.
Введенный в ALGOL 68 и впоследствии PL/I, этот подход позволяет объединить итерацию цикла с проверкой, как в
для i := 1 : N пока A(i) > 0 делать и т.д.
То есть переменной цикла i присваивается значение , и только если выражение while истинно , будет выполнено тело цикла. Если результат ложный, выполнение цикла for останавливается. При условии, что значение переменной цикла определено после завершения цикла, то приведенный выше оператор найдет первый неположительный элемент в массиве A (а если такового нет, его значение будет равно N + 1 ), или, с подходящими вариациями, первый непустой символ в строке и т. д.
В программировании на компьютере счетчик циклов — это управляющая переменная, которая управляет итерациями цикла ( конструкция языка программирования на компьютере ). Она так названа, потому что большинство применений этой конструкции приводит к тому, что переменная принимает диапазон целочисленных значений в некоторых упорядоченных последовательностях (например, начиная с 0 и заканчивая 10 с шагом 1)
Счетчики цикла изменяются с каждой итерацией цикла, предоставляя уникальное значение для каждой отдельной итерации. Счетчик цикла используется для принятия решения о том, когда цикл должен завершиться, и для продолжения потока программы к следующей инструкции после цикла.
Распространенное соглашение об именовании идентификаторов заключается в том, что для счетчика цикла используются имена переменных i , j и k (и так далее, если необходимо), где i будет самым внешним циклом, j — следующим внутренним циклом и т. д. Некоторые программисты также используют обратный порядок. Общепризнано, что этот стиль возник из раннего программирования на Фортране [ требуется ссылка ] , где эти имена переменных, начинающиеся с этих букв, неявно объявлялись как имеющие целочисленный тип, и поэтому были очевидным выбором для счетчиков циклов, которые требовались только временно. Практика восходит еще к математической нотации , где индексами для сумм и умножений часто являются i , j и т. д. Вариант соглашения заключается в использовании дублирующихся букв для индекса, ii , jj и kk , поскольку это упрощает поиск и поиск-замену, чем использование одной буквы. [4]
Пример кода на языке C, включающего вложенные циклы for, где переменными счетчика цикла являются i и j :
для ( i = 0 ; i < 100 ; i ++ ) { для ( j = i ; j < 10 ; j ++ ) { некоторая_функция ( i , j ); } } Циклы в языке C также можно использовать для печати слова в обратном порядке. Например:
для ( я = 0 ; я < 6 ; я ++ ) { scanf ( "%c" , &a a [ я ]); } для ( я = 4 ; я >= 0 ; я -- ) { printf ( "%c" , a [ я ]); } Здесь, если входные данные равны apple, то выходные данные будут равны elppa.
Этот цикл for в стиле C обычно является источником бесконечного цикла , поскольку основные шаги итерации полностью контролируются программистом. Фактически, когда подразумеваются бесконечные циклы, этот тип цикла for может использоваться (с пустыми выражениями), например:
for (;;) //тело цикла Этот стиль используется вместо бесконечных while (1)циклов, чтобы избежать предупреждения о преобразовании типов в некоторых компиляторах C/C++. [5] Некоторые программисты предпочитают более лаконичную for (;;)форму семантически эквивалентной, но более подробной while (true)форме.
Некоторые языки также могут предоставлять другие вспомогательные операторы, которые при наличии могут изменять ход выполнения итерации цикла for. Среди них распространены операторы break и continue , встречающиеся в C и его производных. Оператор break немедленно завершает самый внутренний цикл при выполнении. Оператор continue сразу же перейдет к следующей итерации без дальнейшего продвижения по телу цикла для текущей итерации. Оператор for также завершается, когда выполняется оператор break, goto или return в теле оператора. [Wells] Другие языки могут иметь похожие операторы или иным образом предоставлять средства для изменения хода выполнения цикла for; например, в Fortran 95:
DO I = 1 , N операторов ! Выполняется для всех значений "I", вплоть до катастрофы, если таковая имеется. IF (нехорошо ) CYCLE ! Пропустить это значение "I", продолжить со следующим. операторов ! Выполняется только там, где преобладает добро. IF ( катастрофа ) EXIT ! Прекратить цикл. операторов ! Пока хорошо и, катастрофы нет. END DO ! Должны быть согласованы с "DO". Некоторые языки предлагают дополнительные возможности, такие как присвоение имен различным операторам цикла, так что при наличии нескольких вложенных циклов не возникает сомнений относительно того, какой цикл задействован. Например, 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 имеет соответствующую метку для своей позиции: это не просто помощь в документировании. Программист все равно должен правильно закодировать проблему, но некоторые возможные ошибки будут заблокированы.
Различные языки определяют разные правила для того, какое значение будет хранить переменная цикла по завершении цикла, и некоторые действительно считают, что она «становится неопределенной». Это позволяет компилятору генерировать код, который оставляет любое значение в переменной цикла или, возможно, даже оставляет ее неизменной, поскольку значение цикла хранилось в регистре и никогда не сохранялось в памяти. Фактическое поведение может даже различаться в зависимости от настроек оптимизации компилятора, как в случае с компилятором Honeywell 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 ! Сколько раз будет выполнен цикл? Обычный подход заключается в вычислении количества итераций в начале цикла (с особым вниманием к переполнению, как в for i := 0 : 65535 do ... ;шестнадцатибитной целочисленной арифметике) и с каждой итерацией уменьшать это количество, одновременно корректируя значение I : результаты двойного подсчета. Однако корректировка значения I в цикле не изменит количество выполненных итераций.
Еще одна возможность заключается в том, что сгенерированный код может использовать вспомогательную переменную в качестве переменной цикла, возможно, хранящейся в машинном регистре, значение которой может или не может быть скопировано в I на каждой итерации. Опять же, изменения I не повлияют на управление циклом, но теперь возможна дизъюнкция: внутри цикла ссылки на значение I могут быть ссылками на (возможно измененное) текущее значение I или на вспомогательную переменную (сохраненную от неправильной модификации), и запутанные результаты гарантированы. Например, внутри цикла ссылка на элемент I массива, скорее всего, будет использовать вспомогательную переменную (особенно если она хранится в машинном регистре), но если I является параметром некоторой процедуры (например, оператора print для раскрытия ее значения), то вместо этого, скорее всего, это будет ссылка на правильную переменную I. Лучше избегать таких возможностей.
Так же, как переменная индекса может быть изменена в цикле for, так же могут быть изменены ее границы и направление. Но с неопределенным эффектом. Компилятор может предотвратить такие попытки, они могут не иметь никакого эффекта или даже работать правильно - хотя многие заявят, что делать так было бы неправильно. Рассмотрим такое утверждение, как
для i := первый : последний : шаг сделать A(i) := A(i) / A(последний);
Если бы подход к составлению такого цикла заключался в оценке first , last и step и вычислении количества итераций с помощью чего-то вроде одного раза только в начале, то если бы эти элементы были простыми переменными и их значения каким-то образом корректировались во время итераций, это не оказало бы никакого влияния на количество итераций, даже если бы элемент, выбранный для деления, изменился.(last - first)/stepA(last)
PL/I и ALGOL 68 допускают циклы, в которых переменная цикла итерируется по списку диапазонов значений вместо одного диапазона. Следующий пример PL/I выполнит цикл с шестью значениями i: 1, 7, 12, 13, 14, 15:
do i = 1 , 7 , 12 to 15 ; /*утверждения*/ конец ; Цикл for обычно эквивалентен циклу while:
факториал := 1 для счетчика от 2 до 5 факториал := факториал * счетчиксчетчик := счетчик - 1счетчик печати + "! равно " + факториал
эквивалентно:
факториал := 1счетчик := 1 пока счетчик < 5 счетчик := счетчик + 1 факториал := факториал * счетчиксчетчик печати + "! равно " + факториал
как показано на выходе переменных.
Учитывая действие, которое должно быть повторено, например, пять раз, циклы for разных языков будут написаны по-разному. Синтаксис цикла for из трех выражений практически идентичен во всех языках, где он есть, после учета различных стилей завершения блока и т. д.
Эквивалентом цикла for в Фортране является цикл DO , использующий ключевое слово do вместо for. Синтаксис цикла DO в Фортране следующий:
DO метка счетчик = первый , последний , шаг операторы метка оператор Следующие два примера ведут себя эквивалентно циклу for с тремя аргументами в других языках, инициализируя переменную счетчика значением 1, увеличивая ее на 1 на каждой итерации цикла и останавливаясь на пятом аргументе (включительно).
DO 9 , СЧЕТЧИК = 1 , 5 , 1 ЗАПИСЬ ( 6 , 8 ) СЧЕТЧИК 8 ФОРМАТ ( I2 ) 9 ПРОДОЛЖИТЬ В Fortran 77 (или более поздней версии) это можно также записать так:
сделать счетчик = 1 , 5 написать ( * , '(i2)' ) счетчик конец сделать Часть шага может быть опущена, если шаг один. Пример:
* Пример цикла DO. ПРОГРАММА 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 Пробелы не имеют значения в операторах Fortran фиксированной формы, поэтому SUM SQ — это то же самое, что и SUMSQ . В современном стиле Fortran свободной формы пробелы имеют значение.
В Fortran 90 оператор GO TO можно обойти, используя оператор EXIT .
* Пример цикла DO. Программа main неявный none целое число :: sumsq целое число :: i sumsq = 0 сделать i = 1 , 9999999 если ( sumsq > 100 0.0 ) выйти sumsq = sumsq + i ** 2 конец сделать распечатать * , sumsq конец программыВ ALGOL 58 был введен forоператор, использующий форму Суперплана:
FOR Идентификатор = База ( Разница ) Предел
Например, чтобы напечатать число от 0 до 10 с шагом 1:
ДЛЯ x = 0 (1) 10 НАЧАЛОПЕЧАТЬ (FL) = x КОНЕЦ
COBOL был формализован в конце 1959 года и имел много усовершенствований. Он использует глагол PERFORM, который имеет много опций. Первоначально все циклы должны были быть вне строки с итерируемым кодом, занимающим отдельный абзац. Игнорируя необходимость объявления и инициализации переменных, эквивалентом цикла for в COBOL будет.
ВЫПОЛНЯЙТЕ SQ-ПРОЦЕДУРУ, ИЗМЕНЯЯ I ОТ 1 НА 1, ПОКА I > 1000 ПРОЦЕДУРА SQ-ДОБАВЛЕНИЯ I ** 2 К SUM-SQ . В 1980-х годах добавление встроенных циклов и структурированных программных операторов, таких как END-PERFORM, привело к появлению цикла for с более привычной структурой.
ВЫПОЛНИТЬ ИЗМЕНЯЮЩУЮСЯ I ОТ 1 НА 1 ДО ТЕХ ПОР, ПОКА I НЕ БУДЕТ > 1000 ДОБАВИТЬ I ** 2 К СУММЕ-КВ . КОНЕЦ-ВЫПОЛНИТЬ Если глагол PERFORM имеет необязательное предложение TEST AFTER, результирующий цикл немного отличается: тело цикла выполняется как минимум один раз, перед любой проверкой.
В BASIC цикл иногда называется циклом for-next .
10 REM ЭТОТ ЦИКЛ FOR ПЕЧАТАЕТ НЕЧЕТНЫЕ ЧИСЛА ОТ 1 ДО 15 20 ДЛЯ I = ОТ 1 ДО 15 ШАГ 2 30 ПЕЧАТЬ I 40 ДАЛЕЕ I Маркер конца цикла указывает имя индексной переменной, которое должно соответствовать имени индексной переменной в начале цикла for. Некоторые языки (PL/I, Fortran 95 и более поздние) допускают метку оператора в начале цикла for, которая может быть сопоставлена компилятором с тем же текстом в соответствующем операторе конца цикла. Fortran также допускает операторы EXITи CYCLEдля именования этого текста; в гнезде циклов это дает понять, какой цикл предполагается. Однако в этих языках метки должны быть уникальными, поэтому последовательные циклы, включающие одну и ту же индексную переменную, не могут использовать один и тот же текст, а метка не может совпадать с именем переменной, например, индексной переменной для цикла.
do counter = 1 to 5 by 1 ; /* "by 1" - значение по умолчанию, если не указано иное */ /*statements*/ ; end ; Оператор LEAVE может использоваться для выхода из цикла. Циклы могут быть помечены , и оператор leave может оставить определенный помеченный цикл в группе вложенных циклов. Некоторые диалекты PL/I включают оператор ITERATE для завершения текущей итерации цикла и начала следующей.
В ALGOL 68 есть то, что считалось универсальным циклом, полный синтаксис которого выглядит так:
ДЛЯ i ОТ 1 НА 2 ДО 3 ПОКА i≠4 ДЕЛАТЬ ~ OD
Далее, диапазон единичной итерации может быть заменен списком таких диапазонов. Есть несколько необычных аспектов конструкции
do ~ odчасть была обязательной, в этом случае цикл будет повторяться бесконечно.to 100 do ~ odбудет повторяться ровно 100 раз.while элемент позволял программисту forпреждевременно выйти из цикла, например:INT сумма кв := 0;ДЛЯ Я ПОКА print(("So far:", i, new line)); # Вставлено для целей трассировки. # сумма кв ≠ 70↑2 # Это тест для WHILE #ДЕЛАТЬ сумма кв +:= i↑2ОДПоследующие расширения стандарта ALGOL 68 позволили toзаменить синтаксический элемент на uptoи downtoдобиться небольшой оптимизации. Те же компиляторы также включили:
untilforeachдля Счетчика := от 1 до 5 do (*оператор*) ; Декремент (обратный отсчет) осуществляется с использованием downtoключевого слова вместо to, например:
для Counter := 5 вниз до 1 do (*statement*) ; Числовой диапазон цикла for варьируется несколько больше.
для ( инициализация ; условие ; инкремент / декремент ) оператор Оператор часто представляет собой блок-оператор; примером этого может служить:
//Использование циклов for для сложения чисел 1 - 5 int sum = 0 ; for ( int i = 1 ; i <= 5 ; ++ i ) { sum += i ; } Публикация ISO/IEC 9899:1999 (широко известная как C99 ) также допускает начальные объявления в forциклах. Все три раздела в цикле for являются необязательными, а пустое условие эквивалентно true.
1 до: 5 сделать: [ : счетчик | "утверждения" ]В отличие от других языков, в Smalltalk цикл for не является языковой конструкцией , а определен в классе Number как метод с двумя параметрами: конечным значением и замыканием , использующим self в качестве начального значения.
для Счетчика в цикле 1..5 - операторы заканчивают цикл ; Оператор выхода может использоваться для выхода из цикла. Циклы могут быть помечены, и выход может оставить специально помеченный цикл в группе вложенных циклов:
Подсчет : для счетчика в цикле 1..5 Треугольник : для вторичного_индекса в цикле 2..Счетчик — операторы выходят Подсчет ; — операторы заканчивают цикл Треугольник ; конец цикла Подсчет ; Maple имеет две формы цикла for, одну для итерации диапазона значений, а другую для итерации по содержимому контейнера. Форма диапазона значений выглядит следующим образом:
для i от f по b до t пока w do # тело цикла od ;
Все части, кроме doи , odявляются необязательными. Часть, если она присутствует, должна быть первой. Остальные части ( , , , ) могут появляться в любом порядке.for ifrom fby bto twhile w
Итерация по контейнеру выполняется с использованием следующей формы цикла:
for e in c while w do # тело цикла od ;
В предложении указывается контейнер, который может быть списком, набором, суммой, произведением, невычисленной функцией, массивом или объектом, реализующим итератор.in c
Цикл for может быть завершен с помощью od, end, или end do.
В Maxima CAS можно использовать и нецелые значения:
для x : 0.5 шаг 0.1 через 0.9 do /* "Сделать что-нибудь с x" */ Цикл for, записанный как [initial] [increment] [limit] { ... } forинициализирует внутреннюю переменную, выполняет тело до тех пор, пока внутренняя переменная не больше предела (или не меньше, если приращение отрицательно) и в конце каждой итерации увеличивает внутреннюю переменную. Перед каждой итерацией значение внутренней переменной помещается в стек. [6]
1 1 6 { ЗАЯВЛЕНИЯ } дляСуществует также простой цикл повторения. Цикл повторения, записанный как X { ... } repeat, повторяет тело ровно X раз. [7]
5 { ЗАЯВЛЕНИЯ } повторитьПроцедура 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 ;для n = 1 : 5 -- утверждения заканчиваются После цикла nв этом примере будет 5.
Поскольку iиспользуется для мнимой единицы , ее использование в качестве переменной цикла не рекомендуется.
for ( $counter = 1 ; $counter <= 5 ; $counter ++ ) { # неявно или предопределенная переменная # операторы; } for ( my $counter = 1 ; $counter <= 5 ; $counter ++ ) { # переменная, приватная для цикла # операторы; } for ( 1 .. 5 ) { # переменная, неявно вызванная $_; 1..5 создает список из этих 5 элементов # операторы; } оператор for 1 .. 5 ; # почти то же самое (только 1 оператор) с естественным порядком языка for my $counter ( 1 .. 5 ) { # переменная, приватная для цикла # операторы; } « Есть больше одного способа сделать это » — девиз программирования на Perl.
Конструкция, соответствующая циклу for большинства других языков, в системе Mathematica называется Do.
Сделай [ ф [ х ] , { х , 0 , 1 , 0.1 } ] В системе Mathematica также есть конструкция For, которая имитирует цикл for языков типа C.
Для [ x = 0 , x < = 1 , x + = 0.1 , f [ x ] ] # первая форма for i in 1 2 3 4 5 do # должна быть хотя бы одна команда в цикле echo $i # просто вывести значение i done # вторая форма for (( i = 1 ; i < = 5 ; i++ )) do # в цикле должна быть хотя бы одна команда echo $i # просто вывести значение i done Пустой цикл (т. е. цикл без команд между doи done) является синтаксической ошибкой. Если бы указанные выше циклы содержали только комментарии, выполнение привело бы к сообщению "синтаксическая ошибка около неожиданного токена 'done'".
Встроенный императив forM_ отображает монадическое выражение в список, как
forM_ [ 1 .. 5 ] $ \ indx -> do операторы или получить каждый результат итерации в виде списка в
statements_result_list <- forM [ 1 .. 5 ] $ \ indx -> do операторы Но для экономии места в списке [1..5] можно определить более аутентичную монадическую конструкцию forLoop_ как
импортировать Control.Monad как M forLoopM_ :: Монада 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 -- что угодно с индексом FOR Counter := 1 TO 5 DO (* последовательность операторов *) ENDВ оригинальном языке Oberon цикл for был опущен в пользу более общей конструкции цикла Oberon. Цикл for был вновь введен в Oberon-2.
В Python нет классического цикла for, вместо этого foreachцикл используется для итерации по выходным данным встроенной range()функции, которая возвращает итерируемую последовательность целых чисел.
for i in range ( 1 , 6 ): # дает i значения от 1 до 5 включительно (но не 6) # операторы print ( i ) # если нам нужно 6, мы должны сделать следующее for i in range ( 1 , 6 + 1 ): # дает i значения от 1 до 6 # операторы print ( i )Использование range(6)запустит цикл от 0 до 5.
повторите с i от 1 до 5 -- операторы log i конец повтораОн также может выполнять итерацию по списку элементов, подобно тому, как это можно делать с массивами в других языках:
установить x в { 1 , "вафли" , "бекон" , 5.1 , false } повторить с i в x log i конец повторитьA exit repeatтакже может быть использован для выхода из цикла в любое время. В отличие от других языков, AppleScript в настоящее время не имеет команды для продолжения следующей итерации цикла.
для i = начало , остановка , интервал do -- операторы конецИтак, этот код
для i = 1 , 5 , 2 вывести ( i ) конецнапечатает:
1 3 5Циклы for также могут проходить по таблице, используя
ipairs ()для численной итерации по массивам и
пары ()для случайного перебора словарей.
Общий цикл for, использующий замыкания:
для имени , телефона , адреса в contacts () do -- contacts() должна быть функцией-итератором endПростой индексный цикл:
для ( i = 1 ; i <= 5 ; i ++ ) { // операторы }Использование массива:
для ( i in [ 1 , 2 , 3 , 4 , 5 ]) { // операторы }Использование списка строковых значений:
индекс цикла = "i" список = "1;2,3;4,5" разделители = ",;" { // операторы }Приведенный выше listпример доступен только на диалекте CFML, используемом Люси и Райло .
Простой индексный цикл:
<cfloop index = "i" from = "1" to = "5" > <!--- операторы ---> </cfloop>Использование массива:
<cfloop index = "i" array = " #[1,2,3,4,5]# " > <!--- операторы ---> </cfloop>Использование «списка» строковых значений:
<cfloop index = "i" list = "1;2,3;4,5" delimiters = ",;" > <!--- операторы ---> </cfloop>for ( int i = 0 ; i < 5 ; i ++ ) { //выполняем функции внутри цикла; //можно использовать оператор 'break;' для раннего выхода; //можно использовать оператор 'continue;' для пропуска текущей итерации } Для расширенного цикла for см. Цикл Foreach § Java .
JavaScript поддерживает циклы "трех выражений" в стиле C. Операторы breakи continueподдерживаются внутри циклов.
for ( var я = 0 ; я < 5 ; я ++ ) { // ... } В качестве альтернативы можно выполнить итерацию по всем ключам массива.
for ( var key in array ) { // также работает для ассоциативных массивов // используйте array[key] ... } Это распечатает треугольник *
для ( $i = 0 ; $i <= 5 ; $i ++ ) { для ( $j = 0 ; $j <= $i ; $j ++ ) { echo "*" ; } echo "<br /> \n " ; }для счетчика в 1 .. 5 # операторы заканчиваются 5 . times do | counter | # counter выполняет итерации от 0 до 4 # операторы заканчиваются 1. до ( 5 ) сделать | счетчик | # операторы конец В Ruby существует несколько возможных синтаксисов, включая приведенные выше примеры.
См. синтаксис выражения. [8]
(* for_statement := "for" ident '=' expr ( "to" ∣ "downto" ) expr "do" expr "done" *)для i = от 1 до 5 сделать (* операторы *) сделано ;;для j = 5 до 0 сделать (* операторы *) сделано ;;для ( var counter : uint = 1 ; counter <= 5 ; counter ++) { // оператор; } Для i = 1 до 10 ' Операторы EndFor В Nim есть foreachцикл типа - и различные операции для создания итераторов. [9]
для i в 5 .. 10 : # операторы для i := 0 ; i <= 10 ; i ++ { // операторы } для i в 0 .. 10 { // операторы } для j = 1 : 10 # операторы заканчиваются Я видел версию цикла for с точкой с запятой Джонсона и вставил ее в [B], я ее украл.