1с если ошибка тогда продолжить

16.03.08 — 21:06

1 — 16.03.08 — 21:19

ух ты, ты действительно гений

2 — 16.03.08 — 21:24

(0) наверое так
Пока 1=1 Цикл

Если НЕ Условие1 Тогда
  Прервать;//или Возврат
 
 
КонецЕсли;
Если НЕ Условие2 Тогда
  Прервать;//или Возврат
 
 
КонецЕсли;
Если Условие3 Тогда
    ...
КонецЕсли;
Прервать;

3 — 16.03.08 — 21:33

(0) не видно Ваших вариантов.

4 — 16.03.08 — 22:05

С продолжить — да, согласен, более красиво и с точки зрения производительности потерь не вижу, а вот вызывать возврат внутри цикла мне вспоминается почему-то плохим стилем кодинга, но вот почему — не помню 🙂
Возможно, есть опасность не дойти до вызова delete, но в 1С, вроде сама платформа следит за очищением кучи (правда, следит не очень-то хорошо)

5 — 16.03.08 — 22:16

Под возвратом подразумевался выход из процедуры (если условие применяется на уровне процедуры) или продолжить (если условие используется внутри цикла).

Просто такой подход позволяет избавиться от многоэтажных если. 😉

6 — 16.03.08 — 22:24

Давно уже так пишу 
да, лучше чем КонецЕсли разбирать

7 — 16.03.08 — 22:27

(5) Обойтись без многоэтажки — это хорошо, но плохо тем, что код ДОЛЖЕН доходить до конца процедуры. Для того, что бы можно было отловить состояния переменных и понять, где бага, а то, когда куча выходов посредине кода — попробуй поймать ошибку.

8 — 16.03.08 — 22:28

(7) код ДОЛЖЕН доходить до конца процедуры?!
LOL
А что он еще должен? :)))

9 — 16.03.08 — 22:30

(7)Зато очень удобно при обработке списка

10 — 16.03.08 — 22:31

(7) Логика не понятна

11 — 16.03.08 — 23:32

Функции ВозвратаНечто()
   Если А = 1 Тогда
      Возврат 10;
   Иначе
      Возврат 11;
   КонецЕсли;
КонецФункции;

Функции ВозвратаНечто()
   Перем Результат;

   Результат = Неопределено;

   Если А = 1 Тогда
      Результат = 10;
   Иначе
      Результат = 11;
   КонецЕсли;

   Возврат Результат;
КонецФункции;

12 — 16.03.08 — 23:43

(8)+1 (11) ИМХО фигня. На каком возврате выход происходит — как правило знать нафиг не нужно. Бывает нужно знать по каким операторам проходим, а по каким нет. Даже обычные Если … КонецЕсли при этом заставляют копаться в коде подробнее, смотреть на конец процедуры не помогает. А при наличии отладчика все это отслеживается элементарно…

13 — 16.03.08 — 23:51

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

Если  Тогда 
   Продолжить; 
КонецЕсли; 
Если  Тогда 
   Продолжить; 
КонецЕсли;
Если  Тогда 
   Продолжить; 
КонецЕсли;
Если  Тогда 
   Продолжить; 
КонецЕсли;
Если  Тогда 
   Продолжить; 
КонецЕсли;
 Тело модуля

или  
    Если Тогда 
        Если Тогда
            Если Тогда
                Если Тогда
                    Если Тогда
                        Тело модуля на 300 строк 
                    КонецЕсли;     
                КонецЕсли;     
            КонецЕсли;     
    КонецЕсли;

14 — 16.03.08 — 23:52

(0) Поздравляю… за 10 лет работы наконец то дошло то, что другие понимают на 2й год работы

прогресс…

15 — 16.03.08 — 23:58

(13) вообще то все понимают на первый

16 — 17.03.08 — 00:02

(15) ну я взял максимум…

17 — 17.03.08 — 07:11

Я вот в порыве страсти (вдохновения) обычно пишу код так,как представляю в мозге,и поэтому многие конструкции потом сложно воспринимать,хоть и расставляю комментарии,а переписывать покрасивее так лень,когда и так все работает…

(16) 😉 Гыгыгы, в книжках по программированию вам такого не расскажут. 😉

«Продолжить» и «Возврат»

Автор Константин163, 30 мар 2015, 21:12

0 Пользователей и 1 гость просматривают эту тему.

Если (If)

Описание:
Оператор Если управляет выполнением программы, основываясь на результаты одного или более логических выражений. Оператор может содержать любое количество групп операторов, возглавляемых конструкциями ИначеЕсли – Тогда.
Синтаксис:
Если <Логическое выражение> Тогда
// Операторы
[ИначеЕсли <Логическое выражение> Тогда]
// Операторы
[Иначе]
// Операторы
КонецЕсли;
Англоязычный синтаксис:
If <Логическое выражение> Then
// Операторы
[ElsIf <Логическое выражение> Then]
// Операторы

