Для цикла

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Печатает числа от 0 до 99 (а не 100), за каждым из которых следует пробел. 

  для   (  int   я  знак равно  0  ;   я  <  100  ;   я  ++  ) 
 { 
     System  .   вне  .   распечатать  (  я  ); 
      Система  .   вне  .   Распечатать  (  ' '  ); 
  } 
 Система  .   вне  .   печатьln  ();

Эти циклы также иногда называют числовыми циклами 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ключевое слово в Фортране 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;

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

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

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

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

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

Введенный в АЛГОЛ 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 :

for   (  я   знак равно   0  ;   я   <   100  ;   я  ++  )   { 
     for   (  j   знак равно   я  ;   j   <   10  ;   j  ++  )   { 
         some_function  (  i  ,   j  ); 
      } 
 }

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

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

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

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

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

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

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

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

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

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

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

Некоторые языки предлагают дополнительные возможности, такие как присвоение имен различным операторам цикла, чтобы при наличии нескольких вложенных циклов не было сомнений в том, какой цикл задействован. Фортран 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   =   НАСТРОЙКА  (  I  )                     !Функция «НАСТРОЙКА» может изменить «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 является параметром некоторой процедуры (например, оператора печати , раскрывающего его значение), скорее всего, это будет ссылка на соответствующую переменную. Я вместо этого. Лучше всего избегать таких возможностей.

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

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

for  i := первый : последний : шаг  сделать 
    A(i) := A(i) / A(последний);

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

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

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

делаю   я   =   1  ,   7  ,   от 12   до   15  ; 
    /*операторы*/ 
 end  ;

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

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

факториал := 1
  для счетчика от 2 до 5
      факториал := факториал * счетчик
 счетчик := счетчик - 1
 напечатать счетчик + "! равно" + факториал

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

факториал := 1
 счетчик := 1
  пока счетчик < 5
     счетчик := счетчик + 1
     факториал := факториал * счетчик
 напечатать счетчик + "! равно" + факториал

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

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

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

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

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

         DO  меток  Счетчик   =   первого  ,   последнего  ,   шага 
           оператор 
 метки       операторы

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

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

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

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

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

* Пример цикла DO. 
         PROGRAM  MAIN 
          SUM  SQ   =   0 
          DO  199   I   =   1  ,   9999999 
            IF   (  SUM  SQ  .  GT  .  1000  )   ПЕРЕЙТИ   К   200 
 199        SUM  SQ   =   SUM  SQ   +   I  **  2 
 200      ПЕЧАТЬ  206  ,   SUMSQ 
 206      ФОРМАТ  (   I2   ) 
        КОНЕЦ

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

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

* Пример цикла DO. 
         программа  main 
          неявное none 

          целое   ::   sumsq 
          целое   ::   i 

          sumsq   =   0 
          do  i   =   1  ,   9999999 
            if   (  sumsq   >   100  0.0  )   выход 
            sumsq   =   sumsq   +   i  **  2 
           end do 
          print   *  ,   sumsq 

        завершить программу

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

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

 FOR  Идентификатор  =  Базовый  (  Разница  )  Предел

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

FOR x = 0 (1) 10 НАЧАЛО
 ПЕЧАТЬ (FL) = x КОНЕЦ

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

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

      ВЫПОЛНИТЬ   SQ-ПРОГРАММУ   , ИЗМЕНЯЮЩУЮ   I   ОТ   1  НА   1  ДО   I   >   1000 

       SQ-ПРОГРАММУ 
              ДОБАВИТЬ   I  **  2  К   SUM-SQ  .

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

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

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

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

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

10   REM THIS FOR LOOP ПЕЧАТАЕТ НЕЧЕТНЫЕ ЧИСЛА ОТ 1 ДО 15 
 20   FOR   I   =   1   ДО   15   ШАГ   2 
 30   ПЕЧАТЬ   I 
 40   СЛЕДУЮЩИЙ   I

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

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

do   counter   =   от 1   до   5   на   1  ;    /* «на 1» используется по умолчанию, если не указано */ 
   /*statements*/  ; 
    конец  ;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

for   Counter   в   цикле 1   ..   5   операторы 
    -- 
 завершают   цикл  ;

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

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

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

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

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

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

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

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

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

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

: CAS Максима 1982

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

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

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

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

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

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

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

83 и выше : Ада 1983

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

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

для   n   =   1  :  5 
      --   операторы 
 заканчиваются

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

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

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

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 Математика :

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

Делай  [  ж  [  Икс  ]  ,   {  Икс  ,   0  ,   1  ,   0  .   1  }  ]

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

Для  [  x  знак равно   0   ,   x   <=   1  ,   x   +=   0  .   1  , 
     ж  [  Икс  ] 
 ]

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

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

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

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

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

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

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

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

операторы_result_list   <-   forM   [  1  ..  5  ]   $   \  indx   ->   do   операторы

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

импортируйте   Control.Monad   как   M 

 forLoopM_   ::   Monad   m   =>   a   ->   (  a   ->   Bool  )   ->   (  a   ->   a  )   ->   (  a   ->   m   ()  )   ->   m   () 
 forLoopM_   indx   prop   incr   f   =   сделать 
         найти   индекс 
         M  .   When   (  prop   next  )   $   forLoopM_   next   prop   incr   f 
   где 
     next   =   incr   indx

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

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

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

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

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

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

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 
 end   повтор

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

установите   x   в   {  1  ,   "вафли"  ,   "бекон"  ,   5.1  ,   false  } 
 повторите   с   i   в   x 
	 log   i, 
 закончите   повтор

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

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

for   i   =   start  ,   stop  ,   интервал   do 
   — операторы 
 заканчиваются

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

для   i   =   1  ,   5  ,   2   напечатайте 
    (  i  ) 
 end

напечатает:

1  3  5

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

IP-пары  ()

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

пары  ()

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

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

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

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

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

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

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

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

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

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

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

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

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