Красота разработки в 1С, или художественная верстка кода
Разработка - Рефакторинг и качество кода
Я буду употреблять слово «Функция», но под этим буду иметь в виду «Функции» и «Процедуры».
Большинство статей по оформлению кода это описание комментариев, заголовков функций и нумерации обработок. Но разве на этом заканчивается правила написания чистого кода? Вам будет важно, кто написал код, если это процедура на 5000 строк, которая делает «всё»? Ну если только для того, чтобы проклясть этого человека, да и дата написания кода вам не особо поможет. А что же тогда важно? По моему мнению, это читаемость и простота отладки. Не будем сейчас разбирать правильность и скорость выполнения, а поговорим только об оформлении.
Существует 10 правил, которые позволяют NASA писать миллионы строк кода с минимальными ошибками и, взяв 2 за отправную точку, я вывел для себя следующие правила написания кода для 1С.
- Одна функция – одно действие. Это убирает задвоение кода (на практике я встречал сокращения строк кода после рефакторинга в 3 раза!) Это позволяет использовать функции повторно, а не каждый раз заниматься написанием заново.
Процедура ЗаполнитьДокументРеализациюТоваров(ДанныеЗаполнения) РеализацияТоваровСсылка = Документы.РеализацияТоваровУслуг.НайтиДокументРеализации(ДанныеЗаполнения); Если НЕ ЗначениеЗаполнено(РеализацияТоваровСсылка) Тогда РеализацияТоваровОбъект = Документы.РеализацияТоваровУслуг.СоздатьДокумент(); Иначе РеализацияТоваровОбъект = РеализацияТоваровСсылка.ПолучитьОбъект(); КонецЕсли; Документы.РеализацияТоваровУслуг.ЗаполнитьДокументРеализации(РеализацияТоваровОбъект,ДанныеЗаполнения); Результат = РаботаСДокументамиСервер.ЗаписатьДокументВПопытке(РеализацияТоваровОбъект); Если НЕ Результат.Ошибка Тогда ИнтерактивнаяРабота.СообщитьПользователю("Всё хорошо"); Иначе ИнтерактивнаяРабота.СообщитьПользователю(Результат.ОписаниеОшибки); КонецЕсли; КонецПроцедуры - Размещать функции там, к чему функция относятся. То есть не надо все функции стараться запихнуть в один модуль. Чем точней вы будете размещать функции, тем чаще вы будите их находить и использовать повторно. Если функция относится к документу реализации, то надо ее размещать в менеджере реализации. Так вы будете чаще находить уже готовые функции, даже если забыли, что их когда-то писали.
Процедура Хорошо() Документы.РеализацияТоваровУслуг.НайтиДокументРеализации(); РаботаСДокументамиСервер.ЗаписатьДокументВПопытке() КонецПроцедуры Процедура Плохо() РазноеМоё.НайтиДокументРеализации(); РазноеМоё.ЗаписатьДокументВПопытке(); КонецПроцедуры - Делите общие модули по логике работы. Почти то же самое, что и пункт 2, но про общие модули. Не надо делать модуль с именем "Разное" или "Общее". Называйте их "РаботаСТабличнойЧастьюДокументов", "ЗагрузкаДанныхFTP" и не надо бояться модулей в одну функцию, придет время и вы его расширите, да если даже и нет, зато не будет бардака в других модулях.
Процедура Хорошо() РаботаССправочникамиСервер.ЗаписатьСправочникВПопытке(); РаботаСДокументамиСервер.ЗаписатьДокументВПопытке() КонецПроцедуры Процедура Плохо() РазноеМоё.ЗаписатьСправочникВПопытке(); РазноеМоё.ЗаписатьДокументВПопытке(); КонецПроцедуры - Не называйте функции «от балды». Называйте максимально однотипно, например я взял следующий формат. Все функции должны начинаться с глагола и обязательно содержать в наименовании тип данных, с чем производится действие. («Заполнить», «Получить», «Найти» и т.д.) + («Документ», «Справочник», «Структура», «ТаблицаЗначений» и т.д.). Это позволит быстрей читать свой же код, а не раздумывать на тему, что я имел в виду, когда назвал функцию "БыстроСпрВ(до)"
Процедура Хорошо() ТекстЗапроса = ПолучитьТекстЗапросаПоискаРеализации(); КонецПроцедуры Процедура Плохо() ТекстЗапроса = ЗапросТекст(); КонецПроцедуры - Специально для не любителей «НЕ» и «<>» в условиях. Где-то я встречал рекомендацию, и она мне понравилась: В условиях первая группа команд та, которая чаще выполняется. Так код смотрится читабельней.
Процедура Хорошо() Ошибка = Ложь; ОписаниеОшибки = ""; Попытка Документ.Записать(); Исключение ОписаниеОшибки = ОписаниеОшибки(); Ошибка = Истина; КонецПопытки; Если НЕ Ошибка Тогда Сообщить("Всё хорошо"); Иначе Сообщить(ОписаниеОшибки); КонецЕсли; КонецПроцедуры Процедура Плохо() Ошибка = Ложь; ОписаниеОшибки = ""; Попытка Документ.Записать(); Исключение ОписаниеОшибки = ОписаниеОшибки(); Ошибка = Истина; КонецПопытки; Если Ошибка Тогда Сообщить(ОписаниеОшибки); Иначе Сообщить("Всё хорошо"); КонецЕсли; КонецПроцедуры - Результат условия в одну команду пишите одной строкой. Самое частое, где я это использую, это когда после ТОГДА идет только ВОЗВРАТ; или ПРОДОЛЖИТЬ;. Исключение если есть ИНАЧЕ или ИНАЧЕЕСЛИ.
Когда растягивают короткое условие на 3 (иногда 5) строк. Читабельность это только ухудшает.
Процедура Хорошо(Значение) Если Значение = Неопределено Тогда Возврат ложь; КонецЕсли; Возврат Истина; КонецПроцедуры Функция Плохо(Значение) Если Значение = Неопределено Тогда ЭтоНеопределено = Истина; Иначе ЭтоНеопределено = Ложь; КонецЕсли; Возврат ЭтоНеопределено; КонецФункции -
Тексты запросов выносите в отдельные функции. Длинные запросы, больше обычной выборки с условием, стоит выносить в отдельную функцию. Код становится компактней, а для отладки текста запроса код модуля не нужен.
Думаю тут и без примера понятно.
-
Удаляйте ненужный код. Я, конечно, понимаю, что удалять код, который вы писали многие часы, жалко, но оставлять простыни зеленого кода тоже не стоит, особенно когда между двумя простынями есть одна не закомментированная строка, а за оставление не использованных функций без комментирования, считаю, надо лишать прав на программирование.
Зеленый код ЗЛО!
-
Не комментируйте каждую строку. Код должен быть легко читаемый и без комментариев. Писать комментарии стоит только у правда сложных алгоритмов, а излишнее комментирование только усложняет.
//++ Начало 17 мая 2021 года //Тут я нахожу реализацию товаров, а если не нашел, то ее создаю с помощью метода СоздатьДокумент() Реализация = НайтиИСоздатьРелизациюТовара(); // Теперь переменная Реализация это объект Документ.Реализация //-- Начало 19 октября 2022 года -
Описание обязательно делайте у экспортных или глобальных функций. Это сильно вам поможет при вторичном использовании. У остальных функций по желанию, я это делаю, только если приходит что-то сложное.
// Процедура-обработчик события "ПередЗаписью" регистров для механизма регистрации объектов на узлах // // Параметры: // ИмяПланаОбмена – Строка – имя плана обмена, для которого выполняется механизм регистрации // Источник - НаборЗаписейРегистра - источник события // Отказ - Булево - флаг отказа от выполнения обработчика // Замещение - Булево - признак замещения существующего набора записей -
Объединяйте множество параметров в структуры. Если вам надо получить/передать более шести параметров в функцию, то лучше создать Структуру и передать их в ней (или часть параметров передать в структуре), и не забыв сделать описание этой структуры в описании.
Процедура Хорошо(Документ, ДанныеШапки, ДанныеТоваров) КонецПроцедуры Процедура Плохо(Документ, Организация, Склад, Контрагент, Ответственный, Клиент, Операция, Валюта, КонтактноеЛицо, МассивНоменклатурИКоличеств, ТипЦен) КонецПроцедуры -
Объявляйте переменные в начале функции. 1С позволяет объявлять переменные в любом месте кода и инициализировать сразу, но для чтения удобней, когда они все объявляются и инициализируются в самом начале. Тогда сразу видно, какие параметры приходят в функцию, и какие переменные используются внутри.
Функция Хорошо(Значение) ЭтоНеопределено = Ложь; Если Значение = Неопределено Тогда ЭтоНеопределено = Истина; КонецЕсли; Возврат ЭтоНеопределено; КонецФункции Функция Плохо(Значение) Если Значение = Неопределено Тогда ЭтоНеопределено = Истина; Иначе ЭтоНеопределено = Ложь; КонецЕсли; Возврат ЭтоНеопределено; КонецФункции -
Собирайте строки в переменные. Не стоит собирать строки сразу при заполнении реквизита или вызове метода. Сделайте это в отдельной переменной и присвойте, а еще лучше в отдельной функции, но это уже в зависимости от сложности. Это спасет вас от длинных строк вызовов.
Процедура Хорошо(Имя, Фамилия, Отчество) ФИО = Фамилия + Символы.ВК + Имя + Символы.ВК + Отчество; Сообщить(ФИО); КонецПроцедуры Функция Плохо(Имя, Фамилия, Отчество) Сообщить(Фамилия + Символы.ВК + Имя + Символы.ВК + Отчество); КонецФункции - Возврат значений в функциях делайте одного типа. Если Функция возвращает объект, то она должна возвращать или объект или пустую ссылку (иногда можно Неопределено). Если функция возвращает коллекцию, то она всегда должна возвращать коллекцию. Это спасет вас от разных ошибок при обработке результата выполнения этих функций. (автор идеи ksely)
Функция Хорошо() РеализацияСсылка = Документы.РеализацияТоваровУслуг.НайтиДокумент(); Если НЕ ЗначениеЗаполнено(РеализацияСсылка) Тогда РеализацияСсылка = Документы.РеализацияТоваровУслуг.ПустаяСсылка(); КонецЕсли; Возврат РеализацияСсылка; КонецФункции Функция Плохо() РеализацияСсылка = Документы.РеализацияТоваровУслуг.НайтиДокумент(); Если ЗначениеЗаполнено(РеализацияСсылка) Тогда Возврат РеализацияСсылка; Иначе Возврат Ложь; КонецЕсли; КонецФункции Функция Хорошо() РеализацияСсылка = Документы.РеализацияТоваровУслуг.НайтиДокумент(); СтруктураВозврата = Новый Структура; Если ЗначениеЗаполнено(РеализацияСсылка) Тогда СтруктураВозврата.Вставить("Документ",РеализацияСсылка); СтруктураВозврата.Вставить("Ошибка",Ложь); Иначе СтруктураВозврата.Вставить("Документ",Неопределено); СтруктураВозврата.Вставить("Ошибка",Истина); КонецЕсли; Возврат СтруктураВозврата; КонецФункции Функция Плохо() РеализацияСсылка = Документы.РеализацияТоваровУслуг.НайтиДокумент(); СтруктураВозврата = Новый Структура; Если ЗначениеЗаполнено(РеализацияСсылка) Тогда СтруктураВозврата.Вставить("Документ",РеализацияСсылка); СтруктураВозврата.Вставить("Ошибка",Ложь); Иначе Возврат Ложь; КонецЕсли; Возврат СтруктураВозврата; КонецФункции - В функциях стараться размещать "Возврат" в конце. Конечно это правило далеко не всегда выполнимо, но если функция это допускает, то лучше это правило выполнять. Это вам поможет при отладке, когда мельком глянув текст и поставив точку остановки вы сразу на неё попадете.
Функция Хорошо() РеализацияСсылка = Документы.РеализацияТоваровУслуг.НайтиДокумент(); Если НЕ ЗначениеЗаполнено(РеализацияСсылка) Тогда РеализацияСсылка = Документы.РеализацияТоваровУслуг.ПустаяСсылка(); КонецЕсли; Возврат РеализацияСсылка; КонецФункции Функция Плохо() РеализацияСсылка = Документы.РеализацияТоваровУслуг.НайтиДокумент(); Если ЗначениеЗаполнено(РеализацияСсылка) Тогда Возврат РеализацияСсылка; Иначе Возврат Ложь; КонецЕсли; КонецФункции
P.S. Буду обновлять, если что-то понравится из комментариев или вспомнится.
Вступайте в нашу телеграмм-группу Инфостарт
стиль разработка рефакторинг код
Вы можете заказать платную адаптацию этой статьи под ваши задачи на «Бирже заказов».
- 0% комиссии — оплата напрямую исполнителю;
- Исполнители любого масштаба — от отдельных специалистов до команд под проект;
- Прямой обмен контактами между заказчиком и исполнителем;
- Безопасная сделка — при необходимости;
- Рейтинги, кейсы и прозрачная система откликов.
См. также
Нейросети Рефакторинг и качество кода Запросы Разработчик 1С 8.3 Абонемент ($m)
Нейросеть написала запрос или процедуру для вашей базы 1С, и непонятно, все ли имена в нём настоящие. Обработка компилирует текст без выполнения, сверяет его с метаданными этой базы и к каждой ошибке пишет настоящее имя, например ВНаличииОстаток вместо выдуманного КоличествоОстаток. Список ошибок с подсказками одной кнопкой копируется обратно в чат с моделью.
10 стартмани
02.11.2026 519 2 nedomolkov.ivan 3
Рефакторинг и качество кода Разработчик 1С:Предприятие 8 Россия Бесплатно (free)
Одна проверка в обработчике кнопки может выглядеть достаточной, пока ту же операцию не вызовут из другого места. На примере управляемой формы разберём, почему так происходит, как разместить проверку в общей серверной функции и чем отличается удобная проверка ввода от обязательного условия выполнения операции.
29.10.2026 516 YA_777378709 0
Рефакторинг и качество кода Разработчик Бесплатно (free)
Рассказываем, почему качественный код – это не техническая прихоть, а актив, который помогает бизнесу быстрее адаптироваться к изменениям и запускать новые фичи без бесконечного преодоления техдолга. Показываем, как объяснить бизнесу ценность рефакторинга через понятные признаки: замедление разработки, неточные оценки, страх перед legacy и хрупкость системы. Разбираем, почему неправильный рефакторинг может быть дороже его отсутствия, какие анти-паттерны ломают процесс и как не превратить улучшения в бесконечную переделку ради переделки. Объясняем, как сделать рефакторинг частью культуры команды: договориться с бизнесом, научить разработчиков видеть проблемные места, закрепить правила и поддерживать улучшения на уровне тимлидов, архитекторов и всей команды.
28.10.2026 640 Pavel791 0
Рефакторинг и качество кода HighLoad оптимизация Системный администратор Разработчик Стажер 1С 8.3 Абонемент ($m)
Если к HTTP-сервису 1С обращаются сразу несколько программ, сколько запросов в секунду он успеет обработать? Я опубликовала простой HTTP-сервис на нашей "подопытной" конфигурации «Нано-УТ» (файловая база, Apache, без прав администратора) и нагрузила его скриптом на Python. Ответ: около 15-16 запросов в секунду, сколько бы клиентов ни обращалось одновременно. Запросы ждут своей очереди, и при 32 клиентах ответ приходит через 2 секунды вместо 64 мс. Заодно разобрала скрипт из первого варианта статьи: он «проверял» сервер, который отвечал по одному, и считал ошибки вместе с успешными ответами. В архиве исправленный скрипт, учебный сервер, HTTP-сервис для 1С и инструкция по запуску.
1 стартмани
23.10.2026 634 Ninel_S 3
Рефакторинг и качество кода Разработчик 1С 8.3 Абонемент ($m)
Запустили Analyzer 1C 2.7.65 на промышленной конфигурации (596 модулей, 13 669 функций) и исследовали перегруженные функции (до 1887 строк), циклические зависимости и экран «Циклы» (кольцо из 64 модулей). Разобрали, почему популярные метрики (McCabe, связность) не представлены в продукте вендора, и составили пошаговый план разделения модуля. Привели проверенный платформой 8.3.27 пример до и после рефакторинга и выявили скрытую ловушку загрузки модулей с точкой в имени.
9 стартмани
19.10.2026 577 Ninel_S 2
Рефакторинг и качество кода EDT СКД Разработчик 1С 8.3 1С 8.5 1С:Бухгалтерия 3.0 Бесплатно (free)
Одиннадцать граблей схем компоновки, которые не видно в конструкторе и не ловит EDT, на реальных отчетах БП КОРП. Формат числа задается в двух местах, и условное оформление варианта перебивает формат поля. Ресурс складывает штуки с часами, и помогает выражение «только когда единица одна». Ресурс пуст в детальных записях, параметр не появляется в шапке без userSettingID, valueListAllowed ломает границы периода, Остатки и СрезПоследних с параметром периода падают с «Несоответствием типов», title без xsi:type дает «Исключение XDTO» при загрузке. В конце код проверки схемы из файла до обновления базы, сводная таблица и чеклист.
16.10.2026 694 Konstmax13 2
Инструментарий разработчика Нейросети Рефакторинг и качество кода EDT Разработчик 1С 8.3 1С 8.5 1С:Бухгалтерия 3.0 Бесплатно (free)
Как ИИ-агент (Claude Code) работает в живом EDT-проекте 1С:Бухгалтерии КОРП 3.0: из чего собрать стенд с MCP-сервером для EDT, как ставить задачи агенту, где он ломает проект и какие проверки это ловят. Реальные случаи: рукописные метаданные, ронявшие конфигуратор; четыре дня зависшего обновления из-за порядка блоков в Rights.rights; ошибки, которые EDT пропускает, а платформа нет; сплошная сверка вместо «вроде работает». В приложении шаблон CLAUDE.md, шаблон правила, чеклист перед обновлением базы и скрипты проверки ролей и схем СКД.
15.10.2026 3917 Konstmax13 11
Рефакторинг и качество кода Тестирование QA Разработчик 1С 8.3 Абонемент ($m)
Инженерный анализ влияния (Impact Analysis) при изменении общего метода в 1С:Предприятии: почему штатный поиск ссылок скрывает 99% зависимостей и как обратный обход графа вызовов выявляет 370 скрытых потребителей на глубине 3 уровней. В статье — верификация сквозной цепочки обмена с маркетплейсом; в архиве-компаньоне — автономный BFS-анализатор на Python, слепки графа и план регрессионного тестирования.
1 стартмани
12.10.2026 426 Ninel_S 0
Тогда код читается легче - сразу читаем что вернется из функции, как будто это уже переменная, а не вызов функции.
"Удаляйте ненужный код" - работает при наличии хранилища или git.
"Объявляйте переменные в начале функции" - если их больше 10, то имеет смысл в декомпозиции функции.
"ФИО = Фамилия + Символы.ВК + Имя + Символы.ВК + Отчество;" - Массив и стрСоединить, чтобы не забыть разделитель.
К-к-к-комбо!
из "Системы стандартов и методик разработки конфигураций для платформы 1С:Предприятие 8"?
ей лет 15+, не поленитесь, почитайте
Это пошло из "нативных" языков. Суть в том, чтобы попасть в условие предсказателя ветвления на процессоре. Не уверен, что это актуально в виртуальной машине 1с. Но по привычке всегда так пишу )
Советы хорошие. Вот бы ваши рекомендации, да
Процедура Хорошо(Значение)
Если Значение = Неопределено Тогда Возврат ложь; КонецЕсли;
Возврат Истина;
КонецПроцедуры
Функция Плохо(Значение)
Если Значение = Неопределено Тогда
ЭтоНеопределено = Истина;
Иначе
ЭтоНеопределено = Ложь;
КонецЕсли;
Возврат ЭтоНеопределено;
КонецФункции ПоказатьНе согласен полностью!
Вот так читабельно одной строчкой (хоть и не на языке 1с, но суть одна)?
ЕСЛИ([Согласован (ФЭО)]=[Да] И [Направлять в лист ожидания ]=[Нет];Нет;[Операция_платежей]=[Отдел ПСО] ИЛИ [Операция_платежей]=[Отдел снабжения] ИЛИ [Операция_платежей]=[Отдел маркетинга] ИЛИ [Операция_платежей]=[Транспортный отдел] ИЛИ [Направлять в лист ожидания ]=[Да] ИЛИ [Сумма заявки, руб.]<>0 И [Направлять в лист ожидания ]=[Да] ИЛИ [Операция_платежей]=[Отдел продаж] ИЛИ НЕ ([Организация]=[_____] И ([Контрагент]=[_______] ИЛИ [Контрагент]=[РОСТЕЛЕКОМ, ПАО] ИЛИ [Контрагент]=[ВОСТОК ______, АО] ИЛИ [Контрагент]=[_____, ОАО] ИЛИ [Контрагент]=[_____, ПАО])) И [Направлять в лист ожидания ]=[Да])
Не комментируйте каждую строку.Вот мне заняться больше нечем как рассказывать что и как работает каждая функция для другого программиста.
Так то и ежу понятно, что можно и не вызывать процедуру "Превосходно", а сразу написать вместо нее "= Значение = Неопределено".
Плюс, это не очень удобно для отладки.
Ну, наверное, еще от контекста зависит.
Действительно, некоторые ЯП требуют именно такое поведение, например, Pascal.
Но если язык позволяет - рекомендуется объявлять переменные по возможности ближе к месту использования.
Есть специальные метрики для анализа кода в этом разрезе: "Интервал" и "Время жизни".
Метрика "Интервал" показывает усредненное значение количества строк между местами использованиями переменной.
Метрика "Время жизни" показывает количество строк между первым и последним использованием переменной.
Чем меньше значение этих метрик, тем:
а) меньше "окно уязвимости" - вероятность изменения переменной между вызовами. Умышленного или неумышленного;
б) меньше неоптимальных затрат памяти;
в) проще программисту держать в голове этот кусок кода.
Процедура Хорошо(Значение)
Если Значение = Неопределено Тогда Возврат ложь; КонецЕсли;
Возврат Истина;
КонецПроцедурыв таких случаях имеет смысл использовать тернарный оператор
Процедура Хорошо(Значение)
Возврат ?(Значение = Неопределено, Ложь, Истина);
КонецПроцедуры7) я для длинных запросов делаю область, так его можно свернуть + не надо между функциями скакать, что бы подправить обработку результата после изменения запроса.
Тип данных параметра Значение в текущем примере особого значения не имеет.
Результат выражения
Значение <> НеопределеноФункция Хорошо(Значение) (судя по коду) должна возвращать Истина только в одном случае: когда
Значение = НеопределеноСоответственно, тип данных параметра может быть любым. Мы же можем любое значение сравнить с Неопределено )
В отличие от функциональных языков программирования, где сам оператор if возвращает значение.
Поэтому не люблю этот тернарный оператор + читабельность не очень.
И Если в одну строку тоже не нужно писать.
Без пруфов - это всё вкусовщина.
Вы потрудились систематизировать свои знания - за это +, но есть и минус.
Уважаемый автор, если не хотите быть голословными - рекомендую отделить Свои правила, Правила сложившиеся на проекте и Общие правила.
Последние легко гуглятся на:
- ИТС
-
-
-
- и других общепринятых ресурсах
Это позволит вам вырасти по грейдам, на примере ожиданий одного работодателя
Ведь все люди разные, у каждого свой бэкграунд, и для многих описанных моменты покажутся спорными.
Лучше корректировать архитектурные решения и подсвечивать проблемы текущей реализации, а не code style - для этого есть ;)
Представляется правильным выпуск нового продукта с возможностью интеграции со старым либо переносом данных. Тема архитектуры ПО в 1С почти не обсуждается. Поэтому большинство разработок в 1С это вырвиглаз с множеством таблиц полей кнопок вкладок в одной форме
1. Функция, возвращающая какой-либо объект, всегда возвращает только один тип объекта, либо Неопределено.
2. Функция, возвращающая любую коллекцию, всегда возвращает коллекцию, пусть даже пустую. Такая функция не должна возвращать Неопределено, или объект.
3. Блок Исключение в блоке Попытка никогда не должен быть пустым. Там нужно либо логировать ошибку, либо выводить сообщение. В редких случаях, когда там точно ничего не нужно делать, там надо оставить об этом комментарий.
Если РезультатФункции.Количество() = 0 ТогдаЕсли функция может вернуть как коллекцию, так и Неопределено, то проверка будет двухступенчатой:
1. Проверка на Неопределено, например:
Если РезультатФункции <> Неопределено Тогда2. Проверка на пустую коллекцию:
Если РезультатФункции.Количество() = 0 ТогдаP.S. Справедливости ради можно сказать, что проверка на пустую коллекцию не всегда нужна. Потому что обычно коллекцию обходят циклом, или используют ЗаполнитьЗначенияСвойств() и другие варианты.
в этом случае Неопределено мы возвращаем как "ненормальный" результат.
Платформа тоже так делает в некоторых случаях, если что
Я в случаях, когда внутри функции может что-то сломаться, формирую структуру:
Результат = Новый Структура;
Результат.Вставить("Успешно", Ложь);
Результат.Вставить("Коллекция", Новый Массив); // это и есть коллекция с данными, ключ выбирается по месту
Результат.Вставить("ТекстОшибки", "");Так я гарантирую, что на выходе функции точно будет строго определенная коллекция. И не надо обрабатывать другие типы.
Я не использую процедуры от слова совсем, только функции. Оставляю только те процедуры, что конструктор платформы создает сам. Функция не обязательно должна что-то возвращать (по умолчанию это будет Неопределено), но если мне впоследствии нужно будет что-то вернуть, я с лёгкостью это изменю, не перелопачивая код.
Возможно это не соответствует стандартам, но это удобно.
1) Объекты следует заполнять используя события обработки заполнения.
Плохо: Документы.РеализацияТоваровУслуг.ЗаполнитьДокументРеализации(РеализацияТоваровОбъект,ДанныеЗаполнения);
Хорошо: РеализацияТоваровОбъект.Заполнить(ДанныеЗаполнения)
Почему: Это выделяет код, ответственный конкретно за заполнение объекта, позволяет его унифицировать. Эта же рекомендация есть в стандартах:
4) В общем случае - от глагола (инфинитива) образуются именования процедур (надо что-то сделать). Имена функций от сути происходящего в ней. Если функция является по своей сути процедурой, допустимо ее также именовать от глагола. Например "ВыполнитьЗаписьОбъектов", возвращающая результат записи. Булево, или конструктор в виде структуры с описанием. Не следует в функциях употреблять слова "Вернуть", "Получить" и т.д. - и так понятно что функция нужна для того чтобы что-то вернуть \ получить. Подробнее см.
5) Это вкусовщина, и подход к которому конкретно Вы привыкли. В общем случае обратные условия сложней для понимания, наш разум стремиться решать задачи линейно, и не надо ему мешать в простых случаях. Его можно натренировать на восприятие таких конструкций, но это ломает мышление. В итоге разработчик оказывается в меньшинстве которому оный подход удобен, и не понимает почему это не нравится другим. Потому что избыточное усложнение.
6) См. , п.4. Сможете поставить точку останова на операторе "Возврат"? Не надо говорить что "там все просто, и это никогда не понадобится". Понадобится. Причем в проде, на пике сдачи регл. отчетности.
10, 11)
15) Это называется "единая точка выхода". В процедурах - чем выше возврат, тем лучше. В функциях он всегда должен быть один, в конце метода. Если этого сложно добиться, значит метод надо рефакторить.
Вообще, со временем у меня сложился такой подход: функция всегда возвращает переменную "Результат". Т.е. контекст образован самим методом. Ваш пример из 14 более читабелен с моей т.з. вот в таком виде:
// Было:
Функция Хорошо()
РеализацияСсылка = Документы.РеализацияТоваровУслуг.НайтиДокумент();
СтруктураВозврата = Новый Структура;
Если ЗначениеЗаполнено(РеализацияСсылка) Тогда
СтруктураВозврата.Вставить("Документ",РеализацияСсылка);
СтруктураВозврата.Вставить("Ошибка",Ложь);
Иначе
СтруктураВозврата.Вставить("Документ",Неопределено);
СтруктураВозврата.Вставить("Ошибка",Истина);
КонецЕсли;
Возврат СтруктураВозврата;
КонецФункции
// Стало:
Функция РезультатПоискаРеализации()
Результат = НовоеОписаниеРезультатаПоискаДокумента();
Результат.Документ = Документы.РеализацияТоваровУслуг.НайтиДокумент();
Результат.Ошибка = НЕ ЗначениеЗаполнено(Результат.Документ);
Возврат Результат;
КонецФункции
Функция НовоеОписаниеРезультатаПоискаДокумента()
Результат = Новый Структура;
Результат.Вставить("Документ");
Результат.Вставить("Ошибка", Ложь);
Возврат Результат;
КонецФункции
ПоказатьНу тоже же холиварное утверждение.
Если функция - это один Если ... Тогда <много кода> Иначе <одна строка> КонецЕсли, то почему сразу не срубить короткий конец?
Меня вот от "Иначе" коробит, даже если я вижу где-то слегка выше соответствующий "Если" .
(А ещё 1Ска не умеет сворачивать "Если" до "Иначе")
Процедура Хорошо()
Ошибка = Ложь;
ОписаниеОшибки = "";
Попытка
Документ.Записать();
Исключение
ОписаниеОшибки = ОписаниеОшибки();
Ошибка = Истина;
КонецПопытки;
Если НЕ Ошибка Тогда
Сообщить("Всё хорошо");
Иначе
Сообщить(ОписаниеОшибки);
КонецЕсли;
КонецПроцедуры Показать+ По поводу 6. все уже высказались. Добавлю: Вариант написания в строку плохо читается!
Вообще, код в одну строку - это плохой стиль.
Процедура Плохо(Документ)
МояСтруктура = новый Структура("ДокДата,ДокНомер,ДокСсылка,ДокПримечание", Документ.Дата, Документ.Номер, Документ.Ссылка, Документ.Примечание);
КонецПроцедуры
Процедура Хорошо(Документ)
МояСтруктура = новый Структура;
МояСтруктура.Вставить("ДокДата", Документ.Дата);
МояСтруктура.Вставить("ДокНомер", Документ.Номер);
МояСтруктура.Вставить("ДокСсылка", Документ.Ссылка);
МояСтруктура.Вставить("ДокПримечание", Документ.Примечание);
КонецПроцедуры ПоказатьСчитаю, всеми силами надо избегать обратных условий. При невозможности обойтись - искать синонимы. Например надо добавить параметр учетной политики "НеИспользоватьФункционал". Кажется, что его удобнее задать именно так, т.к. по умолчанию будет Ложь, и не надо перезаполнять документы. Но потом начинается кошмар в коде... Лучше либо описать прямо: ИспользоватьФункционал, и добавить обработчик обновления, который взведет флаг в Истина в существующих документах (учетных политик не так много, на самом деле). Либо найти синоним, например "ИсключитьИспользованиеФункционала".
При наборе кода, при описании ФТ, при вводе реквизита и т.д..
Иначе при дальнейшем развитии и усложнении кода начинаются игры разума с "НЕ НетОшибок". И вместо того чтобы работать приходится маяться такой фигней, соображать что будет при расчете.
На высокоуровневом ЯП с его-то синтаксическим "сахаром", приближающий ЯП к человеческому языку, пишется самочитаемый, то есть самокомментируемый, код-как-формула с вынесением общих, то есть смысловых, логических или технических, множителей за скобки для автоматизации текущей бизнес-логики с последующей, а не преждевременной, оптимизацией, если будущее того потребует.
Что там в тригонометрии?! sin 2а = 2 * sin a * cos a. Хочешь, вынеси в процедуру получение синуса, а косинус вырази через него. А если бизнес-логика того потребует, то вырази всё через тангенс половинного аргумента или ряды и вперед.
Пункт 11 - я сейчас в автора тапком кину... А точнее говоря, это явный признак того, что функцию-процедуру не разложили на множители (Фаулер), оттого и входящих параметров много (Фаулер), то есть [бизнес-]логика не разграничена (Фаулер), значит нарушен пункт 1 (Фаулер).
Пункт 15 - классика жанра в конце текста. Видимо, автор в своей практике видел и так, а видел и так. А как нужно - автор не до конца понимает, или не решил для себя, или уже устал и пунктов много. Поэтому используются обтекаемые фразы "стараться" (со смыслом, "я не понимаю, но делаю" с мемом "Давай, программировай!") и "если функция этого допускает" (со смыслом, "не виноватая я, функция сама"), дающие на откуп самого программиста: хочешь - пиши так, а хочешь - как сказал стажер-с-5-летним-стажем ("сеньор" типа). Ответ-то простой - см. пункт 1, а точнее троицу Фаулера-Макконнелла-Мартина.
Но 1С сами такой подход продвигают, из-за отсутствия ООП. Этакие квази-объекты в структурах.
Было:
МояФункция(Дата, Организация)
Стало
МояФункция(Дата = Неопределено, Организация)
Указание структуры - это весьма удобный подход, сокращающий риски рефакторинга. Самый надежный метод - который принимает внутрь структуру, и отдает структуру. Причем, если это экспортный метод - он должен принимать и отдавать конструктор.
// Плохо:
Функция ОписаниеЗадолженности(Дата, Организация, Контрагент) Экспорт
КонецФункции
// Хорошо
Функция НовыеПараметрыПолученияЗадолженности() Экспорт
Результат = Новый Структура;
Результат.Вставить("Дата");
Результат.Вставить("Организация");
Результат.Вставить("Контрагент");
Возврат Результат;
КонецФункции
Функция НовыйРезультатПолученияЗадолженности() Экспорт
Результат = Новый Структура;
Результат.Вставить("Суммы");
Результат.Вставить("ЕстьОшибка", Ложь);
Результат.Вставить("Описание", "");
Возврат Результат;
КонецФункции
Функция ОписаниеЗадолженности(ПараметрыПолучения) Экспорт
Результат = НовыйРезультатПолученияЗадолженности();
// Много кода
Возврат Результат;
КонецФункции
// Пример использования при локальном вызове:
Функция СуммыЗадолженности()
ОписаниеЗадолженности = ОбщийМодуль.НовыйРезультатПолученияЗадолженности();
Попытка
ПараметрыПолучения = ОбщийМодуль.НовыеПараметрыПолученияЗадолженности();
ОписаниеЗадолженности = ОбщийМодуль.ОписаниеЗадолженности(ПараметрыПолучения);
Исключение
ОписаниеОшибки = ОписаниеОшибки();
// Запись в ЖР
КонецПопытки;
Результат = ОписаниеЗадолженности.Суммы;
Возврат Результат;
КонецФункции
ПоказатьМояФункция( , Организация)
чем ловить ошибки времени выполнения из-за опечатки в ключе структуры.
+ Много лишнего (служебного) кода со структурами.
При добавлении нового параметра нужно или прописать ему значение по умолчанию или изменить все вызовы функции. Структура тут ничем не поможет (по сути то же значение по умолчанию).
Параметры и выход функции описываются в комментарии к ней.
По выходному результату тут есть 2 пути: отдавать структуру из функции или в процедуру принимать пустые параметры для изменения.
Тут кто-то написал в комментариях - а зачем мне писать комменты помогать другому программисту? Все верно, как правило программисты не заинтересованы в качественной архитектуре, они заинтересованы в своей востребованности, зависимости работодателя от него и хорошем заработке. А хорошая архитектура - это опасность для такого деятеля.
Заказчик или работодатель в идеале не должен рассказывать программисту свою бизнес-логику, достаточно объектов предметной области, а что с ними делать давайте специалисты уже сами разберутся - адвокаты юристы врачи. Разработчик пусть отвечает только за технический функционал программы - кнопки таблички формы свойства. С логикой в качественном пользовательском интерфейсе с возможностью автоматизации бизнес-процессов специалисты предметной области разберутся сами. Мало того, такой подход позволит в пользовательском операционном режиме совершенствовать эту самую логику без помощи программистов
Я тоже когда-то упирался против использования ЗначениеЗаполнено, с некоторым стыдом предлагаю ознакомиться с этой темой на мисте , начиная с поста 15.
Умные люди мне говорили, я не слушал. Потом сам же к этим выводам и пришел.
Потом приходит понимание, что такие вот места далее ручным поиском не найдешь. И остается "отлаживаться на хомячках", выслушивая претензии в свой адрес. В общем, не буду больше ничего говорить - знаю все ответные аргументы, некогда мыслил примерно также. Это видимо тот случай, когда надо самому вынимать палки из колес, и к этому приходить.
Но справедливости ради, если у вас кто-то длину наименования обнулит, то метод ЗначениеЗаполнено() вас в этом случае не спасет, а скорее наоборот скроет ошибку. Но это все детали из гипотетического мира.
Я читал Фаулера-Макконнелла-Мартина и даже рекомендации 1С. Но я устал копаться в кое как написаном коде других программистов. Видимо им не охото читать книжки про стили программирования, поэтому вывел эти короткие и понятные правила. Может говнокода хоть на 1% будет меньше.
Я читал Фаулера-Макконнелла-Мартина и даже рекомендации 1С. Но я устал копаться в кое как написаном коде других программистов. Видимо им не охото читать книжки про стили программирования, поэтому вывел эти короткие и понятные правила. Может говнокода хоть на 1% будет меньше.
А не надо стесняться говонокода.
По моему опыту, 80% от того, что я пишу в ближайшие пять лет будут выкинуты на помойку. Причины при этом будут самые разные, вообще никакого отношения к качеству кода не имеющие. Про рефакторинг когда и технический долг можно не напрягаясь говорить с заказчиком - все равно если все как-то работает он эту деятельность точно оплачивать не будет.
Я стараюсь придерживаться стандартов кодирования, изложенных на ИТС.
Я всегда в комментариях стараюсь описать бизнес логику - чтобы потом было о чем говорить с заказчиком.
Я оставляю старый код закомментированным - зеленые поля меня не напрягают - но если что я моментально выполнить * ,если заказчик это решит.
Есть такое понятие "культура производства", которую надо соблюдать, что и подтверждается вашими словами, что ваш код выкинут на помойку. Я в 1С уже чуть более 13 лет, и что самое удивительное, некоторый который я написал уже около 7-8 лет назад, еще не выкинули.
Надо уважать себя и уважать программистов, которые будут разбираться в коде, которого вы не стестняетесь. И это только моральный аспект. Но есть еще и скорость отладки, внесения изменений итд
Надо смотреть на жизненный цикл продукта, если мы предполагаем, что это тиражное решения, которое будет жить долго, то есть смысл усердствовать, если мы занимаемся заказной разработкой, - то однозначно нет, ниже растолкую почему.
Чем бы 1С программист на работе не занимался в любом случае это будет - решение задач бизнеса, в интересах бизнеса. Как говорят америанцы, - "когда человек спрашивает в магазине сверло на четверть дюйма, ему не нужно сверло - ему нужны отверстия диаметром четверть дюйма". Бизнесу нужно решение - в минимально возможные сроки и за минимальные деньги - что там будет внутри - бизнесу без разницы. С моей колокольни ваша позиция - "Надо уважать себя и уважать программистов, которые будут разбираться в коде, которого вы не стестняетесь" - это называется ставить свои личные амбиции выше интересов дела, как здесь насчет "морального аспекта".
Мне вообще глубоко безразличны программисты, которые будут разбираться в моем коде. Стараюсь придерживаться стандартов разработки фирмы 1СДля себя, как я уже выше писал, я там оставляю комментарии, в которой описываю бизнес логику - чего именно в тот раз желал заказчик. Точно так же я отношусь к программистам, чей код мне приходится допиливать - если я подписался выполнить задачу, то я обязан эту задачу выполнить, больше тут обсуждать нечего. Как писали классики - "Не надо делать из еды культа"
Бизнесу от нас не нужно стремление к идеалу за его счет - ему нужно просто работающее решение. Как в известном меме автоматизаторов - "теперь девушка-оператор сможет раскладывать на три пасьянса больше".
А откроешь какой-нибудь модуль типовой или не очень - мама дорогая! Чужие для хищников писали, не иначе!
Если Отказ Тогда
Возврат;
КонецЕсли;
КакойтоКодВычисляющийРезультат;
Возврат Результат;
По-моему лучше присвоить значение переменной значение, а потом уже её вернуть.
IMHO, что в примере плохо, должно быть хорошо и наоборот.
&НаСервереБезКонтекста
Функция ПолучитьСписокДокументовНаСервере (СтрокаИмениДокумента, СтруктураПараметров = Неопределено)
#Если Сервер И Не Сервер Тогда
СтруктураПараметров = Новый Структура;
#КонецЕсли
#Область запрос
зпрДанные = Новый Запрос ("
| ВЫБРАТЬ РАЗРЕШЕННЫЕ
| Ссылка Объект
| ИЗ
| &Документ
| ГДЕ
| ИСТИНА
| //УСЛОВИЕ_Проведен
| ");
#КонецОбласти // запрос
зпрДанные.Текст = СтрЗаменить (зпрДанные.Текст, "&Документ", "Документ." + СтрокаИмениДокумента);
Если СтруктураПараметров <> Неопределено Тогда
Если СтруктураПараметров.Свойство ("Проведен") Тогда
зпрДанные.Текст = СтрЗаменить (зпрДанные.Текст, "//УСЛОВИЕ_Проведен", "И " + ? (СтруктураПараметров.Проведен, "", "НЕ ") + Проведен);
КонецЕсли;
КонецЕсли;
реззпрДанные = зпрДанные.Выполнить ();
Если реззпрДанные.Пустой () Тогда Возврат Неопределено КонецЕсли;
Возврат реззпрДанные.Выгрузить ().ВыгрузитьКолонку ("Объект");
КонецФункции // ПолучитьСписокДокументовНаСервере ()
Показатьи где-нибудь в коде, где вызываю эту функцию, я пишу:
&НаСервереБезКонтекста
Функция ПолучитьОшибкуНаСервере (СтрокаТекстаОшибки)
Возврат Новый Структура ("Ошибка, ТекстОшибки", Истина, СтрокаТекстаОшибки);
КонецФункции // ПолучитьОшибкуНаСервере ()
&НаСервереБезКонтекста
Функция ПолучитьРезультатНаСервере (Данные = Неопределено)
Возврат Новый Структура ("Ошибка, Данные", Ложь, Данные);
КонецФункции // ПолучитьРезультатНаСервере ()
&НаСервереБезКонтекста
Функция ОбработатьДокументыНаСервере (СтрокаИмениДокумента, СтруктураПараметров)
мсвОбъекты = ПолучитьСписокДокументовНаСервере (СтрокаИмениДокумента, СтруктураПараметров);
Если мсвОбъекты = Неопределено Тогда Возврат ПолучитьОшибкуНаСервере ("Нет документов") КонецЕсли;
Для Каждого элмсвОбъект Из мсвОбъекты Цикл
//…
КонецЦикла;
Возврат ПолучитьРезультатНаСервере ();
КонецФункции // ОбработатьДокументыНаСервере ()
…
сттРезультат = ОбработатьДокументыНаСервере ("ПриходныйКассовыйОрдер", Новый Структура ("Проведен", Истина));
Если сттРезультат.Ошибка Тогда
...
КонецЕсли;
ПоказатьС инфинитива в общем случае должны начинаться имена процедур, а не функций. А функции лучше называть так, как-будто в названии уже зашит результат, то есть не ПолучитьСписокДокументовНаСервере, а просто СписокДокументов. В коде с этой функцией может работать как с обычной переменной
я и переменные называю тоже по-своему. например, вместо «ТоварСсылка» пишу «спрслкТовар». в префиксе я как бы указываю тип данных, который в переменной хранится. если назвать переменную, например, «СписокТоваров», то непонятно будет, что именно в такой переменной хранится (массив, список значений, таблица значений или что-то другое).
не нужно слепо следовать «правилам», которые придумали другие программисты (Фирма 1С). определЁнно, в этих правилах есть свои полезные моменты, которые полезно будет перенять, но делать только так, как там сказано, не стоит.
цель всех этих «правил» заставить программистов писать одинаково, чтоб код был одинаково всем понятен. вроде бы полезная и хорошая идея, но!!! есть побочный момент, который я считаю очень существенным, - подобные «правила» заставляют программистов мыслить и думать одинаково, то есть лишают программиста индивидуального мышления, которое приводит к уникальным решениям и подходам их реализации.
Гибкость реализации функционала ни как не коррелирует с именованием, а вот поддержка кода, очень даже. Я встречал код, где было ОбщийМодуль1-ОбщийМодуль6, программист вообще не парился про именование :).
PS по мне идея очень не плохая:
(65)
Но я не люблю как-то обрабатывать результат функции не поместив его в переменную.
Даешь Знач Параметр1, Знач Параметр2 - всегда!
Вы можете заказать платную консультацию или разработку у автора. Будет создан приватный заказ на «Бирже заказов» для автора.
№ 1670466
Создание 02.06.22 20:00
Обновление 02.06.22 20:37
Просмотры 21754
Загрузки 0
Рейтинг
78
Комментарии 72
Код открыт Да
Рубрики Рефакторинг и качество кода
Кому Разработчик
Тип файла Нет файла
Платформа 1С:Предприятие 8
Конфигурация 1C:Бухгалтерия
Операционная система Не имеет значения
Страна Не имеет значения
Отрасль Не имеет значения
Налоги Не имеет значения
Вид учета Не имеет значения
Доступ к файлу Бесплатно (free)