[Else]
// Операторы
EndIf;
Параметры:

<Логическое выражение>  – Логическое выражение.

Тогда – Операторы, следующие за Тогда, выполняются, если результатом логического выражения является значение Истина.

// Операторы – Исполняемый оператор или последовательность таких операторов

ИначеЕсли – Логическое выражение, следующее за ключевым словом ИначеЕсли, вычисляется только тогда, когда условия в Если и всех предшествующих ИначеЕсли
оказались равны Ложь. Операторы, следующие за конструкцией ИначеЕсли – Тогда, выполняются, если результат логического выражения в данном
ИначеЕсли равен Истина.

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

КонецЕсли–  Ключевое слово, которое завершает структуру оператора условного выполнения.

Пример:

Если ДеньНедели(ТекущаяДата()) = 6 Тогда
Сообщить(“Сегодня суббота.”);
ИначеЕсли ДеньНедели(ТекущаяДата()) = 7 Тогда
Сообщить(“Сегодня воскресенье.”);
Иначе
Сообщить(“Сегодня рабочий день.”);
КонецЕсли;

Новый (New)

Описание:
Оператор позволяет создать значение указанного типа. Допустим только для тех типов, для которых разрешено создание новых значений. Для прикладных объектов необходимо использовать функциональную форму оператора Новый (вариант 2), так как при проверке модулей в конфигураторе  не определены типы для прикладных объектов.
При работе с функциональной формой оператора Новый следует помнить, что операция разыменования непосредственно к результату работы оператора не может быть применена. Вначале следует присвоить результат работы оператора Новый какой-либо переменной, а затем использовать уже эту переменную.
Синтаксис (вариант 1):
Новый <Имя типа>[(<Парам 1>, …, <Парам N>)]
Параметры:

Имя типа – Указывается имя типа, значение которого создается.

<Парам 1>, …, <Парам N> –  После имени типа в скобках могут указываться параметры, если они определены в конструкторах для данного типа. Допустимое количество параметров
и их назначение указываются в описании конструкторов объекта.

Пример:
// Пример создания массива из трех элементов.
Массив = Новый Массив(3);

Синтаксис (вариант 2):
Новый (<Тип>[, <Параметры конструктора>])
Параметры:

Тип – Имя типа или значение типа Тип.
<Параметры конструктора> Массив параметров конструктора.
Пример:

ТипЗначения = Тип(“КвалификаторыСтроки”);
Параметры = Новый Массив(2);
Параметры[0] = 20;
Параметры[1] = ДопустимаяДлина.Переменная;
КвалифСтр = Новый(ТипЗначения, Параметры);

Перейти (Goto)

Описание:
Безусловная передача управления на другой оператор программы. Передает управление от одного оператора к другому.
Область действия оператора ограничивается программным модулем, процедурой или функцией; он не может передать управление за пределы программного модуля, процедуры или функции.
Примечание 1. Метка в этом операторе не должна быть меткой перехода на оператор Процедура или Функция.
Примечание 2. Оператор безусловного перехода не может быть использован для передачи управления на операторы, находящиеся внутри конструкций:
Пока – КонецЦикла, Для – КонецЦикла, Для каждого – КонецЦикла, Если – КонецЕсли, Попытка – Исключение – КонецПопытки извне этих конструкций.
Синтаксис:
Перейти <Метка>;
Пример:

Перейти ~Метка1;
…
~ Метка1: Сообщить(“Осуществлен переход по метке.”);

Перем (Var)

Описание:
Позволяет в явном виде объявить переменную.
Синтаксис:
Перем <Имя переменной 1> [Экспорт] [, <Имя переменной 2>, …];
Англоязычный синтаксис:
Var <Имя переменной 1> [Export] [, <Имя переменной 2>, …];
Параметры:

<Имя переменной 1>[, <Имя переменной 2>, …] – Задается имя или имена объявляемых переменных
Экспорт – Необязательное ключевое слово. Указывает, что данная переменная доступна при обращении к контексту этого модуля из других модулей. Данное ключевое слово необходимо указывать для каждой объявляемой переменной отдельно. Не имеет смысла при объявлении переменных отдельных процедур или функций.
Пример:

// Пример объявления одной переменной
Перем А Экспорт;
Перем Б;
// Пример объявления нескольких переменных одним оператором
Перем А, Б Экспорт;
Неявное объявление переменных:
В языке необязательно объявлять переменные в явном виде. Неявным определением переменной является первое ее появление в левой части
оператора присваивания. Тип переменной определяется типом присвоенного ей значения. Не допускается использование в выражениях переменных, не
объявленных ранее в явном или неявном виде.
Область использования переменной:
Область использования переменных зависит от места их определения в конфигурации. Существует три области, в которых можно объявить
переменные:
● В разделе определения переменных программного модуля управляемого приложения. Это глобальные переменные.
● В разделе определения переменных модуля. Это переменные модуля.
● В процедуре или функции. Это локальные переменные.
Глобальные переменные, объявленные с ключевым словом Экспорт, доступны для использования в исполняемых операторах, выражениях, в любой процедуре и функции любого клиентского программного модуля конфигурации.
Переменные модуля доступны для использования в исполняемых операторах, выражениях, в любой процедуре и функции того программного модуля, в пределах которого они объявлены. Если они объявлены с ключевым словом Экспорт, то они доступны из других модулей через контекст модуля, в котором они объявлены.
Локальные переменные доступны в пределах той процедуры или функции, в которой они объявлены.
Если переменная определена как глобальная, то она видна из всех процедур и функций любого клиентского программного модуля конфигурации. Если же переменная определена внутри процедуры, то ее областью видимости является данная процедура или функция.

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

Пока (While)

Описание:
Оператор цикла Пока предназначен для циклического повторения операторов, находящихся внутри конструкции Цикл – КонецЦикла. Цикл выполняется,
пока логическое выражение равно Истина. Условие выполнения цикла всегда проверяется вначале, перед выполнением цикла.
Синтаксис:
Пока <Логическое выражение> Цикл
// Операторы
[Прервать;]
// Операторы
[Продолжить;]
// Операторы
КонецЦикла
Англоязычный синтаксис:
While <Логическое выражение> Do
// Операторы
[Break;]
// Операторы
[Continue;]
// Операторы
EndDo;
Параметры:

<Логическое выражение> -Логическое выражение
Цикл– Операторы, следующие за ключевым словом Цикл, выполняются, пока результат логического выражения равен Истина.
// Операторы – Исполняемый оператор или последовательность таких операторов.
Прервать – Позволяет прервать выполнение цикла в любой точке. После выполнения этого оператора управление передается оператору, следующему за ключевым
словом КонецЦикла.
Продолжить –  Немедленно передает управление в начало цикла, где производится вычисление и проверка условий выполнения цикла. Операторы, следующие в теле
цикла за ним, на данной итерации обхода не выполняются.
КонецЦикла –  Ключевое слово, которое завершает структуру оператора цикла.
Пример:

ВыборкаДок = Документы.РасходнаяНакладная.Выбрать();
// Цикл по всем документам
Пока ВыборкаДок.Следующий() Цикл
// Отобразим Документ в панели состояния
Состояние(“Обрабатывается документ №” + ВыборкаДок.Номер);
// Операторы выполнения действий над документом
КонецЦикла;

Попытка (Try)

Описание:
Оператор Попытка управляет выполнением программы, основываясь на возникающих при выполнении модуля ошибочных (исключительных) ситуациях,
и определяет обработку этих ситуаций.
В качестве ошибочных (исключительных) ситуаций воспринимаются ошибки времени выполнения модуля. Не предусмотрено определяемых пользователем исключений.
КонецПопытки оператор. Если же последовательность операторов попытки выполнилась без ошибок, то последовательность операторов исключения будет пропущена и управление также будет продолжено с оператора, следующего за ключевым словом КонецПопытки.
Конструкции Попытка – Исключение – КонецПопытки могут быть вложенными. При этом при возникновении исключительной ситуации управление передается на тот обработчик, в попытке которого произошла ошибка. Если же в последовательности операторов исключения этого обработчика выполняется оператор ВызватьИсключение, выполнение передается вышестоящему обработчику исключения и так далее. Если вышестоящего обработчика нет, исключительная ситуация обрабатывается системно с прекращением выполнения программного модуля.
В выдаче диагностики помощь могут оказать встроенные функции ОписаниеОшибки() и ИнформацияОбОшибке() (см. описание функций встроенного языка). Также следует учитывать, что попадание во вложенный обработчик исключения приводит к тому, что информация о «родительском» исключении теряется.
С помощью конструкции Попытка – Исключение – КонецПопытки не могут быть перехвачены следующие ошибки:
● Ошибки компиляции модулей встроенного языка во время исполнения.
● Ошибки времени исполнения, возникающие в обработчиках ПередЗакрытием() и ПриЗакрытии() управляемой формы.
Такие ошибки всегда будет отображаться системой «1С:Предприятие» и приводить к прекращению выполнения встроенного языка.
Синтаксис:
Попытка
// Операторы попытки
Исключение
// Операторы исключения
[ВызватьИсключение;]
// Операторы исключения
КонецПопытки;
Англоязычный синтаксис:
Try
// Операторы попытки
Except
// Операторы исключения
[Raise;]
// Операторы исключения
EndTry;
Параметры:

// Операторы попытки – Исполняемый оператор или последовательность таких операторов.

Исключение – Операторы, следующие за ключевым словом Исключение, выполняются, если при выполнении последовательности операторов произошла ошибка
времени выполнения.

// Операторы исключения – Исполняемый оператор или последовательность операторов, которые обрабатывают исключительную ситуацию.

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

