Для цикла

Для схемы цикла

В информатике , для цикла (или просто цикл ) является управление потоком оператор для определения итерации , что позволяет код , который будет выполняться повторно. Для определения этого утверждения используются различные ключевые слова: потомки ALGOL используют «for», а потомки Fortran используют «do». Существуют и другие возможности, например COBOL, который использует "PERFORM VARYING".

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

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

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

ДЛЯ [ редактировать ]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Некоторые языки предлагают цикл for, который действует так, как будто обрабатывает все итерации параллельно , например 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: = 2: N - 1 выполнить 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 или чего-то еще, может быть не ясно описано в руководстве компилятора.

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

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

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

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

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

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

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

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

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

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

for  ( i  =  0 ;  i  <  100 ;  i ++ )  {  for  ( j  =  i ;  j  <  10 ;  j ++ )  {  некоторая_функция ( i ,  j );  } }

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

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

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

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

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

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

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

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

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

Ранний выход и продолжение [ править ]

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

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

Некоторые языки предлагают дополнительные возможности, такие как присвоение имен различным операторам цикла, чтобы при использовании нескольких вложенных циклов не возникало сомнений в том, какой цикл задействован. Фортран 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 ++ ) переменная цикла неизменна в рамках тела цикла, и любая попытка изменить ее значение рассматривается как семантическая ошибка. Такие модификации иногда являются следствием ошибки программиста, которую бывает очень сложно идентифицировать после внесения. Однако компилятор, скорее всего, обнаружит только явные изменения. Ситуации, когда адрес переменной цикла передается в качестве аргумента подпрограмме, очень затрудняют проверку, поскольку поведение подпрограммы, как правило, неизвестно компилятору. Некоторые примеры в стиле Фортран:

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 массива, вероятно, будет использовать вспомогательную переменную (особенно, если она хранится в машинном регистре), но если бы яявляется параметром для некоторой подпрограммы (например, печать -statement раскрыть его значение), то, вероятно , будет ссылка на соответствующую переменную я вместо этого. Лучше избегать таких возможностей.

Регулировка границ [ править ]

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

для i: = first: last: step do 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:

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

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

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

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

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

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

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

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

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

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

Эквивалентом цикла 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 ПРОДОЛЖИТЬ        

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

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

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

* Пример цикла DO. ПРОГРАММА ГЛАВНАЯ СУММА 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 . В современном стиле Фортрана свободной формы пробелы имеют большое значение.

В Фортране 90 перехода к переходу можно избежать с помощью оператора EXIT .

* Пример цикла DO. главная программа неявная нет      integer  ::  sumsq integer :: i      sumsq  =  0 do i = 1 , 9999999 if ( sumsq > 100 0,0 ) выход sumsq = sumsq + i ** 2 end do print * , sumsq                         конец программы

1958: Алгол [ править ]

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

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

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

 Не ВЫПОЛНИТЬ  SQ-ROUTINE  варьируя  I  ОТ  1 BY  1 ПОКА  I  >  1000 SQ-ROUTINE ДОБАВИТЬ I ** 2 В SUM-SQ .    

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

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

Если команда 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: Алгол 68 [ править ]

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

ДЛЯ i ОТ 1 НА 2 ДО 3, В то время как i 4 DO ~ OD

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

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

INT сумма sq: = 0;Для меня ПОКА print (("Пока:", i, новая строка)); # Вставлен для отслеживания. # sum sq ≠ 70 ↑ 2 # Это тест для WHILE #ДЕЛАТЬ сумма sq +: = i ↑ 2OD

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

until

для позднего завершения цикла.

foreach

для параллельной работы с массивами .

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

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

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

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

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

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

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

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

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

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

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

1  к:  5  делать: [ : counter  |  "заявления" ]

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

1980: Ада [ править ]

для  счетчика  в  1  ..  5  цикл  - отчетность конца  цикла ;

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

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

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

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

for  i  от  f  на  b  до  t  while  w  do  # тело цикла od ;

Все части, кроме doи, odявляются необязательными. Часть, если он присутствует, должен прийти первым. Остальные части ( , , , ) могут появляться в любом порядке.for ifrom fby bto twhile w

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

for  e  in  c  while  w  do  # тело цикла od ;

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

