Как перейти к следующей итерации цикла в 1С

Во встроенном языке 1С переход к следующей итерации цикла выполняется оператором Продолжить (английский вариант — Continue). Он немедленно завершает текущий проход цикла и передаёт управление в начало: для цикла Для — к увеличению счётчика, для цикла Пока — к проверке условия. Код, расположенный после Продолжить внутри тела цикла, в текущей итерации не выполняется.

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

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

Синтаксис оператора Продолжить

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

Для Каждого Строка Из ТаблицаДокументов Цикл
Если Строка.ПометкаУдаления Тогда
Продолжить; // помеченные документы пропускаем
КонецЕсли;
// основная обработка строки
ОбработатьДокумент(Строка.Ссылка);
КонецЦикла;

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

Если Строка.Количество = 0 Тогда
	Продолжить; // переходим к следующей итерации
КонецЕсли;

Переход к следующей итерации в цикле Для

В цикле со счётчиком Для Счетчик = 1 По 10 Цикл оператор Продолжить сначала увеличивает счётчик на шаг, затем проверяет, не вышел ли он за границу диапазона, и только потом начинает новую итерацию. Это значит, что бесконечного цикла из-за Продолжить здесь возникнуть не может — счётчик движется в любом случае.

Для Н = 1 По 10 Цикл
Если Н % 2 = 0 Тогда
Продолжить; // чётные числа пропускаем
КонецЕсли;
Сообщить(Н); // выведет 1, 3, 5, 7, 9
КонецЦикла;

Типовой сценарий — обход массива или табличной части по индексу с пропуском «плохих» позиций. Например, при обработке табличной части документа строки с нулевой суммой не требуют движений по регистрам, и их разумно пропустить в самом начале итерации, не наращивая вложенность условий.

Продолжить в цикле Для Каждого

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

Выборка = Запрос.Выполнить().Выбрать();
Пока Выборка.Следующий() Цикл
Если Не ЗначениеЗаполнено(Выборка.Контрагент) Тогда
Продолжить; // записи без контрагента не обрабатываем
КонецЕсли;
СформироватьОтгрузку(Выборка.Ссылка);
КонецЦикла;

Обратите внимание: в цикле по выборке запроса Продолжить корректно вызывает Следующий() — позиционирование на следующую запись происходит автоматически, отдельно дублировать вызов не нужно. Это частая ошибка: разработчик вручную вызывает Выборка.Следующий() перед Продолжить и теряет каждую вторую запись.

Продолжить в цикле Пока: риск бесконечного цикла

Цикл Пока — единственный, где неосторожное использование Продолжить приводит к зависанию. Оператор передаёт управление на проверку условия, и если до этого в итерации не изменились переменные, влияющие на условие, цикл будет крутиться бесконечно.

Н = 0;
Пока Н < 10 Цикл
Н = Н + 1; // сначала двигаем счётчик
Если Н % 2 = 0 Тогда
Продолжить; // безопасно: Н уже увеличено
КонецЕсли;
Сообщить(Н);
КонецЦикла;

Правило безопасности простое: всё, что приближает завершение цикла (инкремент счётчика, чтение следующей записи, изменение флага), должно выполняться до Продолжить. Если пропуск стоит раньше изменения состояния — перестройте порядок строк или замените цикл на Для.

Чем Продолжить отличается от Прервать

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

Выбирайте по смыслу задачи: если неподходящий элемент — это норма и дальше есть что обрабатывать, нужен Продолжить. Если после находки продолжать обход бессмысленно (например, искомый товар уже найден в таблице), используйте Прервать — это ещё и быстрее на больших коллекциях.

Вложенные циклы и ограничения оператора

Важное ограничение: Продолжить действует только на ближайший цикл, внутри которого он написан. Перейти к следующей итерации внешнего цикла из вложенного напрямую нельзя — в языке 1С нет меток или конструкций вида «continue outer».

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

Для Каждого Документ Из СписокДокументов Цикл
ЕстьОшибки = Ложь;
Для Каждого Строка Из Документ.Товары Цикл
Если Строка.Количество < 0 Тогда
ЕстьОшибки = Истина;
Прервать; // выходим из внутреннего цикла
КонецЕсли;
КонецЦикла;
Если ЕстьОшибки Тогда
Продолжить; // пропускаем документ целиком
КонецЕсли;
ПровестиДокумент(Документ.Ссылка);
КонецЦикла;

Ещё одно ограничение: Продолжить нельзя использовать вне цикла — компилятор выдаст синтаксическую ошибку при проверке модуля. Также оператор нельзя применить внутри конструкции Попытка ... Исключение, если сам цикл находится снаружи этой конструкции: переход через границу попытки запрещён, и это нужно учитывать при проектировании обработчиков ошибок.

Как проверить, что переход работает правильно

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

Для прикладной проверки полезно подсчитать, сколько элементов обработано и сколько пропущено. Заведите два счётчика перед циклом, увеличивайте их в соответствующих ветках и после цикла сравните сумму с размером коллекции. Если сумма не сходится — где-то элементы теряются, чаще всего из-за лишнего вызова Следующий() или изменения коллекции во время обхода.

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

Часто задаваемые вопросы