КонецПопытки–  Ключевое слово, которое завершает структуру оператора обработки исключительных ситуаций.
Пример:

Процедура СформироватьВExcel()
Попытка
// Пытаемся обратиться к программе MS Excel
Табл = Новый ComObject(“Excel.Application”);
Исключение
Предупреждение(ОписаниеОшибки());
Возврат;
КонецПопытки;
// Операторы формирования отчета
…
КонецПроцедуры

Процедура (Procedure)

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

Синтаксис:
Процедура <ИмяПроцедуры>([[Знач] <Парам 1> [=<ДефЗнач>], … ,[Знач] <Парам N> [=<ДефЗнач>]])[Экспорт]
// Объявления локальных переменных;
// Операторы;
…
[Возврат;]
// Операторы;
…
КонецПроцедуры
Англоязычный синтаксис:
Procedure <ИмяПроцедуры>([[Val] <Парам 1> [=<ДефЗнач>], … ,[Val] <Парам N>[=<ДефЗнач>]])[Export]
// Объявления локальных переменных;
// Операторы;
…
[Return;]
// Операторы;
…
EndProcedure

Пример:

Перем Глоб;
// Описание процедуры
Процедура МояПроцедура(Пар1, Пар2, Пар3) Экспорт
Глоб = Глоб + Пар1 + Пар2 + Пар3;
Возврат;
КонецПроцедуры
Глоб = 123;
МояПроцедура(5, 6, 7); // Вызов процедуры

УдалитьОбработчик (RemoveHandler)

Описание:
Удаляет обработчик события.
При удалении обработчика события производится проверка соответствия числа параметров события числу параметров метода, назначенного в качестве
обработчика.
Синтаксис:
УдалитьОбработчик <Событие>, <ОбработчикСобытия>;
Англоязычный синтаксис:
RemoveHandler <Событие>, <ОбработчикСобытия>;
Параметры:

<Событие> – Событие, обработчик которого удаляется.
Событие задается в форме <Выражение>.<ИмяСобытия>, где:
● <Выражение> – произвольное выражение на встроенном языке. Его результатом должен быть объект, обработчик события которого удаляется.
● <ИмяСобытия> – идентификатор (имя) события.

<ОбработчикСобытия> – Процедура/функция-обработчик события.
Обработчиком события может являться метод объекта встроенного языка. Тогда <ОбработчикСобытия> задается как <Выражение>.<ИмяОбработчика>,
где:
● <Выражение> – произвольное выражение на встроенном языке. Его результатом должен быть объект, метод которого служит обработчиком события.
● <ИмяОбработчика> – имя метода обработчика события.
Также в качестве обработчика события может быть задана процедура/функция, находящаяся в области видимости. В этом случае обработчик события
задается как имя процедуры/функции.
Пример:

УдалитьОбработчик Накладная.ПриЗаписи, Обработка.ПриЗаписиДокумента;

Функция (Function)

Описание:
Ключевое слово Функция начинает секцию исходного текста функции, выполнение которой можно инициировать из любой точки программного модуля,
просто указав ИмяФункции со списком параметров (если параметры не передаются, то круглые скобки, тем не менее, обязательны). Если в модуле приложения или общем программном модуле в теле описания функции использовано ключевое слово Экспорт, то это означает, что данная функция является доступной из всех других программных модулей конфигурации.
Выполнение функции заканчивается оператором Возврат. Функции отличаются от процедур только тем, что возвращают ВозвращаемоеЗначение. Конец
программной секции функции определяется по оператору КонецФункции.
Вызов любой функции в тексте программного модуля можно записывать как вызов процедуры, т. е. в языке допускается не принимать от функции
возвращаемое значение.
Если ключевое слово Возврат в теле функции не указано или строка модуля, его содержащая, не выполнена, то функция возвращает значение типа Неопределено.
Переменные, объявленные в теле функции в разделе Объявления локальных переменных, являются локальными переменными данной функции, поэтому доступны только в этой функции (за исключением случая передачи их как параметров при вызове других процедур, функций или методов).
ПРИМЕЧАНИЕ. Ключевые слова Функция, КонецФункции являются не операторами, а операторными скобками, поэтому не должны заканчиваться точкой с запятой (это может приводить к ошибкам выполнения модуля).
Синтаксис:

Функция <ИмяФункции>([[Знач] <Парам 1>[=<ДефЗнач>], … ,[Знач] <Парам N>[=<ДефЗнач>]])[Экспорт]
// Объявления локальных переменных;
// Операторы;
…
Возврат <Возвращаемое значение>;
// Операторы;
…
КонецФункции

Англоязычный синтаксис:
Function <ИмяФункции>([[Val] <Парам 1>[=<ДефЗнач>], … ,[Val] <Парам N>[=<ДефЗнач>]])[Export]
// Объявления локальных переменных;
// Операторы;
…
Return <Возвращаемое значение>;
// Операторы;
…
EndFunction