Для цикла может быть прекращено od, endили end do.

1982: Maxima CAS [ править ]

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

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

1982: PostScript [ править ]

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

1  1  6  { ЗАЯВЛЕНИЯ }  для

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

5  {  ЗАЯВЛЕНИЯ  }  повторяются

1983: Ada 83 и выше [ править ]

процедура  Main  -  Sum_Sq  :  Integer  : =  0 ; начало  для  I  в  1  ..  9999999  цикле  if  Sum_Sq  <=  1000  then  Sum_Sq  : =  Sum_Sq  +  I ** 2  end  if ;  конец  петли ; конец ;

1984: MATLAB [ править ]

для n = 1 : 5 - утверждения      конец

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

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

1987: Perl [ править ]

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

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

1988: Mathematica [ править ]

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

Сделайте [ f [ x ] ,  { x ,  0 ,  1 ,  0 . 1 } ]

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

Для [ x =  0  ,  x  <=  1 ,  x  + =  0 . 1 ,  f [ x ] ]

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

# первая форма для i in  1  2  3  4  5 do  # в цикле должна быть хотя бы одна команда  echo  $ i  # просто вывести значение i done

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

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

1990: Haskell [ править ]

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

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

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

statements_result_list  <-  FORM  [ 1 .. 5 ]  $  \ INDX  ->  делать  заявления

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

импортировать  Control.Monad  как  MforLoopM_  ::  Монада  м  =>  -> ( -> Bool ) -> ( -> ) -> ( -> м () ) -> м () forLoopM_ INDX проп инкр е = сделать е INDX М . when ( prop next ) $ forLoopM_ next prop incr f where next = incr indx                                      

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

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

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

ДЛЯ  Счетчик  : =  1  TO  5  DO  (* последовательность операторов *) END

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

1991: Python [ править ]

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

for  i  in  range ( 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 конец  повторять

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

Множество  х  к  { 1 ,  «вафли» ,  «бекон» ,  5.1 ,  ложных } повторить  с  I  в  х войти  я закончить  повтор

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

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

for  i  =  start ,  stop ,  interval  do  - конец операторов

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

для  i  =  1 ,  5 ,  2  сделать  print ( i ) end

напечатает:

1  3  5

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

ipairs ()

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

пары ()

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

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

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

1995: CFML [ править ]

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

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

for  ( i  =  1 ;  i  <=  5 ;  i ++ )  { // операторы }

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

for  ( i  in  [ 1 , 2 , 3 , 4 , 5 ])  { // операторы }

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

loop  index = "i"  list = "1; 2,3; 4,5"  delimiters = ",;"  { // заявления }

Выше listпример доступен только в диалекте CFML , используемого Lucee и Railo .

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

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

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

1995: Java [ править ]

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

О расширенном цикле for см. В разделе Цикл по каждому элементу.

1995: JavaScript [ править ]

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

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

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

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

1995: PHP [ править ]

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

for  ( $ i  =  0 ;  $ i  <=  5 ;  $ i ++ )  {  for  ( $ j  =  0 ;  $ j  <=  $ i ;  $ j ++ )  {  echo  "*" ;  }  эхо  "<br> \ n " ; }

1995: Руби [ править ]

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

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

1996: OCaml [ править ]

См. Синтаксис выражения. ^[8]

 (* for_statement: = "for" identifier '=' expr ("to" ∣ "downo") expr "do" expr "done" *)для  i  = от  1  до  5  do  (* statement *)  done  ;;для  j  =  5  до  0  do  (* statement *)  done  ;;

1998: ActionScript 3 [ править ]

for  ( var  counter : uint  =  1 ;  counter  <=  5 ;  counter ++) {  // оператор; }

2008: Small Basic [ править ]

Для  i  = от  1  до  10  'утверждения EndFor

2008: Ним [ править ]

В Nim есть foreachцикл -type и различные операции для создания итераторов. ^[9]

for  i  in  5  ..  10 :  # операторов

2010: Rust [ править ]

for i in 0 .. 10 {     // операторы }

2012: Юлия [ править ]

for  j  =  1 : 10  # оператор конец

См. Также [ править ]

• Сделать цикл while
• Для каждого
• Пока цикл

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