Оператор GOTO в 1С - табу или волшебная палочка?
Разработка - Механизмы платформы 1С
Что такое оператор GOTO?
Оператор GOTO - это базовый оператор для управления потоком выполнения кода. Обычно платформа выполняет код в рамках единого блока (модуля, процедура, тело цикла) по очереди - выполнив одну команду, переходит к выполнению следующей. Но если платформа 1С видит оператор GOTO, то после него начинает выполняться строчка в произвольном месте кода, на которую ссылается этот оператор.
Указание новой точки выполнения кода происходит с помощью Меток, численно-буквенных идентификаторов, которые начинаются на символ ~ (тильда). Требования к идентификатору Метки не столь строги, как к прочим идентификаторам, и допускается делать Метки начиная с числа или даже вовсе без букв. Чтобы выполнить пометку строки, перед ней необходимо указать Метку и двоеточие. При вызове оператора GOTO вместе с ним указывается Метка и точка с запятой.
Пока Истина Цикл
Перейти ~КонецЦикла; // выходим из цикла
Сообщить("Застрял в бесконечном цикле..."); // никогда не выполнится
КонецЦикла;
~КонецЦикла:
Сообщить("Вышел из цикла!");
Переходы ограничены пределами текущих областей видимости - функциями, процедурами и модулями объектов, в которых применяется оператор GOTO. Т.е. у меток для использования переходов есть только пределы локальной видимости (напомню, что, в отличии от многих языков программирования высоких уровней, в 1С для тела Условий и Циклов нет собственной вложенной области видимости).
С появлением 8.2 появилось новое ограничение - запрещено использовать GOTO в коде управляемых приложений, которые должны выполняться на стороне клиента. Ограничение связано с отсутствием реализации оператора в веб-клиенте.
Почему у оператора Goto плохая слава в академической среде?
Изначально в низкоуровневых языках программирования операторы условных и безусловных переходов были единственно доступными операторами управления потоком выполнения. Но с появлением языков программирования высокого уровня появились новые альтернативные и более удобные операторы - Условия и Циклы, с которыми возникла парадигма Структурного Программирования.
Программисты "старой школы", которые уже имели за плечами огромный багаж программирования в машинных кодах и на версиях Ассемблера, с радостью приняли новый "синтаксический сахар", но при этом не отказались от некоторых ранее наработанных алгоритмов на переходах. Использование "не структурных операторов управления" затрудняло понимание и поддержку такого кода молодым поколением программистов, которые никогда ранее не работали с языками низкого уровня. Но было намного хуже, когда эти молодые специалисты видя операторы GOTO у старших товарищей, начинали за ними повторять и активно использовать переходы в своем коде, что должно было продемонстрировать "крутизну", но в результате только превращали их программы в трудно читаемых "монстров" со множеством ошибок. Такой код получил нарицательное прозвище "спагетти-код".
В 1966 году было опубликовано "Доказательство Бема-Якопини", суть которого заключалась в том, что любой алгоритм можно переписать без переходов по меткам на одних только условиях и циклах, хоть это может приводить к существенным потерям в эффективности. В 1968 году голландский ученый Эдсгер Дейкстра, будучи уже известным в ИТ-сообществе после своей публикации алгоритма для поиска кратчайшего пути на графе и после участия в группе разработки компилятора языка Algol, публикует свою статью "О вреде оператора GOTO" (GOTO considered harmful), которая вызвала бурные академические споры. Дейкстра утверждал, что на основе статистического анализа пришел к выводу, что количество ошибок в изученном программном коде прямо пропорционально количеству использованных в тексте программ GOTO и потому предложил радикально улучшить качество программирования введением запрета на данный оператор.
С этого момента начались гонения на оператор GOTO. И запреты на использование оператора часто были настолько фанатично слепы, что за него пришлось публично вступиться таким известным людям как Дональду Кнуту, Брайану Кернигану и Деннису Ритчи, Линусу Торвальдсу, Стиву МакКоннелли и многим другим чуть менее известным. Эти авторитетные люди заявили, что оператор GOTO улучшает скорость, размер и ясность кода программы, но только при разумном использовании разумным программистом.
Любопытные факты. Общеизвестно, что Дейкстра был мало заинтересован в приеме на старшие курсы университета, где он преподавал, студентов со знанием Фортрана по той причине, что вместе с этими знаниями могли привиться дурные привычки программирования. Под дурной привычкой имелось в виду, конечно же, применение GOTO, правила использования которого в Фортране было очень свободным. В результате давления порицанием от научного сообщества в 1978 году в Фортране сначала запретили свободный вход/выход в рамках циклов (до сих пор разрешен в C++), а потом в 1995 запретили почти все прочие варианты переходов.
Откуда у оператора GOTO плохая слава в 1С?
Почему с оператором GOTO все не так однозначно в универсальных высокоуровневых языках, на которых до сих пор делают ассемблерные вставки, более-менее понятно. Но почему в сообществе 1С при виде использования оператора перехода начинается настоящая истерика с криками "четвертовать", "сжечь", "повесить", "волчий билет и запрет на программирование"?
Откуда столько негатива? Ведь язык 1С - это DSL, который не предполагает написание сложных алгоритмов, а потому большая часть программистов пишет простые скрипты и скорее всего даже не догадывается про существование GOTO, а остальные просто помнят о его существовании, но при этом превосходно обходятся без него.
Причина №1 - Академический навык. Далеко не все программисты 1С самоучки или свитчеры из финансистов. Есть те, кто окончили кафедры компьютерных наук и из-за событий непреодолимой силы попали в 1С. А гонения на оператор GOTO - это классика современных компьютерных наук. Таким людям на лекциях сказали, что использование GOTO - это плохо. Если они на экзамене смогли воспроизвести данное утверждение, то получали хорошую оценку и закрепляли навык порицания.
Причина №2 - Портирование внешнего кода. Часто при работе с данными в бинарных форматах, драйверами торгового оборудования и с прочими библиотеками, от поставщика есть пример кода, который легко скопировать в 1С и который после этого даже будет работать. Но ради эффективности такой код часто низкоуровневый и содержит множественные GOTO. Если потом неподготовленному человеку потребуется что-то там исправить, то возникает состояние "плачу кровавыми слезами" и кредо "никогда в жизни не буду связываться с GOTO".
Причина №3 - Обфускация кода. Когда хотят затруднить самостоятельное использование кода клиентом и обеспечить дополнительный доход для поддержки, то код запутывают. Есть несколько вариантов запутывания на уровнях исходного кода и байткода, но практически все варианты для затруднения анализа используют множественные GOTO. Когда такой код видят специалисты клиента, то он вызывает высокий уровень раздражения. Когда такой запутанный код работает с ошибками, которые нужно исправить, а "поставщик" исчез, то раздражение возрастает на порядок.
Любопытные факты. На уровне байткода не существуют никаких структурных операторов, а все условия, циклы, обработки ошибок и процедуры с функциями реализованы на условных и безусловных переходах. Т.е. байткод 1С сильно подобен ассемблеру. Выходит, что изначально для платформы 1С оператор GOTO является "родным", а циклы и условия по своей сути являются "синтаксическим сахаром" для удобства программистов.
Когда можно и нужно использовать GOTO в 1С?
Предыдущий раздел дает часть ответа. Так если в портируемом алгоритме были GOTO, то проще их сохранить, а не терять несколько дней на рефакторинг с риском привнесения ошибок.
Так же без GOTO никуда, если вы решили писать собственную версию обфускатора. Но не рекомендую таким заниматься. Во первых, ниша уже занята и у вас практически нет шансов совершить революцию, чтобы потеснить конкурентов и хотя бы отбить затраты на разработку (даже для себя проще купить чужое решение, чем тратить время на разработку). А во вторых, тех, кто обфусцирует собственный код, никто не любит - это может существенно испортить деловую репутацию (кто занимается отраслевыми решениями меня поймут).
Но все же, а какие адекватные причины могут побудить использовать GOTO при написании своего кода? Предлагаю следующий перечень по возрастанию степени ответственности за принятое решение:
1. Сложный входящий алгоритм
Не всегда мы придумываем свои алгоритмы самостоятельно, иногда нам ставят задачу просто кодировать согласно чужим "блок-схемам". Это может быть как адаптация "под 1С" чужого кода на универсальном языке программирования. Или это может постановка от пользователя, который именно "так" видит решение. И эти внешние алгоритмы могут содержать переходы в произвольные части кода, которые можно реализовать исключительно с помощью GOTO. Что-то такое:

Только на схеме маленький и простой вариант, который легко переделать (о переделке еще вспомним в пункте №3). Но представьте, что к вам пришел руководитель кадровой службы и попросил сделать для него мегакрутую штатную расстановку, на которой будет ВСЁ, и в описании которой десятки таких странных "поворотов сюжета".
Вы можете заявить, что такой алгоритм стоит предварительно "причесать" - структурировать, выровнять линии управления, возможно упростить некоторые условия согласно карт Карно. Но хватит ли у вас квалификации и знания предметной области для написания своего алгоритма? А если вам платят только за программирование, то готовы ли несколько вечеров забрать у своей семьи и жить на работе? А как будете поддерживать написанное? А если к вам снова придет заказчик и скажет - "тут ещё работы на 5 минут", просто добавь в этом блоке новое условие под "новый вчера принятый закон" и утром уже должно быть в "проде" или иначе компанию ждут гигантские штрафы, но вы изначально не учли вероятность изменения законов и для вашего нового алгоритма теперь нужна неделя на "всё переписать"?
Если ответственность за создание алгоритма на другом человеке, то чаще лучше не требовать её на себя и не привносить лишние риски на свою "пятую точку". В конце-концов с нами тоже работают профессионалы и их алгоритмы могут являться не результатом безумия, а компромиссом между "понятностью" и "внешними условиями".
2. Быстрый выход из вложенных циклов
Мало кто знает, но операторы Прервать (Break) и Продолжить (Continue) - это тоже операторы безусловного перехода, подобные GOTO. Первый совершает переход на скрытую метку после цикла, а второй на окончание цикла перед переходом на следующую итерацию. Для нас это чрезвычайно удобные переходы уже как минимум за счет того, что не нужно явно ставить метки и следить за уникальностью их имен - все происходит автоматически. Но не всегда циклы одноуровневые!
Не очень часто, но все же время от времени нужно писать циклы, где уровней очень много - например, обработка данных с группировкой по периодам, видам контрагентов, самим контрагентам, валютам, договорам, заказам и т.д. И далее предположим, что для нашей бизнес-задачи погашения долгов нужно отобрать из этой древовидной структуры данные на определенную сумму, но с хитрым условием, которое прописали юристы в договоре - нужно возвращать деньги за полные поставки с сортировками сначала по дате заключения заказа, а потом по дате фактического прибытия груза. Лимит по сумме тоже хитрый - поскольку и мы и поставщики транснациональные компании, то долги нужно возвращать в разных валютах и при этом действуют независимые лимиты на уровне валюты (ограничения от банков) и в целом по управленческой валюте (ограничение от своих финансистов).
Как обычно делают такие "прыжки" через несколько уровней цикла? На каждом уровне создаются сигнальные переменные, значение которых проверяем при завершении тела цикла. Если значение переменной изменилось, то прерываем выполнение текущего уровня и переходим к проверке значений переменных выше. Но чем больше уровней, чем сложнее будет логика "возврата" - слишком много таких переменных и блоков кода по их проверке.
ВыборкаКонтрагентов = Запрос.Выполнить().Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаКонтрагентов.Следующий() Цикл
ДолгКонтрагента = 0;
ДолгОбщийНайден = Ложь;
ВыборкаВалют = ВыборкаКонтрагентов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаВалют.Следующий() Цикл
ДолгВалютный = 0;
ДолгВалютныйНайден = Ложь;
ВыборкаДоговоров = ВыборкаВалют.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаДоговоров.Следующий() Цикл
ВыборкаЗаказов = ВыборкаДоговоров.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаЗаказов.Следующий() Цикл
ВыборкаОтгрузок = ВыборкаЗаказов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаОтгрузок.Следующий() Цикл
ВыборкаДетальная = ВыборкаОтгрузок.Выбрать(ОбходРезультатаЗапроса.Прямой);
Пока ВыборкаДетальная.Следующий() Цикл
Если ДолгКонтрагента+ВыборкаДетальная.СуммаУпр > ЛимитВозвратаОбщий Тогда
// по этому контрагенту больше не возвращаем
ДолгНайден = Истина;
ИначеЕсли ДолгВалютный+ВыборкаДетальная.Сумма > ЛимитВозвратаВалюты Тогда
// по этой валюте больше не возвращаем
ДолгВалютныйНайден = Истина;
Иначе
ДолгКонтрагента = ДолгКонтрагента+ВыборкаДетальная.СуммаУпр;
ДолгВалютный = ДолгВалютный+ВыборкаДетальная.Сумма;
Если ДолгВалютный = ЛимитВозвратаВалюты Тогда
ДолгВалютныйНайден = Истина;
КонецЕсли;
Если ДолгКонтрагента = ЛимитВозвратаОбщий Тогда
ДолгНайден = Истина;
КонецЕсли;
КонецЕсли;
Если ДолгВалютныйНайден ИЛИ ДолгНайден Тогда
Прервать;
КонецЕсли;
КонецЦикла; // ВыборкаДетальная.Следующий()
Если ДолгВалютныйНайден ИЛИ ДолгНайден Тогда
Прервать;
КонецЕсли;
КонецЦикла; // ВыборкаОтгрузок.Следующий()
Если ДолгВалютныйНайден ИЛИ ДолгНайден Тогда
Прервать;
КонецЕсли;
КонецЦикла; // ВыборкаЗаказов.Следующий()
Если ДолгВалютныйНайден ИЛИ ДолгНайден Тогда
Прервать;
КонецЕсли;
КонецЦикла; // ВыборкаДоговоров.Следующий()
ДобавитьДолгНаВозврат(ВыборкаКонтрагентов.Контрагент, ВыборкаВалют.Валюта, ДолгВалютный);
Если ДолгНайден Тогда
Прервать;
КонецЕсли;
КонецЦикла; // ВыборкаВалют.Следующий()
КонецЦикла; // ВыборкаКонтрагентов.Следующий()
Хотя намного проще в такой ситуации было бы поставить метки "СледующаяВалюта" и "СледующийКонтрагент".
ВыборкаКонтрагентов = Запрос.Выполнить().Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаКонтрагентов.Следующий() Цикл
ДолгКонтрагента = 0;
ВыборкаВалют = ВыборкаКонтрагентов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаВалют.Следующий() Цикл
ДолгВалютный = 0;
ВыборкаДоговоров = ВыборкаВалют.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаДоговоров.Следующий() Цикл
ВыборкаЗаказов = ВыборкаДоговоров.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаЗаказов.Следующий() Цикл
ВыборкаОтгрузок = ВыборкаЗаказов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаОтгрузок.Следующий() Цикл
ВыборкаДетальная = ВыборкаОтгрузок.Выбрать(ОбходРезультатаЗапроса.Прямой);
Пока ВыборкаДетальная.Следующий() Цикл
Если ДолгКонтрагента+ВыборкаДетальная.СуммаУпр > ЛимитВозвратаОбщий Тогда
// по этому контрагенту больше не возвращаем
Перейти ~СледующийКонтрагент;
ИначеЕсли ДолгВалютный+ВыборкаДетальная.Сумма > ЛимитВозвратаВалюты Тогда
// по этой валюте больше не возвращаем
Перейти ~СледующаяВалюта;
Иначе
ДолгКонтрагента = ДолгКонтрагента+ВыборкаДетальная.СуммаУпр;
ДолгВалютный = ДолгВалютный+ВыборкаДетальная.Сумма;
Если ДолгКонтрагента = ЛимитВозвратаОбщий Тогда
Перейти ~СледующийКонтрагент;
ИначеЕсли ДолгВалютный = ЛимитВозвратаВалюты Тогда
Перейти ~СледующаяВалюта;
КонецЕсли;
КонецЕсли;
КонецЦикла; // ВыборкаДетальная.Следующий()
КонецЦикла; // ВыборкаОтгрузок.Следующий()
КонецЦикла; // ВыборкаЗаказов.Следующий()
КонецЦикла; // ВыборкаДоговоров.Следующий()
~СледующаяВалюта:
ДобавитьДолгНаВозврат(ВыборкаКонтрагентов.Контрагент, ВыборкаВалют.Валюта, ДолгВалютный);
КонецЦикла; // ВыборкаВалют.Следующий()
~СледующийКонтрагент:
КонецЦикла; // ВыборкаКонтрагентов.Следующий()
По сути это все еще тот же Прервать, только сразу на нужный нам уровень.
3. Отказ от избыточных подпрограмм (процедур).
Как упоминалось ранее, любой алгоритм с GOTO можно переписать в алгоритм с циклами и условиями. Но что мы получим в результате? Давайте рассмотрим простой пример такого преобразования:

Сразу становится видимой главная проблема - дублирование участков кода. Теперь блок инструкций B вставлен два раза, а блок C - три раза.
Можно так и оставить, но сильно усложняется поддержка - ведь при изменении одного блока, нужно искать его дубликаты и вносить туда аналогичные правки. Автор лично видел очень много подобного дублируемого кода, где "синхронизацией" не заморачивались, что и приводило к проблемам из-за side-effects.
Как известно из теории компьютерных наук, правильным подходом при наличии дублирующих участков является выделение их в отдельные подпрограммы - процедуры, если говорить терминами 1С. Ярким примером, который знаком всем, является расчет стоимости по цене и количеству - алгоритм расчета выносим в отдельную процедуру, которую вызываем не только в рамках текущего алгоритма (например в заполнении по основанию), но и при последующем программировании логики (например в обработчиках изменения количества на форме). При чем для алгоритма не важно, что было передано ему в качестве параметра и он одинаково отработает для табличных частей Товары, Работы, Материалы, Продукция или Полуфабрикаты.
Но не каждая процедура такая универсальная как расчет суммы по цене и количеству. Если нужно выполнить более сложные действия, то тут или нужно усложнять сигнатуру метода и переписывать все вызовы (и потом ловим ошибки в процессе работы, так как благодаря отсутствию типизации в 1С нет контроля на передачу сложных параметров), или внутри процедуры обращаться к метаданным конфигурации и выполнять действия в зависимости от типов и состава реквизитов (и потом получить медленную программу из-за высоких накладных расходов по работе с метаданными), или писать в модули десяти служебных подпрограмм (и получить захламленный и сложно читаемый модуль, так как в 1С не предусмотрено хранение иерархического кода - выделение в Регионы интересная попытка, но пока очень сырая).
А ведь еще не упомянули про то, что выделение кода в подпрограмму - это не "бесплатно". За передачу параметров, за создание нового изолированного контекста и за обслуживание стека вызовов нужно платить дополнительным расходом памяти и процессорного временем.
Любопытные факты. В 1С упомянутый стек вызовов не просто слегка замедляет выполнение программы, но еще и может привести к ее падению, когда он окажется переполнен. В результате просто невозможно реализовать некоторые классы рекурсивных алгоритмов обработки данных - при увеличении входящего потока информации каждый раз получим падения. Из-за этого реализацию действительно "глубоких" рекурсий на 1С можно сделать исключительно с помощью GOTO.
Но вернемся к самому началу - к преобразованию алгоритма на картинке. Мы действительно можем убрать GOTO и за счет обслуживающих "замену" инструментов слегка замедлить выполнение - пусть с 10 миллисекунд до 1 секунды. Какая мелочь - 0,99 секунды ведь никто не заметит, это же "квантовое измерение" и замедление в 100 раз это ни о чем. Хотя СТОП! А если этот маленький кусочек кода находится в цикле, который при обычных условиях выполняется один час (какой-нибудь парсинг цен конкурентов), то теперь этот цикл займет 100 часов, или другими словами остановит работу на четыре дня вместо традиционного перекура, к которому уже все привыкли.
Итого. Если у нас есть возможность "почистить" модуль от десятка служебных процедур, сделать код алгоритма более читаемым, а общее время выполнение ускорить на один-два порядка, то не вижу здравых причин от этого отказываться. Зачем делать закрытие месяца с расчетом себестоимости продукции на протяжении дня-недели, если есть возможность ускорить до часа-двух?
4. Создание динамических алгоритмов (метапрограммирование).
Программистам на языке 1С не часто, но все же попадаются интересные и сложные задачи. Сложные не из-за большого объема или необходимости изучения новой документации, а из-за отсутствия фиксированного алгоритма решения. Это потребность создавать динамические алгоритмы, ход выполнения которых зависит от неких внешних условий.
Это может быть код, который генерируется "на лету" для обменов по "Конвертация данных 2". Или это может быть интеграция по некоторому хитрому формату внешних данных, правила обработки которого являются частью данного формата. Или возможно вы делаете NoCode-инструмент, чтобы ваши пользователи сами писали сложную обработку данных просто накликивая требуемую им блок-схему.
Т.е. у вас может быть только информация о базовом наборе "кирпичиков" для будущего алгоритма и правила для их объединения, но никаких догадок о том, в какие финальные конфигурации они будут складываться.
Подобное метапрограммирование на 1С делается двумя способами:
- формированием текста будущей программы и запуск ее с помощью команды Выполнить (Execute);
- формированием текста будущей программы, запись ее во внешнюю обработку с помощью популярной утилиты v8unpack, а затем запуск этой обработки.
У первого способа есть ограничения, которые накладываются платформой 1С:
- отсутствие вложенных контекстов и работа только с контекстом точки вызова;
- отсутствие возможности создания процедур и функций;
- запрет на использование ключевого слова Возврат (Return).
Команда Выполнить изначально задумывалась для запуска фрагмента, а не полноценного кода, и потому тут использование операторов GOTO максимально облегчит нашу работу. Во первых, упрощается стыковка "кирпичиков" - на вход следующего фрагмента вставляем метку, а на выходе из требуемых предыдущих блоков делаем переход на эту метку. Во вторых, при описании содержимого самих "кирпичиков" мы можем избежать самоповтора кода (см. часть "Отказ от избыточных подпрограмм").
У второго способа (создание внешней обработки) нет никаких платформенных ограничений и мы можем генерировать полноценный код согласно парадигме структурного программирования без всяких, так сказать, "мерзких" GOTO. Но есть ряд нюансов, с которыми нужно будет сперва побороться:
- Этот метод в целом не поддерживается и не поощряется фирмой 1С. Утилита v8unpack (и ей подобные) создана независимыми программистами, которые предоставляют свою работу в OpenSource по модели "AS IS" - т.е. если у вас возникают проблемы, то решение их будет вашей личной задачей.
- Установка и запуск утилиты v8unpack на сервере 1С может быть связана со сложностями. Особенно если это не ваш сервер, а местные системные администраторы очень настороженно относятся к малоизвестным программам из интернета.
- Запись внешней обработки на диск и её последующее чтение могут быть заблокированы антивирусом или сбоем файловой подсистемы.
- При загрузке внешних обработок иногда происходят сбои. Если вы каждый раз не генерируете новое уникальное название, то часто программный кэш не очищается и 1С работает со старыми версиями обработок. Но и смена названий не панацея - иногда внешние обработки по непонятным причинам просто не работают (возможно сбои реализации защищенного режима?).
Заключительное слово
Позиция автора статьи предельно прозрачна - не нужно быть столь категоричными к оператору GOTO. Иногда с ним код становится красивым и более понятным. Иногда использование GOTO экономит часы и дни разработки. Иногда его наличие позволяет оптимизировать сложные расчеты и выполнить их в разумные сроки.
У нас на платформе 1С и так слишком много технологических ограничений, чтобы мы еще дополнительно себя ограничивали. Главное не боятся взять на себя ответственность и предварительно дать утвердительные ответы на следующие вопросы:
- точно ли будет ощутимый эффект от применения GOTO?
- точно ли ваш код будет понятен другим, кто станет его поддерживать?
- хорошо ли вы продумали ваш алгоритм и уверены в отсутствии "побочных эффектов"?
post scriptum
Автор статьи достаточно видел применение GOTO в различном коде (даже в популярных Инструментах разработчика), но при этом ни разу не сталкивался с проблемами, которые вызвал именно факт его использования. Возможно у читателей есть подобный опыт? Буду чистосердечно благодарен, если поделитесь в комментариях.
Вступайте в нашу телеграмм-группу Инфостарт
программирование перейти метка goto label
Вы можете заказать платную адаптацию этой статьи под ваши задачи на «Бирже заказов».
- 0% комиссии — оплата напрямую исполнителю;
- Исполнители любого масштаба — от отдельных специалистов до команд под проект;
- Прямой обмен контактами между заказчиком и исполнителем;
- Безопасная сделка — при необходимости;
- Рейтинги, кейсы и прозрачная система откликов.
См. также
Механизмы платформы 1С Разработчик Бесплатно (free)
Разберем 15 мифов о работе платформы «1С:Предприятие 8» – как распространенных, так и малоизвестных. Начнем с классики: «Код, написанный в одну строку, работает быстрее, чем многострочный». Так ли это на самом деле?
16.07.2025 45896 TitanLuchs 109
Работа с интерфейсом WEB-интеграция Механизмы платформы 1С Бесплатно (free)
Веб-интерфейсы повышают качество внешнего вида приложений 1С, предсказуемы с точки зрения верстки, позволяют организовать удобные и высокопроизводительные рабочие места для пользователей. Расскажем об особенностях разработки веб-интерфейсов на React внутри 1С, двустороннем взаимодействии 1С и JavaScript, а также сборке веб-приложения в одностраничный файл.
19.06.2025 18922 zeegin 15
Механизмы платформы 1С Работа с интерфейсом Разработчик Стажер 1С:Предприятие 8 Бесплатно (free)
Про ООП в 1С и о том, как сделать свой код более кратким и выразительным при помощи использования текучего интерфейса (fluent interface).
03.02.2025 26176 bayselonarrend 127
Механизмы платформы 1С Разработчик 1С:Предприятие 8 Бесплатно (free)
В этой статье подробно рассматривается работа с JSON в XDTO в 1С:Предприятие. Вы узнаете, как сериализовать и десериализовать объекты XDTO в JSON, интегрировать 1С с веб-сервисами и API, а также корректно обрабатывать данные при обмене. Разбираются особенности работы с коллекциями, использование функций восстановления и частые ошибки при работе с JSON и XDTO.
30.01.2025 33549 user2122906 10
Механизмы платформы 1С Файловый обмен (TXT, XML, DBF), FTP Разработчик 1С:Предприятие 8 Бесплатно (free)
Этот материал познакомит вас с механизмом XDTO (XML Data Transfer Objects) в 1С и научит эффективно использовать его возможности. Мы разберёмся, как работать с XML-схемами, создавать модели данных, манипулировать объектами XDTO, а также сериализовать и десериализовать их в XML. Вы узнаете, как использовать XDTO для интеграции с внешними системами, избегать типичных ошибок и оптимизировать код. К концу вы будете уверенно применять XDTO для решения сложных задач обмена данными и автоматизации процессов.
17.01.2025 56392 user2122906 13
Механизмы платформы 1С WEB-интеграция Разработчик 1С:Предприятие 8 Бесплатно (free)
В платформе 8.3.27 появилась возможность использовать WebSocket-клиент. Давайте посмотрим, как это все устроено и чем оно нам полезно.
14.01.2025 47159 dsdred 110
Механизмы платформы 1С Разработчик 1С:Предприятие 8 Бесплатно (free)
Особенности "Знач" и разбор документации к нему.
10.01.2025 26660 VAAngelov 60
Механизмы платформы 1С Разработчик Стажер 1С:Предприятие 8 1C:Бухгалтерия Бесплатно (free)
Эта небольшая статья - некоторого рода шпаргалка по файловым потокам: как и зачем с ними работать, какие преимущества это дает.
23.06.2024 40711 bayselonarrend 24
Код |
|---|
Процедура ДолгВалютный(ВыборкаВалют, ДолгКонтрагента, ДолгВалютный)
ВыборкаДоговоров = ВыборкаВалют.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаДоговоров.Следующий() Цикл
ВыборкаЗаказов = ВыборкаДоговоров.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаЗаказов.Следующий() Цикл
ВыборкаОтгрузок = ВыборкаЗаказов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаОтгрузок.Следующий() Цикл
ВыборкаДетальная = ВыборкаОтгрузок.Выбрать(ОбходРезультатаЗапроса.Прямой);
Пока ВыборкаДетальная.Следующий() Цикл
Если ДолгКонтрагента+ВыборкаДетальная.СуммаУпр > ЛимитВозвратаОбщий Тогда
Возврат;
КонецЕсли;
Если ДолгВалютный+ВыборкаДетальная.Сумма > ЛимитВозвратаВалюты Тогда
Возврат;
КонецЕсли;
ДолгКонтрагента = ДолгКонтрагента+ВыборкаДетальная.СуммаУпр;
ДолгВалютный = ДолгВалютный+ВыборкаДетальная.Сумма;
КонецЦикла; // ВыборкаДетальная.Следующий()
КонецЦикла; // ВыборкаОтгрузок.Следующий()
КонецЦикла; // ВыборкаЗаказов.Следующий()
КонецЦикла; // ВыборкаДоговоров.Следующий()
КонецПроцедуры
Процедура ДолгиКонтрагента(ВыборкаКонтрагентов, ДолгКонтрагента)
ВыборкаВалют = ВыборкаКонтрагентов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаВалют.Следующий() Цикл
ДолгВалютный = 0;
ДолгВалютный(ВыборкаВалют, ДолгКонтрагента, ДолгВалютный);
ДобавитьДолгНаВозврат(ВыборкаКонтрагентов.Контрагент, ВыборкаВалют.Валюта, ДолгВалютный);
КонецЦикла;
КонецПроцедуры
Процедура РасчитатьДолги(Запрос)
ВыборкаКонтрагентов = Запрос.Выполнить().Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
Пока ВыборкаКонтрагентов.Следующий() Цикл
ДолгКонтрагента = 0;
ДолгиКонтрагента(ВыборкаКонтрагентов, ДолгКонтрагента);
КонецЦикла; // ВыборкаКонтрагентов.Следующий()
КонецПроцедуры
Показать |
Т.е. у вашего решения есть плюс - не нужно вручную отслеживать наименование меток, можно использовать подсказки от EDT. Но есть и минусы - кода банально больше и возникает задача его упорядочить; появляются уровни абстракции усложняющие доработку, контекст модуля разбухает и потребляет чуть больше ресурсов.
P.S. Тогда и от Прервать/Продолжить можно отказаться - все отлично декомпозируется на систему вложенных процедур и функций.
КОД |
|---|
Процедура РасчитатьДолги2(Запрос)
ВыборкаКонтрагентов = Запрос.Выполнить().Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
ТекущийУровень = 1;
Пока (ТекущийУровень >= ВыборкаКонтрагентов.Уровень()) И (ВыборкаКонтрагентов.Следующий()) Цикл
ДолгКонтрагента = 0;
ВыборкаВалют = ВыборкаКонтрагентов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
ТекущийУровень = ВыборкаВалют.Уровень();
Пока (ТекущийУровень >= ВыборкаВалют.Уровень()) И (ВыборкаВалют.Следующий()) Цикл
ДолгВалютный = 0;
ВыборкаДоговоров = ВыборкаВалют.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
ТекущийУровень = ВыборкаДоговоров.Уровень();
Пока (ТекущийУровень >= ВыборкаДоговоров.Уровень()) И (ВыборкаДоговоров.Следующий()) Цикл
ВыборкаЗаказов = ВыборкаДоговоров.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
ТекущийУровень = ВыборкаЗаказов.Уровень();
Пока (ТекущийУровень >= ВыборкаЗаказов.Уровень()) И (ВыборкаЗаказов.Следующий()) Цикл
ВыборкаОтгрузок = ВыборкаЗаказов.Выбрать(ОбходРезультатаЗапроса.ПоГруппировкам);
ТекущийУровень = ВыборкаОтгрузок.Уровень();
Пока (ТекущийУровень >= ВыборкаОтгрузок.Уровень()) И (ВыборкаОтгрузок.Следующий()) Цикл
ВыборкаДетальная = ВыборкаОтгрузок.Выбрать(ОбходРезультатаЗапроса.Прямой);
ТекущийУровень = ВыборкаДетальная.Уровень();
Пока (ТекущийУровень >= ВыборкаДетальная.Уровень()) И (ВыборкаДетальная.Следующий()) Цикл
Если ДолгКонтрагента+ВыборкаДетальная.СуммаУпр > ЛимитВозвратаОбщий Тогда
// по этому контрагенту больше не возвращаем
ТекущийУровень = ВыборкаКонтрагентов.Уровень();
Прервать;
ИначеЕсли ДолгВалютный+ВыборкаДетальная.Сумма > ЛимитВозвратаВалюты Тогда
// по этой валюте больше не возвращаем
ТекущийУровень = ВыборкаВалют.Уровень();
Прервать;
Иначе
ДолгКонтрагента = ДолгКонтрагента+ВыборкаДетальная.СуммаУпр;
ДолгВалютный = ДолгВалютный+ВыборкаДетальная.Сумма;
Если ДолгКонтрагента = ЛимитВозвратаОбщий Тогда
ТекущийУровень = ВыборкаКонтрагентов.Уровень();
Прервать;
ИначеЕсли ДолгВалютный = ЛимитВозвратаВалюты Тогда
ТекущийУровень = ВыборкаВалют.Уровень();
Прервать;
КонецЕсли;
КонецЕсли;
КонецЦикла; // ВыборкаДетальная.Следующий()
КонецЦикла; // ВыборкаОтгрузок.Следующий()
КонецЦикла; // ВыборкаЗаказов.Следующий()
КонецЦикла; // ВыборкаДоговоров.Следующий()
ДобавитьДолгНаВозврат(ВыборкаКонтрагентов.Контрагент, ВыборкаВалют.Валюта, ДолгВалютный);
КонецЦикла; // ВыборкаВалют.Следующий()
КонецЦикла; // ВыборкаКонтрагентов.Следующий()
КонецПроцедуры
Показать |
Скорее всего, про это есть в .
Также, в типовых конфигурациях стараются избегать конструкций Попытка - Исключение. Пользователю надо показывать ошибки, чтобы он реагировал и звал программиста. Плюс, "Попытка-Исключение" - это часто лень разработчика (ON ERROR RESUME NEXT). Будет вторая статья на эту тему?))
Лень программиста писать обработку исключений - не повод для игнорирования конструкции очень важной для избегания падения критического кода во время исполнения.
Кроме того, это единственный способ не обрушить программу при выполнении явных преобразований типов.
Вот пример:
БП 3.0.130.22
"КонецПопытки;" = 9 935 раз;
"КонецЦикла;" = 147 801 раз; (почти в 15 раз больше)
"КонецЕсли;" = 632 876 раз; (почти в 64 раза больше)
Перейти ~ = 24 раза; Отчет.РегламентированныйОтчетПрибыльИностраннойОрганизации.Форма.ФормаОтчета2014Кв1.Форма.Модуль
Если Делитель<>0 Тогда
Частное = Делимое / Делитель;
Иначе
Частное = 0;
КонецЕсли;Попытка
Частное = Делимое / Делитель;
Исключение
Частное = 0;
КонецПопытки;(18)
КонецПроцедуры = 301 557 раз;
КонецФункции = 100 707 раз;
Суммарно(кп+кф) = 402 264 раз;
//(кп+кф) = (КонецПроцедуры + КонецФункции)(42)
(34) Техподдержка, пользователь присылает скриншот ошибки, доступа в базу пользователя нет (в журнал не зайти). Связи с пользователем нет. Раньше по скрину ошибки можно было хотя-бы увидеть строку кода, найти и проанализировать его, сейчас - нет.
(35) Работу с транзакциями стараюсь всегда делать без Попытка-Исключение. При исключениях, как и при выходе из процедуры, если транзакция не была зафиксирована - происходит *. Обработку больших массивов данных - тоже стараюсь делать без попыток, и, например, при обмене данными 1С - если происходит ошибка, предпочтительнее завалить обмен, чем продолжать грузить инфу с непонятными искажениями. Если же выбирается "продолжить в случае ошибки", то как минимум, ошибки эти где-то нужно собирать и мониторить.
(43) Согласен с Вами. Судя по обилию комментариев и интересу к теме - надо бы написать статью))
--
Писать код, который будет избегать ошибок (с проверками на тип данных, на наличие поля у справочника и т.п.) - всегда сложнее, чем воткнуть "Попытка - Исключение", но использовать второй вариант - это, скорее, лень программиста. Вот я о чем толкую.
Однако, всё-же, есть фрагменты кода, где нет возможности избежать исключительных ситуаций (например, работа с внешними обработками, работа с интернет-функциям), но нужно их обработать и при ошибке выполнить альтернативный алгоритм.
Сама по себе попытка это же не некое условие, а обработка нештатной ситуации во время которой платформа выполняет затратные по ресурсам операции, строит тот же стек вызова, формирует там у себя в мозгах текст ошибки и прочие прелести, что явно дольше отрабатывает нежели проверка на 0 в простом Если. Можно конечно тип переменной еще проверить и если не число тогда ошибку выкинуть самостоятельно мол типа чего вы пытаетесь число на строку поделить, но это уже тоже вызывает доп расходы на вычисления этих типов данных. Тут бы помогла статическая типизация но ее в 1С нет.
Можно так же смело заявить, что 1С умышленно не использует циклы с условием (Пока условие Цикл), и везде их заменяет на Циклы типа Для Каждого или Для Индекс = 0 По...
Конечно же всему свое применение и назначение.
А
А вот если бы существовала альтернативная Попыткам методология написания стабильного кода, то это реально хорошая тема для статьи.
Речь о том, что пока ты доберешься до своей РЕАЛЬНОЙ ошибки - тебе надо продраться через тонну остановок в местах где прогеру тупо лень было типы значений проверить.
И использовать «остановку по ошибке» уже не хочется. Потому что палец на ф5 уже устал.
Моё мнение - попытка должна быть только в проде в критичном коде в новых участках (чтобы точно не упало) при срочной доработке
| Код |
|---|
Попытка
// делаем что-то умное приводящее к ошибке
Исключение
// ничего не делаем
КонецПопытки;
Показать полностью |
Я наоборот часто делаю эскалацию ошибки выше, чтобы вызывающий код страдал от своей тупости что передает невесть что приводящее к ошибкам.
| Код |
|---|
Попытка
// делаем что-то умное приводящее к ошибке
Исключение
// делаем что-то умное, что обязательно надо сделать при возникновении ошибки
ВызватьИсключение; // даем вызвавшему коду понять что он олень
КонецПопытки;
Показать полностью |
Судя по вашей логике, разработчики так же против использования транзакций - всего 1368 раз встречается НачатьТранзакцию() в той же УТ (это у меня еще и с кучей расширений, а если брать "чистую", то еще меньше)
А использовать GoTo народ просто фактически не умеет - выросло уже не одно поколение прикладных программистов, которые фактически даже не знают что это такое и для чего нужно. Поэтому-то и обфускация множественными goto так дико бесит. А на самом деле это один из самых простых для распутывания способ.
И это только то что первое в голову пришло.
Если мы дорабатываем типовую функцию в расширении с директивой &ИзменениеИКонтроль и нам по какой-то причине нужно пропустить большое количество строк типового кода и перескочить в середину процедуры.
&ИзменениеИКонтроль
Функция СложныйМногоступенчатыйАлгоритмНа100500Строк()
//100500 строк нужного кода
#Вставка
Перейти ~ПропуститьНенужныйКод;
#КонецВставки
//100500 строк НЕ нужного кода
#Вставка
~ПропуститьНенужныйКод:
#КонецВставки
//100500 строк нужного кода
КонецФункции
Показать>Если Ложь Тогда
>КонецЕсли
менее наглядно для последующей поддержки, т.к. сложно будет найти поиском/глазами конец фрагмента пропускаемого кода
>Да просто закомментировать
ломает последующее обновление
>#Удаление
>#КонецУдаления
подойдёт для этого упрощённого примера (хотя проблема быстрого поиска окончания пропускаемого кода остаётся), но неприменимо, если его немного усложнить, когда "100500 строк НЕ нужного кода" нужно выполнять в одних случаях, а в других не выполнять
Т.е. если усложнять пример "разумного использования", то он будет выглядеть так:
&ИзменениеИКонтроль
Функция СложныйМногоступенчатыйАлгоритмНа100500Строк()
//100500 строк нужного кода
#Вставка
Если НЕ НадоВыполнитьКусокТиповогоКода Тогда
Перейти ~ПропуститьНенужныйКод;
КонецЕсли;
#КонецВставки
//100500 строк НЕ нужного кода
#Вставка
~ПропуститьНенужныйКод:
#КонецВставки
//100500 строк нужного кода
КонецФункции
ПоказатьЗначение флага "НадоВыполнитьКусокТиповогоКода" зависит от определенных условий
Использование "Вместо" в этом примере вообще очень плохо, т.к. ломает обновление
Тех, кто использует GoTo на ЯВУ, надо по пальцам бить. Кроме запутанности кода никакого прироста производительности на практике от него нет. Если не умеете обходиться без GoTo, то может быть лучше перестроить алгоритм или сменить профессию ?
GoTo только для низкоуровневого программирования и для прошивок микроконтроллеров.
А вот про создание собственного обфускатора с автором не согласен - пишу свой с применением самых лучших практик и добавлением своих фишек.
Может невнимательно читал, но в статье не уловил довольно важный момент - переходы по меткам разрешены в пределах видимости и только внутри текущих конструкций языка, т.е. внутрь соседнего цикла/условия/попытки снаружи запрыгнуть нельзя.
Да. Насчитал в инструментах разработчика 9 статических и 3 генерируемых переходов по меткам. Всегда не испытывал за них стыда. Наоборот даже горжусь тем, что я умею их применять.
Такая была в генераторе в консоли кода ИР на платформе 8.3.11+, где изменили кэширование внешних обработок
Но я нашел ее . Предлагаю добавить эту информацию в статью раз уж ты решил так глубоко копнуть.
В конце недели планирую вычитать все комментарии и подправить статью - сделать акцент на то, что нельзя прыгать внутрь циклов/условий/попыток и добавить интересный код. Ну и решение с внешними обработками добавлю, раз оно есть.
Но не все, кто академически занимается и программированием тоже, заканчивали какие-то кафедры (да, я там работал, но знаю и тех, кто вообще ничего не заканчивал, но они жали руки кнутам и дейкстрам направо и налево). И пункт номер РАЗ - это надуманный пункт, т.к. разные методы расчета - это функции. В части выхода из циклов, ветвлений и т.д. - полностью поддерживаю. По поводу отказа в ряде случаев от процедур и функций, то очень зыбкое такое допущение. Может быть в каком-то пограничном варианте это может привести к какой-то пользе.
Да, иногда использую "гото" для выхода из циклов и ветвлений и для того, чтобы не пилить лишний цикл на два шага (типа в последний день месяца делаем это два раза, а в остальные дни месяца - раз, тут как раз случай, когда код не выносится в процедуру, хотя можно было бы это сделать и вызвать функцию раз для дня и еще раз, если он последний в месяце, но если в функцию приходится тащить кучу локальных переменных, то пилить сто параметров или засовывать их все в структуру - это как-то убого выглядит, т.е. сильно хуже, чем "гото").
В общем, "гото" - это хорошо в некоторых случаях (как соль в еде), хотя тех, кто учился на кафедрах и не смог на достаточном уровне познать дзен-программинг, часто с "гото" плющит и колбасит. Прям как последователей чумаков, которым сказали, что вода в крещение течет заряженная с крана...
ЗЫ: Сам последний раз в 1С "гото" употреблял очень давно - года три назад. Мало в 1С сложного в последнее время требуется. А простое можно и без "гото" написать.
Причем, на практике заметил, что наиболее яркие противники ничего не имеют против Возврат, Продолжить или Прервать, хотя это тоже безусловные переходы, только к предопределённым точкам
Тоесть в итоге я вижу графическое представление кода 1С на схеме. А код в конфигуратор, с расставлением GoTo делает сам программа. Я работаю только над логикой решения в графическом виде. Очень удобно. Делаю целые проекты так уже лет 15.
Этот код УЖАСЕН. И 1-й вариант ужасный и 2-й тем более! Те кто так пишет - никогда этого не делайте. НИКОГДА!
Я должен понимать ваш код и мне не должно быть от него тошно. На примереах - как раз этот случай.
Книга "Чистый код" почитайте.
Автор, а Вы тестили goto на производительность? Есть такое предположение, что все будет тупить.
Ну и ухудшение читаемости - очевидно
В первом варианте что мы делаем? Ищем должников? Ок, мы ищем должников, если лимит долга превышен - взводим семафор, что долг найден, прерываем кучу вложенных циклов, выполняем ДобавитьДолгНаВозврат. Ок, а если за все итерации всех циклов долга не накопилось и семафоры не взвелись? Мы... все равно добавляем долг на возврат! Ни один из семафоров не используется, они просто предназначены, чтобы прервать бессмысленный цикл пораньше. Г - лоГика...
Но ок, может тут что-то не так и так и задумано? Мы пытаемся "улучшить" этот адов угар с помощью Перейти... и нарушаем логику кода. Потому что теперь при превышении лимита общего долга, там, где взводился внешний семафор, мы... переходим по метке, ПЕРЕПРЫГИВАЯ вызов нашей ДобавитьДолгНаВозврат, которая для данного контрагента никогда не выполнится...
Автор, огромное спасибо за демонстрацию того, как при попытке "улучшить" нечитаемый говнокод можно шикарно выстрелить себе в ногу использованием ненужных операторов не в том месте... Надеюсь, за прошедшие полтора года вы научились использовать булевы поля в запросах вида СУММА(...) < &Лимит КАК ЭтоДолжник и перестали ваять подобные мозговыносящие обходы шестикратно вложенных выборок там, где это можно заменить одной строкой в запросе...
P.S. Мне реально жаль вашего работодателя...
И ни одного примера, хоть как-то подтверждающего эти слова. Ну чтобы менее красивый и менее понятный код без goto, и аналогичный ему, но более красивый и понятный с goto
Вы можете заказать платную консультацию или разработку у автора. Будет создан приватный заказ на «Бирже заказов» для автора.
№ 1790973
Создание 19.02.23 15:00
Обновление 19.02.23 15:00
Просмотры 22671
Загрузки 0
Рейтинг
56
Комментарии 80
Код открыт Да
Рубрики Механизмы платформы 1С
Кому Разработчик
Тип файла Нет файла
Платформа 1С:Предприятие 8
Конфигурация Универсальные
Операционная система Не имеет значения
Страна Не имеет значения
Отрасль Не имеет значения
Налоги Не имеет значения
Вид учета Не имеет значения
Доступ к файлу Бесплатно (free)