Пример:
Перем Глоб;
// Описание функции
Функция МояФункция(Пар1, Пар2, Пар3) Экспорт
Глоб = Глоб + Пар1 + Пар2 + Пар3;
Возврат Глоб;
КонецФункции
Глоб = 123;
Рез = МояФункция(5, 6, 7); // Вызов функции

Цикл – это конструкция, которая предназначена для многократного исполнения неких инструкций. Во встроенном языке 1С существует три вида циклов «Пока», «Для» и «Для Каждого». Рассмотрим на примерах работу с каждым из них.

Цикл «Пока»

Синтаксис:

Пока <Логическое выражение> Цикл
// Операторы
КонецЦикла;

Принцип работы такого цикла заключается в том, что операторы находящиеся после ключевого слова «Цикл», будут выполнятся пока логическое выражение будет равно ИСТИНА.

Пример:

Счётчик = 1;
Пока Счётчик <= 5 Цикл
            Сообщить(Счётчик);
            Счётчик = Счётчик + 1;  
КонецЦикла;

В результате выполнения такого цикла, в окно сообщений будут последовательно выведены цифры от 1 до 5.

Цикл «Для»

Синтаксис:

Для <Имя переменной> = <Начальное значение> По <Конечное значение> Цикл
// Операторы
КонецЦикла;

После начального присвоения значения для переменной после ключевого слова «Для», такой цикл прекратится, когда значение переменной будет меньше либо равно конечному значению после ключевого слова «По». В таком цикле приращение переменной происходит автоматически, и всегда равно «1».

Пример:

Для Счётчик = 1 По 5 Цикл
Сообщить(Счётчик);
КонецЦикла;

Результат:

Цикл «Для Каждого»

Синтаксис:

Для Каждого <Элемент> Из <Коллекция> Цикл
// Операторы
КонецЦикла;

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

Пример кода:

// Создание массива
Массив = Новый Массив();

// Наполнение массива
Массив.Добавить("Элемент №1");
Массив.Добавить("Элемент №2");
Массив.Добавить("Элемент №3");

// Обход массива по элементам
Для Каждого Элемент Из Массив Цикл
Сообщить(Элемент);
КонецЦикла;

Визуальное представление созданного массива в 1С:

Результат работы цикла:

Вложенные циклы

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

Пример:

КоллекцияКолонок = ТаблицаЗначений.Колонки;
Для Каждого ТекущаяСтрока Из ТаблицаЗначений Цикл
Для Каждого ТекущаяКолонка Из КоллекцияКолонок Цикл
// Получаем значение ячейки
ТекущаяЯчейка = ТекущаяСтрока[ТекущаяКолонка.Имя];
КонецЦикла;
КонецЦикла;

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

Как организовать обратный цикл

Пример:

Счётчик = 5;

Пока Счётчик >= 1 Цикл
Сообщить(Счётчик);
Счётчик = Счётчик - 1;
КонецЦикла;

Результат:

Как принудительно продолжить цикл

Принудительный переход к следующей итерации в циклах 1С осуществляется с помощью оператора «Продолжить» (Continue).

Пример:

Для Счетчик = 1 По 5 Цикл

Если Счетчик = 2 Тогда
Продолжить;
КонецЕсли;

Сообщить(Счетчик);

КонецЦикла;

В таком примере с помощью операторов «Если» и «Продолжить» пропускаем цифру «2».

Результат:

Как прервать цикл

Полный выход из цикла (прерывание) во встроенном языке программирования 1С осуществляется с помощью оператора «Прервать» (Break).

Пример:

Для Счетчик = 1 По 5 Цикл

Если Счетчик = 2 Тогда
Прервать;
КонецЕсли;

Сообщить(Счетчик);

КонецЦикла;

Такой цикл перестанет выполняться, как только значение переменной «Счётчик» будет равно «2».

Результат:

Условные операторы

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

В системе «1С:Предприятие» в качестве условного оператора используется оператор Если…Тогда, который реализует выполнение определённых инструкций при условии, что некоторое логическое выражение (условие) принимает значение «истина». Он может использоваться в паре с операторами ИначеЕсли…Тогда (их может быть любое количество) и Иначе или без них. Завершает эту конструкцию ключевое слово КонецЕсли. При необходимости условные операторы можно многократно вкладывать друг в друга.

Синтаксис условного оператора:

Если <Логическое_выражение> Тогда
   
    . . .
ИначеЕсли <Логическое_выражение> Тогда
   
    . . .
Иначе
   
    . . .
КонецЕсли;

Англоязычный вариант:

If <Логическое_выражение> Then
   
    . . .
ElsIf <Логическое_выражение> Then
   
    . . .
Else
   
    . . .
EndIf;

Пример использования:

Если КолПоСчету = 0 Тогда
   Если ОтборСубконто[1] <> 3 Тогда
      Таб.ВывестиСекцию("Секция_8");
   ИначеЕсли ДанныеПоСубсчетам = 1 Тогда
      Таб.ВывестиСекцию("Секция_21");
   Иначе
      Таб.ВывестиСекцию("Секция_17");
   КонецЕсли;
Иначе
   Если ОтборСубконто[1] <> 3 Тогда
      Таб.ВывестиСекцию("Секция_13");
   Иначе
      Таб.ВывестиСекцию("Секция_18");
   КонецЕсли;
КонецЕсли;

Для организации ветвлений внутри выражений используется системная функция ?(). Чаще всего она применяется в формулах ячеек печатных форм, элементов диалога и типовых операций.

Синтаксис функции:

?(<Логическое_выражение>, <Выражение1>, <Выражение2>)

где

• <ЛогическоеВыражение> — логическое выражение (условие), истинность которого проверяется;
• <Выражение1> — выражение, результат вычисления которого станет возвращаемым значением функции при истинности условия;
• <Выражение2> — выражение, результат вычисления которого станет возвращаемым значением функции при ложности условия.

Пример использования функции:

СерияНомерДокумента = ?(ПустоеЗначение(ФизЛицо.ДокументСерия)=1,"",ФизЛицо.ДокументСерия+", ")+ФизЛицо.ДокументНомер;

Операторы циклов

В системе «1С:Предприятие» существует два вида циклов. Для организации первого вида циклов используется оператор Пока (англоязычный синоним — While). Он предназначен для циклического повторения операторов, находящиеся внутри конструкции Цикл…КонецЦикла. Цикл выполняется пока <логическое выражение>, следующее за ключевым словом Пока, является истинным. Условие выполнения цикла всегда проверяется вначале, перед выполнением цикла (то есть возможна ситуация, что цикл не выполнится ни разу).

Синтаксис:

Пока <логическое выражение> Цикл
   
    . . .
КонецЦикла;

Англоязычный вариант:

While <логическое выражение> Do
   
    . . .
EndDo;

Пример организации цикла:

Док = СоздатьОбъект("Документ.БригадныйНаряд");

Док.ВыбратьДокументы('11.01.88', '11.01.99');

Пока Док.ПолучитьДокумент() = 1 Цикл
   
   Состояние(Док.Вид() + " " + Док.НомерДок + " " + Док.ДатаДок);
   Док.ВыбратьСтроки();
   
   Пока Док.ПолучитьСтроку() > 0 Цикл
      Если Док.КодРабот = 104 Тогда
         Сообщить(" " + Док.НомерДок);
      КонецЕсли;
   КонецЦикла;
КонецЦикла;

Ещё один вид циклов, используемый в системе «1С:Предприятие» — это цикл Для…По (англоязычный синоним — For…To). Он также предназначен для циклического повторения операторов, находящиеся внутри конструкции Цикл…КонецЦикла. Перед началом выполнения цикла значение <Выражение1> присваивается переменной <Имя_переменной>. Значение <Имя_переменной> автоматически увеличивается при каждом проходе цикла. Цикл выполняется пока значение переменной <Имя_переменной> меньше или равно значению <Выражение2>. Величина приращения счётчика при каждом выполнении цикла равна 1. Условие выполнения цикла всегда проверяется в начале, перед выполнением цикла (то есть возможна ситуация, что цикл не выполнится ни разу).

Синтаксис:

Для <Имя_переменной> = <Выражение1> По <Выражение2> Цикл
   
    . . .
КонецЦикла;

где

• <Имя_переменной> — идентификатор переменной (счётчика цикла), значение которой автоматически увеличивается при каждом повторении цикла;
• <Выражение1> — числовое выражение, которое задаёт начальное значение, присваиваемое счетчику цикла при первом проходе цикла;
• <Выражение2> — максимальное значение счётчика цикла. Когда переменная <Имя_переменной> становится больше чем <Выражение2>, выполнение оператора цикла прекращается. Величина приращения счетчика при каждом выполнении цикла равна 1.

Англоязычный вариант:

For <Имя_переменной> = <Выражение1> To <Выражение2> Do
   
    . . .
EndDo;

Пример использования:

Выв = СоздатьОбъект("Текст");
Выв.Открыть("D:1S_BaseSSTDBdetail.txt");
Для i = 1 По Выв.КоличествоСтрок() Цикл
   Сообщить(Выв.ПолучитьСтроку(i));
КонецЦикла;

Операторы безусловного перехода

Выполнить безусловную передачу управления на другой оператор программы по указанной метке позволяет оператор Перейти (англоязычный синоним — GoTo). Метка в этом операторе не должна быть меткой перехода на такие операторы, как Процедура или Функция. Область действия оператора Перейти ограничивается программным модулем, процедурой или функцией; он не может передать управление за пределы программного модуля, процедуры или функции. Оператор не может быть также использован для передачи управления на операторы, находящиеся внутри конструкций Если…КонецЕсли и Попытка…КонецПопытки извне этих конструкций, а также на операторы, находящиеся внутри циклов извне этих циклов.

Синтаксис оператора:

Перейти <Метка>;

где <Метка> — специальный идентификатор, начинающийся с символа «~» (тильда) и состоящий из последовательности букв, цифр и символов подчёркивания («_»).

Примечание: Любой исполняемый оператор может иметь метку, используемую в качестве точки перехода в операторе Перейти. Чтобы пометить оператор, надо поместить перед ним метку и следующий за ней символ «:» (двоеточие).

Пример использования:

     
     Выв = СоздатьОбъект("Текст");
     Выв.Открыть("D:1S_BaseSSTDBdetail.txt");
     Для i = 1 По Выв.КоличествоСтрок() Цикл
        Если i = 10 Тогда
           Перейти ~М1;
        КонецЕсли;
        Сообщить(Выв.ПолучитьСтроку(i));
        Перейти ~М2;
~М1:     Сообщить("Это десятая строка");
~М2: КонецЦикла;

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

Синтаксис оператора:

Возврат <ВозвращаемоеЗначение>;

где <ВозвращаемоеЗначение> — выражение, результат которого будет возвращаемым значением функции. Параметр обязателен для оператора Возврат в теле описания функции, но не может использоваться в процедуре.

Пример использования:

Функция ДеньНедели(Номер)
   Если Номер = 1 Тогда
      Возврат "Понедельник";
   ИначеЕсли Номер = 2 Тогда
      Возврат "Вторник";
   ИначеЕсли Номер = 3 Тогда
      Возврат "Среда";
   ИначеЕсли Номер = 4 Тогда
      Возврат "Четверг";
   ИначеЕсли Номер = 5 Тогда
      Возврат "Пятница";
   ИначеЕсли Номер = 6 Тогда
      Возврат "Суббота";
   ИначеЕсли Номер = 7 Тогда
      Возврат "Воскресенье";
   Иначе
      Возврат "Ошибка";
   КонецЕсли;
КонецФункции

Прервать выполнение цикла позволяет безусловный оператор Прервать (англоязычный синоним — Break), вызов которого приводит к немедленному прекращению выполнения цикла и передаче управления первому оператору, следующему за ключевым словом КонецЦикла.

Пример использования:

Функция ПроверитьТипЭлементаАдреса(Стр, ВидЭлемента)
 
   Проверено = 0;
   ТипЭлемента = глТипИзАдреснойСтроки(Стр, ВидЭлемента);
   Если ПустоеЗначение(ТипЭлемента) = 0 Тогда
      ВидПеречисления = Перечисление.ПолучитьАтрибут(ВидЭлемента);
      Для Ном = 1 По ВидПеречисления.КоличествоЗначений() Цикл 
         Если ВидПеречисления.ЗначениеПоНомеру(Ном) = ТипЭлемента Тогда
            Проверено = 1;
            Прервать;
         КонецЕсли;  
      КонецЦикла; 
   КонецЕсли;
	
   Возврат Проверено;

КонецФункции

Изменить порядок выполнение операторов в теле цикла позволяет безусловный оператор Продолжить (англоязычный синоним — Continue), вызов которого приводит к немедленной передаче управления в начало цикла, где производится вычисление и проверка условий выполнения цикла.

Пример использования:

Функция ЕстьДубльЦены()

   ВыборкаЦен = СоздатьОбъект("Справочник.Цены");
   ВыборкаЦен.ИспользоватьВладельца(Владелец);
   ВыборкаЦен.ВыбратьЭлементы();

   Пока ВыборкаЦен.ПолучитьЭлемент() = 1 Цикл
      Если ВыборкаЦен.ТипЦен <> ТипЦен Тогда
         Продолжить;
      КонецЕсли;
      Если Выбран() = 0 Тогда
         
         Возврат ВыборкаЦен.ТекущийЭлемент();
      Иначе
         
         Если ТекущийЭлемент() <> ВыборкаЦен.ТекущийЭлемент() Тогда
            Возврат ВыборкаЦен.ТекущийЭлемент();
         КонецЕсли;
      КонецЕсли;
   КонецЦикла;
	
   Возврат "";

КонецФункции   

Операторы обработки исключений

Оператор обработки исключений Попытка…Исключение…КонецПопытки управляет выполнением программы, основываясь на возникающих при выполнении модуля ошибочных (исключительных) ситуациях и определяет обработку этих ситуаций. Если при выполнении последовательности каких-либо операторов, стоящих после оператора Попытка, происходит ошибка времени выполнения (RunTimeError), то выполнение оператора, вызвавшего ошибку, прерывается и управление передаётся на первый оператор, стоящий за оператором Исключение. При этом управление будет передано даже в том случае, если ошибку вызвал оператор, находящийся в процедуре или функции, вызванной одним из операторов, стоящих после оператора Попытка. Если ошибка произошла в вызванной процедуре или функции, то её выполнение будет прервано, а локальные переменные уничтожены. Это справедливо для любой вложенности вызовов.

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

Синтаксис оператора обработки исключений:

Попытка
   
    . . .
Исключение
   
    . . .
КонецПопытки;

Англоязычный вариант:

Try
   
    . . .
Except
   
    . . .
EndTry;

Пример использования:

Процедура СформироватьВЕхсеl()

   
   Попытка
      
      ТаблЕхсеl = СоздатьОбъект("Excel.Application");
   Исключение
      Предупреждение(ОписаниеОшибки() +
                     "; Excel не установлен на данном компьютере!");
      Возврат;
   КонецПопытки;

   
    . . .

КонецПроцедуры

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

Иногда для того, чтобы при наступлении исключительной ситуации во вложенной конструкции передать управление сразу на внешний обработчик, в тело вложенного обработчика (то есть между операторными скобками Исключение…КонецПопытки вложенной конструкции) помещают специальный оператор ВызватьИсключение (англоязычный синоним — Raise). Данный оператор позволяет искусственно вызывать исключительные ситуации, и система реагирует на его вызов, как на естественно возникшую ошибку. Параметров этот оператор не имеет и может использоваться только внутри операторных скобок Исключение…КонецПопытки.

В выдаче диагностики помощь разработчику может оказать встроенная функция ОписаниеОшибки() (англоязычный синоним имени функции — GetErrorDescription()). Эта функция не имеет параметров, а в качестве значения возвращает описание ошибки, такое же, как было бы выдано в окне сообщений, в случае отсутствия обработчика исключительной ситуации, за исключением описания модуля и строки, в которой ошибка возникла. Применять данную функцию имеет смысл только в теле обработчика (то есть внутри операторных скобок Исключение…КонецПопытки, как это показано в примере выше), так как в ином случае она вернёт пустую строку.

Специальная директива языка

Специальная директива языка #ЗагрузитьИзФайла (англоязычный синоним — #ftLoadFromFile) указывает системе, что загрузку программного модуля следует произвести из указанного файла. Директива должна быть записана в первой строке программного модуля с первой позиции. Остальное содержимое программного модуля конфигурации при этом игнорируется.

Синтаксис:

#ЗагрузитьИзФайла <ИмяФайла>

где <ИмяФайла> — имя файла, содержащего исходный текст программного модуля (записывается без кавычек и скобок).

Примечание: Директива #ЗагрузитьИзФайла является не оператором, а специальной конструкцией, поэтому не должна заканчиваться точкой с запятой.

Использование директивы рекомендуется для отладки, чтобы быстро отлаживать код какого-либо программного модуля без промежуточного сохранения всей конфигурации. Считывание текста файла и его компиляция происходит в момент открытия окна формы (документа, отчёта и т.д.). Таким образом, в режиме исполнения, после внесения изменений и записи файла, содержащего текст модуля, следует просто закрыть и открыть окно формы заново. Внесенные в текст файла изменения сразу сработают.

Для редактирования собственно файла, откуда загружается текст программного модуля, можно использовать встроенный текстовый редактор системы «1С:Предприятие», открывая его через главное меню «Файл -> Открыть». Далее, если выбрать в главном меню «Действия -> Текст модуля», то это позволит при редактировании использовать свойства контекстного выделения цветом синтаксических конструкций языка и установленную для программных модулей ширину табуляции.

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

Пример записи директивы:

#ЗагрузитьИзФайла new_mod.txt

Другие статьи по схожей тематике

• Работа с числовыми значениями
• Работа со строковыми значениями
• Работа с датами
• Функции среды исполнения
• Диалоговые окна
• Форматирование данных

Циклы

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

Циклы с фиксированным количеством проходов.

Для сч = 1 По НужноеКоличествоИтераций Цикл
    //Какие то действия
КонецЦикла

Для сч = 1 По 5 Цикл

Циклы по условию.

Пока А < 100 Цикл
КонецЦикла;

Циклы для обхода коллекций.

Для каждого ЭлементКоллекции Из Коллекция Цикл
	//в переменной ЭлементКоллекции будет одно из значений коллекции 
КонецЦикла

Операторы управляющие ходом цикла.

Продолжить

Процедура Команда1(Команда)
    Для сч = 1 По 100 Цикл
        Если сч / 2 = Цел(сч / 2) Тогда
            Продолжить;
	КонецЕсли;
 
	а = а + 1;
	//и еще какие то действия				
    КонецЦикла;	
КонецПроцедуры

Прервать

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

Использование функций в теле цикла.

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

Использование запросов в теле цикла.

Использование запросов в теле цикла также считается недопустимым. Так как при каждом витке цикла делается запросе к базе данных, а использование запросов подразумевает под собой идеологию «Все нужные данные должны быть получены одним запросом». Если есть возможность, следует проанализировать какие данные будут нужны в цикле, сделать запрос до цикла и в цикле пользоваться уже результатами ранее созданного запроса. Здесь следует добавить пример.