Чистый код. Мой взгляд на жизнь в макаронных джунглях. Часть 2
Разработка - Рефакторинг и качество кода
Картинка для улыбки :)

Картинка взята с телеграмм-канала Мемы 1С.
Краткое оглавление
- Введение
- Ссылки
- Источники
- Глава 2
- Содержательные имена
- Функции
- Комментарии
- Форматирование
- Многопоточность и длительные операции
- Практический результат
- Заключение
Введение
Доброго времени суток, уважаемый читатель. Если ты зашел в эту статью, значит ты хочешь стать чуточку лучше и ищешь пути своего развития. В этой статье я познакомлю тебя с моим личным путем развития в направлении качества кода. Данная статья не призывает строго соблюдать правила, написанные в ней, и даже не является рекомендацией. Моя цель - познакомить тебя со своим видением этого мира. Если тебе есть что сказать или обсудить - добро пожаловать в комментарии.
Эта публикация является второй частью. Рекомендую ознакомиться так же с первой частью (хотя они не являются взаимосвязанными).
Ссылки
Источники
Продублирую источники из первой статьи, чтобы интернет знал своих героев.
- За основу взята книга Роберта Мартина "Чистый код". Сразу скажу свое видение по поводу этой книги в сфере 1С. Это лучше, чем разбираться в стандартах 1С на ИТС. Почему? Лично мне неудобно ориентироваться в стандартах, непонятная и неочевидная структура. Но добрая половина книги бесполезна для 1С.
- К книге добавлены стандарты 1С. Я потратил много времени чтобы дополнить материал из книги материалами из стандартов. С того времени я не заходил больше в стандарты.
- Пройдена обкатка на практике, после чего изменены и добавлены некоторые пункты из личного опыта (моего и моей команды).
- Так же есть множество статей на Инфостарте, в них можно изучить разные взгляды и подходы. Алексей Беспалов, Артано Майаров, Тимофей Синичкин, Юрий Былинкин, Николай Васильев, Николай Васильев, Владимир Крючков, Владимир Харин, q_i
Глава 2
В этом разделе я приведу те правила из книги, которые мы используем в своей команде. В предыдущей части я рассматривал больше общие правила. Здесь же будет подробно про переменные и методы, модули и т.д.
Далее по статье я буду использовать разные термины: метод, процедура и функция. Примем, что любое из этих слов подразумевает именно метод.
Содержательные имена
Имена должны передавать намерения программиста (осмысленные наименования).
Сравните вызов двух функций. В первом случае совершенно очевидно, что функция вернет таблицу значений, содержащую документы «Заказ клиента» и даты их проведения. А во втором случае совсем не очевидно, что делает функция, и что хранится в переменной «ТЗДоки», можно только сказать, что там некая таблица значений.
ТЗЗаказыКлиентов = ПолучитьТЗЗаказыКлиентовСДатамиПроведения();
ТЗДоки = ТЗДоки();
Избегайте дезинформации (наименование не отображает реальное предназначение).
Вызываем функцию «ПолучитьТЗЗаказыКлиентов» и ожидаем, что она вернет нам таблицу значений с документами «Заказ клиента».
ТЗЗаказыКлиентов = ПолучитьТЗЗаказыКлиентов();
Однако если мы посмотрим на определение функции, но увидим, что название не соответствует выполняемому коду.
Функция ПолучитьТЗЗаказыКлиентов()
Массив = Новый Массив();
Массив.Добавить(Объект.Ссылка);
Возврат Массив;
КонецФункции
Функция возвращает массив, однако из названия следует, что она возвращает таблицу значений. Это и есть дезинформация. Если бы мы в последующем стали использовать методы, относящиеся к таблице значений, например ТЗЗаказыКлиентов.Колонки.Добавить(“СвязанныйКлиент”), то получили бы ошибку только в ходе выполнения программы.
Так же можно привести пример с переменными. Когда в переменной ФИОКлиента оказывается наименование юридического лица. Или в переменной ЦенаТовара оказывается сумма (цена*количество).
Осмысленные различия
Рассмотрим два метода: ПолучитьДанные() и ПолучитьТаблицу(). Разве из наименований этих методов понятно, что они делают? Разве метод ПолучитьДанные не может вернуть таблицу? А таблица не содержит данные? Кажется, что эти методы делают одно и то же. Важно обращать внимание не только на наименование одного метода, но и остальных. Будет ли уместно задавать то или иное наименование метода, когда через 2 метода вниз существует метод с похожим наименованием? В наименованиях методов должны быть четкие различия. Например ПолучитьДанныеВМассив() и ПолучитьДанныеВТабличныйДокумент(). В таком случае различия в методах очевидны: методы возвращают разные типы данных.
Удобопроизносимые имена.
Что скажите о переменной стрВРегДокЗаказКлиент? Или ЭлТЧФорма? Мало того что их произносить неудобно, так ещё и перечитываешь по несколько раз, чтобы понять суть. Совсем другое дело ПредставлениеЗаказаКлиентаВерхнийРегистр (или ПредставлениеЗаказаКлиентаВРег, поскольку ВРег является типовым методом). Не стоит напихивать в наименования сокращения, несвязанные слова и прочее.
Не кодировать имена.
Не стоит кодировать наименования и выдумывать свой собственный язык и правила именования. Плохой пример: кодировать «Число» в «Ч», «Заказ клиента» в «ЗК» и прочее. Используйте только те правила кодирования, которые приняты в вашем направлении, например: «ТаблицаЗначеий» в «ТЗ», «ТабличнаяЧасть» в «ТЧ» и т.д.
Венгерская запись
Типичный пример венгерской записи: «СтрокаНаименование». Венгерская запись – включать в наименования типы данных там, где в этом нет никакого смысла. Всем и так понятно, что наименование – строковый тип данных.
Не использовать префиксы и суффиксы без необходимости.
Иногда встречается стиль написания кода, когда ко всему, что написано в расширениях, добавляются префиксы расширения. И это применяются так же к переменным, что является абсолютно бессмысленным. Суффиксы и префиксы стоит использовать только тогда, когда это необходимо. Плохой пример: «Расш1ТЗЗаказыКлиентов». Изменив наименование на «ТЗЗаказыКлиентов» наименование станет только более понятней.
Конечно, данный пункт не относится к тем ситуациям, когда платформа автоматически подставляет префиксы (например, при расширении методов).
Пример необходимости применения префикса. В расширении расширяется типовой объект. Добавляется реквизит. Наименование реквизита выбрано такое, что, возможно, в будущих обновлениях типовой конфигурации поставщик может применять его для своих реквизитов. Тогда может случится конфликт при обновлении. В этом случае конечно стоит использовать префикс.
Если наименование присваивается переменной, методу или реквизиту самописного объекта метаданных, скорее всего префикс не будет нужен.
Мысленные преобразования
Читая код, имена мысленно преобразуются в другие, подразумевается что-то другое. Такие наименования лучше избегать. В этом пункте я не смог придумать пример и пока что не встречал его применения на практике в нашей сфере. Если у читателя есть свои предложения – добро пожаловать в комментарии.
Имена методов – глаголы.
Метод с наименованием СуммаТоваров – плохой метод. Непонятно, что происходит с суммой в ходе выполнения метода. Такое наименование больше подходит для переменной. Наименования метода следует начинать с глагола, например РассчитатьСуммуТоваров.
Имена из пространства задачи.
Для наименований следует выбирать имена из предметной области или пространства задачи. Если вы работаете с задачей по изменению заказа клиента, то будет странно, если в вашем коде встретится переменная с именем «СуммаПоБухУчету» или «КоличествоВАптеке» и прочее. Тому, кто читает ваш код, будет непонятно назначение этих переменных и содержащиеся в них данные.
Избыточный контекст
Не нужно для каждого служебного метода добавлять префикс приложения и прочие очевидные вещи, например «УТРассчитатьСуммуТоваров». «УТ» - избыточный контекст, который очевиден и без него.
Функции
Компактность.
20 строк. Именно столько нужно для выполнения любой хорошо выделенной части кода на одном уровне абстракции. Если в вашем методе более 20 строк, вероятно стоит задуматься над тем, чтобы разбить метод на несколько методов.
Мне очень сложно соблюдать данный пункт. Я сделал для себя послабление – от 1 до 1,5 экрана. Такой объем гораздо легче соблюдать. Если вы соблюдаете 20 строк – вы большой молодец!
Блоки и отступы.
Не более 4 уровней отступов, не содержат вложенных структур. В идеале внутри 1 строка – вызов функции (в новом отступе). Посмотрите на представленный блок кода. С первого раза невозможно разобраться, что здесь происходит. Необходимо перечитать блок 2 и более раз. А после вставки изменений необходимо убедиться, что изменения были вставлены в нужный уровень вложенности, прокрутив весь метод. И это только самые простые условия.
Процедура ОчиститьПоставщиковНоменклатуры()
Для каждого стрТЗЗаказов из ТЗЗаказыКлиентов Цикл
Если стрТЗЗаказов.ВидЗаказа = Перечисления.ВидыЗаказов.Стандартный Тогда
Для каждого стрТовары из стр.ТЗЗаказов.Товары Цикл
Если стр.Товары.ЕдиницаИзмерения = Перечисления.ЕдиницыИзмерения.Штуки Тогда
ТоварОбъект = стр.Товары.ПолучитьОбъект();
Для каждого стрПоставщики из ТоварОбъект.Поставщики Цикл
стрПоставщики.Поставщик = Неопределено;
КонецЦикла;
ТоварОбъект.Записать();
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
Или его же версия.
Процедура ОчиститьПоставщиковНоменклатуры()
Для каждого стрТЗЗаказов из ТЗЗаказыКлиентов Цикл
Если стрТЗЗаказов.ВидЗаказа = Перечисления.ВидыЗаказов.Стандартный Тогда
Для каждого стрТовары из стр.ТЗЗаказов.Товары Цикл
Если стр.Товары.ЕдиницаИзмерения = Перечисления.ЕдиницыИзмерения.Штуки Тогда
ТоварОбъект = стр.Товары.ПолучитьОбъект();
Для каждого стрПоставщики из ТоварОбъект.Поставщики Цикл
стрПоставщики.Поставщик = Неопределено;
КонецЦикла;
ТоварОбъект.Записать();
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
А теперь взгляните на новый блок. Функционал двух блоков абсолютно одинаковый. Однако после переработки блок кажется проще и понятнее, читается сверху вниз без прокручивания модуля. Изменения вносятся так же легко.
Процедура ОчиститьПоставщиковНоменклатуры()
Для каждого стрТЗЗаказов из ТЗЗаказыКлиентов Цикл
Если стрТЗЗаказов.ВидЗаказа = Перечисления.ВидыЗаказов.Стандартный Тогда
ИзменитьШтучныеТовары(стрТЗЗаказов );
КонецЕсли;
КонецЦикла;
КонецФПроцедуры
Процедура ИзменитьШтучныеТовары(ЗаказКлиента)
Для каждого стрТовары из стр.ТЗЗаказов.Товары Цикл
Если стр.Товары.ЕдиницаИзмерения = Перечисления.ЕдиницыИзмерения.Штуки Тогда
ОчиститьТЧПоставщикиТовара(стрТовары );
КонецЕсли;
КонецЦикла;
КонецПроцедуры
Процедура ОчиститьТЧПоставщикиТовара(Товар)
ТоварОбъект = Товар.ПолучитьОбъект();
Для каждого стрПоставщики из ТоварОбъект.Поставщики Цикл
стрПоставщики.Поставщик = Неопределено;
КонецЦикла;
ТоварОбъект.Записать();
КонецПроцедуры
Так же обратите внимание на отступы. Отступы разделяют разные уровни вложенности и позволяют наглядно видеть, на каком уровне находится выполняемый код.
Так же отступы между строками. Они должны отделять логические блоки друг от друга. В первом случае метод выглядит скомканным. Во втором все наглядно. Посмотрите на ещё два блока кода, написанных в одном методе.
Процедура РассчитатьСуммуТоваров()
СуммаТоваров = 0;
Для каждого стр из ЗаказКлиента.Товары Цикл
стр.Сумма = стр.сумма * 1.2;
СуммаТоваров = СуммаТоваров + стр.Сумма;
КонецЦикла;
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Процедура РассчитатьСуммуТоваров()
СуммаТоваров = 0;
Для каждого стр из ЗаказКлиента.Товары Цикл
стр.Сумма = стр.сумма * 1.2;
СуммаТоваров = СуммаТоваров + стр.Сумма;
КонецЦикла;
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Во втором блоке выделены логические области: переменные, изменение строки заказа, заполнение переменных, изменение заказа. Эти области обрамлены отступами, что отделяет их от основного кода.
Функция выполняет только одну операцию на одном уровне.
Если функцию можно разделить на секции (области, блоки), то функция выполняет более одной операции. Если взять блок кода из предыдущего примера, то очевидно, что эта функция выполняет более одной операции.
Процедура РассчитатьСуммуТоваров()
СуммаТоваров = 0;
Для каждого стр из ЗаказКлиента.Товары Цикл
стр.Сумма = стр.сумма * 1.2;
СуммаТоваров = СуммаТоваров + стр.Сумма;
КонецЦикла;
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Из операций можно выделить следующие: изменение строки заказа, добавление данных в массив, изменение переменной, изменение документа. Так же здесь 3 уровня: переменные, строки заказа, документ заказа. Таким образом нужно выделить 2 метода.
Процедура РассчитатьСуммуТоваров()
СуммаТоваров = 0;
Для каждого стр из ЗаказКлиента.Товары Цикл
ИзменитьСтрокуЗаказа(стр);
СуммаТоваров = СуммаТоваров + стр.Сумма;
КонецЦикла;
ИзменитьСуммуЗаказа(ЗаказКлиента, СуммаТоваров );
КонецПроцедуры
Процедура ИзменитьСтрокуЗаказа(стрЗаказа)
стрЗаказа.Сумма = стрЗаказа.сумма * 1.2;
КонецПроцедуры
Процедура ИзменитьСуммуЗаказа(ЗаказКлиента, СуммаТоваров)
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Это наиболее простой пример, встречаются примеры, когда выделяются целые циклы или несколько циклов.
Чтение кода сверху вниз: правило понижения.
В одной функции вызываются функции одного уровня абстракции. В предыдущем примере было четко видно 3 уровня абстракции: переменные, строки заказа, документ заказа. После выделения в отдельные методы, в одной функции остался только один уровень абстракции. Таким образом при чтении метода если мы будет проваливаться в один из методов мы будем углубляться в подробности, переходить на более низкий уровень абстракции, но в пределах одного метода мы будет на одном уровне абстракции.
Содержательные имена.
Требования к именованию методов такие же, как и к переменным: имена должны отражать то, что делает метод, нести логический смысл, не быть перегруженными и т.д.
Аргументы функций.
Максимум 2-4 аргумента. Однако есть хитрость: если у функции несколько аргументов их можно объединить в структуру, и передавать структуру как один аргумент.
Возврат должен явно отображаться. Помните, что все ветви выполнения кода в функции должны содержать возврат. Так же функция должна всегда возвращать значение. Не следует использовать функции без возврата.
Возврат через аргументы не следует использовать. Для возврата значений используйте функции и возвращаемые параметры (ключевое слово Возврат). Возврат через аргументы делает код запутанным.
Передача флага в аргумент.
Зачастую, если в функцию требуется передать флаг – это значит, что функция выполняет более одной операции и её требуется разбить на несколько методов.
Передача множества аргументов
Если в аргументах передается много параметров одного объекта (или структура, содержащая много параметров одного объекта), проще передать весь объект.
Много аргументов можно обернуть в массив или структуру и передавать как один аргумент. В этом случае нужно создать описание метода и описать структуру параметра, какие поля он содержит.
Побочные эффекты.
Метод делает дополнительные операции, не заявленные в имени. Для примера возьмем безвредную на первый взгляд функцию. Функция использует стандартный алгоритм для проверки пары «имя пользователя/пароль». Она возвращает Истина в случае совпадения или Ложь при возникновении проблем. Но у функции также имеется побочный эффект. Имя ПроверитьПароль сообщает, что функция проверяет пароль. Оно ничего не говорит о том, что функция инициализирует сеанс. Таким образом, тот, кто поверит имени функции, рискует потерять текущие сеансовые данные, когда он решит проверить данные пользователя.
Проверка и действие – разные методы. Пример:
Если ИзменитьРеквизит("Имя", "Иван") Тогда
В данном случае непонятно, что делает функция ИзменитьРеквизит и почему она используется в условии. Для данного случая следует создать 2 функции: первая, которая изменяет реквизит, и вторая, которая проверяет, что реквизиту задано соответствующее значение.
Если Не ПроверитьРеквизит("Имя", "Иван") Тогда
ИзменитьРеквизит("Имя", "Иван");
КонецЕсли;
Попытка и исключение
Код внутри попытки и внутри исключения лучше выносить в отдельные методы.
Комментарии
О комментариях
Ничто не помогает так, как уместный комментарий. Ничто не загромождает модуль так, как бессодержательные и безапелляционные комментарии. Ничто не приносит столько вреда, как старый, утративший актуальность комментарий, распространяющий ложь и дезинформацию.
Грамотное применение комментариев должно компенсировать нашу неудачу в выражении своих мыслей в коде. Обратите внимание на слово «неудачу». Комментарий — всегда признак неудачи. Мы вынуждены использовать комментарии, потому что нам не всегда удается выразить свои мысли без них.
Комментарии лгут. Не всегда и не преднамеренно, но это происходит слишком часто. Чем древнее комментарий, чем дальше он расположен от описываемого им кода, тем больше вероятность того, что он просто неверен. Причина проста: программисты не могут нормально сопровождать комментарии.
Неточные комментарии гораздо вреднее, чем полное отсутствие комментариев. Они обманывают и сбивают с толку. Они создают у программиста невыполнимые ожидания. Они устанавливают устаревшие правила, которые не могут (или не должны) соблюдаться в будущем. Истину можно найти только в одном месте: в коде. Только код может правдиво сообщить, что он делает. Это единственный источник действительно достоверной информации.
Одной из распространенных причин для написания комментариев является низкое качество кода. Вы пишете модуль и видите, что код получился запутанным и беспорядочным. Вы знаете, что разобраться в нем невозможно. Поэтому вы говорите себе: «О, да это стоит прокомментировать!» Нет! Лучше исправьте свой код! Ясный и выразительный код с минимумом комментариев гораздо лучше громоздкого, сложного кода с большим количеством комментариев. Не тратьте время на написание комментариев, объясняющих созданную вами путаницу, — лучше потратьте его на исправление.
Сейчас в своей практике я редко использую комментарии. Когда я только начинал применять правила чистого кода, я часто писал комментарии. Применяя все больше и больше правил я практически полностью избавился от комментариев.
TODO комментарий
Можно оставлять TODO комментарии. Они обозначают намерения реализовать данный метод позже. Возможно сейчас его нельзя реализовать в полной мере.
Процедура ИзменитьСуммуТовара(стрЗаказа)
//TODO: сделать изменение суммы товара
//Сейчас модуль расчета суммы не реализован
КонецПроцедуры
По «TODO» очень легко искать места, которые ещё не реализованы. Достаточно воспользоваться поиском.
Непонятные комментарии
Если при прочтении комментария стороннему человеку не понятно, что он значит – это плохой комментарий
Процедура ИзменитьСуммуЗаказа(ЗаказКлиента, СуммаТоваров)
// заказ
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Избыточные комментарии
Если код понятен без комментария, комментарий не поясняет и не дополняет код – это плохой комментарий.
Процедура ИзменитьСуммуЗаказа(ЗаказКлиента, СуммаТоваров)
// измененный заказ проводится
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Противоречащие комментарии
Если комментарий противоречит коду – это плохой комментарий.
Процедура ИзменитьСуммуЗаказа(ЗаказКлиента, СуммаТоваров)
// заказ записывается без проведения
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Чаще всего причина таких комментариев – изменение кода без изменения комментариев.
Обязательные комментарии
Обязательные комментарии – зло (описание методов и аргументов – обязательные комментарии по стандартам). Их стоит использовать только тогда, когда это действительно необходимо. Не стоит к каждому методу приписывать описание.
Комментарии для сложных блоков кода
Использовать комментарий для пояснения сложного блока кода – плохо. Лучше сложный блок обернуть в метод и дать методу понятное наименование.
Закомментированный код
Закомментированный код – плохой комментарий. Другие разработчики не решатся его удалить, а о его важности будет знать только создатель. Такой код может жить в модуле несколько лет.
Связь комментария с кодом
Связь между комментарием и кодом должна быть очевидной. Прочитав код и комментарий, комментарий должен пояснить код, а не запутать.
Комментарии для методов
Хорошо выбранное имя метода лучше, чем имя метода и комментарий.
Форматирование
Детализация
Степень детализации увеличивается сверху вниз. Сверху – высокоуровневые концепции и алгоритмы, снизу – все методы и подробности низшего уровня.
Сверху метод с алгоритмом (высокий уровень), снизу методы изменения строки и проведения документа (низкий уровень).
Процедура РассчитатьСуммуТоваров()
СуммаТоваров = 0;
Для каждого стр из ЗаказКлиента.Товары Цикл
ИзменитьСтрокуЗаказа(стр);
СуммаТоваров = СуммаТоваров + стр.Сумма;
КонецЦикла;
ИзменитьСуммуЗаказа(ЗаказКлиента, СуммаТоваров );
КонецПроцедуры
Процедура ИзменитьСтрокуЗаказа(стрЗаказа)
стрЗаказа.Сумма = стрЗаказа.сумма * 1.2;
КонецПроцедуры
Процедура ИзменитьСуммуЗаказа(ЗаказКлиента, СуммаТоваров)
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Отступы между строками
Каждая группа строк представляет законченную мысль. Такие группы следует разделять пустыми строками.
Процедура РассчитатьСуммуТоваров()
СуммаТоваров = 0;
Для каждого стр из ЗаказКлиента.Товары Цикл
стр.Сумма = стр.сумма * 1.2;
СуммаТоваров = СуммаТоваров + стр.Сумма;
КонецЦикла;
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров;
ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
КонецПроцедуры
Выделены логические области: переменные, изменение строки заказа, заполнение переменных, изменение заказа. Эти области обрамлены отступами, что отделяет их от основного кода.
Строки кода, между которыми существует тесная связь, должны быть вертикально сжаты, между ними нет пустых строк, комментариев и других разрывов.
Объявление переменных
Переменные объявляются непосредственно перед их использованием. Не следует объявлять переменные в начале модуля. Дойдя до места их использования, читатель забудет об их существовании.
Расположение вызываемых методов между собой
Вызываемый метод должен находится радом с вызывающим, а вызывающий метод должна быть сверху (если это возможно).
Длинна строк
Строки должны быть шириной не более 120 символов.
Разделение и сжатие
Следует использовать горизонтальное сжатие и разделение. Операторы присваивания выделять с двух сторон пробелами, разделять пробелами аргументы методов, после запятой ставить пробел. А вот метод и скобку наоборот следует сжимать, не разделяя.
Отступы
Исходный файл имеет иерархическую структуру. В нем присутствует информация, относящаяся к методам внутри модулей; к блокам внутри методов и рекурсивно – к блокам внутри блоков. Каждый уровень этой иерархии образует область видимости, в которой могут объявляться имена и в которой интерпретируются исполняемые команды. Чтобы создать наглядное представление этой иерархии, мы снабжаем строки исходного кода отступами, размер которых соответствует их позиции в иерархии. Команды уровня методов отступов не имеют. Реализации этих методов сдвигаются на один уровень вправо от объявления метода. Реализации блоков сдвигаются на один уровень вправо от своих внешних блоков и т. д. Программисты широко используют эту схему расстановки отступов в своей работе. Чтобы определить, к какой области видимости принадлежат строки кода, они визуально группируют строки по левому краю. Это позволяет им быстро пропускать области видимости, не относящиеся к текущей ситуации (например, реализации команд Если и Цикл). У левого края ищутся объявления новых методов, новые переменные. Без отступов программа становится практически нечитаемой для людей.
Не стоит удалять отступы и нарушать их иерархию, даже если условие состоит из одного оператора.
Многопоточность и длительные операции
Многопоточность и длительные операции полезны только при большом объеме данных. На их реализацию необходимо дополнительное время. Не следует реализовывать многопоточность и длительные операции без должного изучения.
Практический результат
- Разработка конфигурации для внутренних нужд нашей компании. На разработку был выделен молодой и перспективный разработчик без опыта работы. В то время ещё не было в нашей команде понятия о стандартах и чистом коде. Разработка планировалась на 2 месяца с учетом неопытного сотрудника. Проект был начат в далеком январе 2022 года… И продолжается до сих пор. Код этого проекта – «легаси» (кому интересно поищите в интернете определение). Сам же разработчик закончил работу только через 6 месяцев. Никто, даже он, уже не могли разобраться в написанном. Этот тот проект, о котором можно сказать: «проще все с нуля сделать, чем переделывать». Кто-то может сказать: причина в неопытности. Я же скажу следующее: если бы разработчик руководствовался не своими фантазиями, а конкретными правилами, то вышел бы качественный продукт. В данном случае на этапе разработки сроки превышены в 3 раза, а сопровождаемость снижена до нуля.
- Разработка модуля интеграции с облачной кассой для торговых конфигураций. В этом проекте было 2 модуля: интеграция с УТ (первый этап) и интеграция с ещё двумя конфигурациями (УНФ, Розница 2.3) (второй этап). Первый этап был оценен в 2 месяца с учетом тестов клиента. При разработке старались придерживаться стандартов и правил чистого кода. Разработкой занимался я лично. Проект был закончен в срок. Когда начали выполнять второй этап, за основу взяли код из первого этапа. На проект было заложено 2 месяца (при объеме работ на 20% больше, чем в первом этапе). Разработкой занимались два других менее опытных разработчика по отдельности (каждый на своей конфигурации). На мое удивление, вопросов было очень мало, а разработчики самостоятельно во всем разобрались. Второй этап был закончен за 1 месяц. В данном случае мы получили опережение по срокам в 2 раза.
- Расширение стороннего разработчика для УТ. После обновления конфигурации мы уже 3 месяца получаем ошибки в совершенно разных местах (при том, что большинство ошибок были исправлены сразу после обновления). Часто ошибки одни и те же, но возникают в разных местах (дублирование кода). На такие ошибки, по первоначальной оценке, мы должны были тратить не более 1 часа. Однако после некоторого количества таких ошибок стало понятно, что время исправления занимает около 3-4 часов. Проблема кроется в запутанности кода.
Заключение
В этой главе я показал правила из главы 2 книги. Они представляют собой конкретные действия, которые я и моя команда соблюдаем. Так же я привел практические примеры, которые для меня показывают эффективность описанных правил. Сейчас мы в команде стараемся руководствоваться этими (и не только) правилами при работе.
Приглашаю обсудить все в комментариях, много спорных вопросов. Надеюсь, вы выскажете свое драгоценное мнение, чтобы улучшить этот мир!
Вступайте в нашу телеграмм-группу Инфостарт
чистый код рефакторинг Роберт Мартин качество кода статья стандарты написания кода
Вы можете заказать платную адаптацию этой статьи под ваши задачи на «Бирже заказов».
- 0% комиссии — оплата напрямую исполнителю;
- Исполнители любого масштаба — от отдельных специалистов до команд под проект;
- Прямой обмен контактами между заказчиком и исполнителем;
- Безопасная сделка — при необходимости;
- Рейтинги, кейсы и прозрачная система откликов.
См. также
Нейросети Рефакторинг и качество кода Запросы Разработчик 1С 8.3 Абонемент ($m)
Нейросеть написала запрос или процедуру для вашей базы 1С, и непонятно, все ли имена в нём настоящие. Обработка компилирует текст без выполнения, сверяет его с метаданными этой базы и к каждой ошибке пишет настоящее имя, например ВНаличииОстаток вместо выдуманного КоличествоОстаток. Список ошибок с подсказками одной кнопкой копируется обратно в чат с моделью.
10 стартмани
02.11.2026 401 2 nedomolkov.ivan 3
Рефакторинг и качество кода Разработчик 1С:Предприятие 8 Россия Бесплатно (free)
Одна проверка в обработчике кнопки может выглядеть достаточной, пока ту же операцию не вызовут из другого места. На примере управляемой формы разберём, почему так происходит, как разместить проверку в общей серверной функции и чем отличается удобная проверка ввода от обязательного условия выполнения операции.
29.10.2026 423 YA_777378709 0
Рефакторинг и качество кода Разработчик Бесплатно (free)
Рассказываем, почему качественный код – это не техническая прихоть, а актив, который помогает бизнесу быстрее адаптироваться к изменениям и запускать новые фичи без бесконечного преодоления техдолга. Показываем, как объяснить бизнесу ценность рефакторинга через понятные признаки: замедление разработки, неточные оценки, страх перед legacy и хрупкость системы. Разбираем, почему неправильный рефакторинг может быть дороже его отсутствия, какие анти-паттерны ломают процесс и как не превратить улучшения в бесконечную переделку ради переделки. Объясняем, как сделать рефакторинг частью культуры команды: договориться с бизнесом, научить разработчиков видеть проблемные места, закрепить правила и поддерживать улучшения на уровне тимлидов, архитекторов и всей команды.
28.10.2026 532 Pavel791 0
Рефакторинг и качество кода HighLoad оптимизация Системный администратор Разработчик Стажер 1С 8.3 Абонемент ($m)
Если к HTTP-сервису 1С обращаются сразу несколько программ, сколько запросов в секунду он успеет обработать? Я опубликовала простой HTTP-сервис на нашей "подопытной" конфигурации «Нано-УТ» (файловая база, Apache, без прав администратора) и нагрузила его скриптом на Python. Ответ: около 15-16 запросов в секунду, сколько бы клиентов ни обращалось одновременно. Запросы ждут своей очереди, и при 32 клиентах ответ приходит через 2 секунды вместо 64 мс. Заодно разобрала скрипт из первого варианта статьи: он «проверял» сервер, который отвечал по одному, и считал ошибки вместе с успешными ответами. В архиве исправленный скрипт, учебный сервер, HTTP-сервис для 1С и инструкция по запуску.
1 стартмани
23.10.2026 551 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 497 Ninel_S 2
Рефакторинг и качество кода EDT СКД Разработчик 1С 8.3 1С 8.5 1С:Бухгалтерия 3.0 Бесплатно (free)
Одиннадцать граблей схем компоновки, которые не видно в конструкторе и не ловит EDT, на реальных отчетах БП КОРП. Формат числа задается в двух местах, и условное оформление варианта перебивает формат поля. Ресурс складывает штуки с часами, и помогает выражение «только когда единица одна». Ресурс пуст в детальных записях, параметр не появляется в шапке без userSettingID, valueListAllowed ломает границы периода, Остатки и СрезПоследних с параметром периода падают с «Несоответствием типов», title без xsi:type дает «Исключение XDTO» при загрузке. В конце код проверки схемы из файла до обновления базы, сводная таблица и чеклист.
16.10.2026 581 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 3634 Konstmax13 11
Рефакторинг и качество кода Тестирование QA Разработчик 1С 8.3 Абонемент ($m)
Инженерный анализ влияния (Impact Analysis) при изменении общего метода в 1С:Предприятии: почему штатный поиск ссылок скрывает 99% зависимостей и как обратный обход графа вызовов выявляет 370 скрытых потребителей на глубине 3 уровней. В статье — верификация сквозной цепочки обмена с маркетплейсом; в архиве-компаньоне — автономный BFS-анализатор на Python, слепки графа и план регрессионного тестирования.
1 стартмани
12.10.2026 349 Ninel_S 0
хотелось бы "автоматизации" проверки на стандарты...
и о чудо, она есть... (но не совсем из коробки)
Лучше, когда код можно проверить сразу ... прямо не выходя из конфигуратора!
1) (спасибо автору Отымко)
ставится в Windows просто 1 файлом - легко и понятно - запустить - далее-далее - готово!
пользоваться - прямо из кода модуля - Ctrl +Shift + i см. фото ниже - список ...
кликабельный - сразу перепрыгивает на строку ошибки.
сам уже года 2 наверное использую... необходимость ставить "лишние" пробелы между операторами = > < + - * /
меня лично бесят, но это не ошибка, я это игнорирую.
2) Для всей конфы - (после выгрузки в файлы) - удобнее использовать Visual Studio Code (бесплатный!), ну или кто любит - SonarQube (платный), который ещё настраивать на отдельном сервере надо...
это для "продвинутых" только... для "начинающих" я читаю он не подъёмный, уж извините.
Visual Studio Code пользоваться можно для проверки в целом уже написанного (см. скрин VSC)
(и да, там есть тёмная тема для 1С, что очень не плохо для проверки кода по ночам)
- открыть папку с файлами выгрузки из конфы ...
(установить 1 раз! "расширение для VSC": 1C (BSL) Extention Pack ) и вуа-ля... чудо проверки уже в кармане.
Насчет примеров я бы поспорил немного, ну да ладно,
разделять 1 маленькую функцию на "абстракции" по 1 строке... это только запутывает,
я бы тут добавил ещё пару "метрик" - число процедур и функций в модуле... мин - макс и среднее число строк в них
наверное это "легко" добавить, но почему-то никто это не сделал (или я не вижу где это посмотреть)
и "целесообразность" увеличения числа процедур и функций.
Оба этих инструмента работают на "одном движке" - , который постоянно обновляют и дорабатывают различные проверки по стандартам 1С.
Потому что чек-лист конечно хорошо, но ... тут могут появиться разные понимания... что лучше что хуже
и упрётся всё в то, что это "вкусовщина" или "делай как я сказал" , "я начальник - ты дурак"...
Каждый! даже начинающий разработчик должен легко уметь проверить свой код на "чистоту".
и "аргументация" в цифрах всегда выглядит убедительнее... Есть ошибки - исправляй, Предупреждения... тоже не хорошо, про Предупреждения... уже спорно, но не красиво
VSC ещё показывает и "когнитивную сложность" методов и функций - это как раз и есть "запутанность" кода
она так же меряется в цифрах... норма 5-10 , но для 1С бывает процедуры и до 50 -100 легко, тут так же не нужно очень сильно дробить 1 мега-функцию на кучу по 1-5 строк, но задуматься стоит.
P.S.
а) Оформление кода "лесенкой" делается в 2 нажатия ...
1) выделить часть кода или весь текст Ctrl + A
2) Alt +Shift + F (или через главное меню Текст - Блок - Форматировать)
б) Двойные пустые строки - считаются "дефектом кода" и в VSC и в Фениксе - они отображаются как Информация или Предупреждение - из VSC - можно сразу (по гипер-ссылке) открыть подробное описание ""
Лишние строки... я считаю излишком, да, только блоки разделять надо, а не после каждой строки - пустую
это только растягивает текст не на 1 а на 2-3 экрана и читать невозможно становится.
Перепечатывание Макконнелла и Мартина - ну такое себе занятие, достаточно бессмысленное. Кому нужно - сам прочитает, кому не нужно - так и будет нарушать правила, даже зная о них. Лучше уж СонарКуб настроить.
Это не перепечатывание, как я считаю. Я привел много своих мыслей, интерпретаций, пояснений и примеров. Начинающий 1Сник, прочитав Мартина, ничего не выявит для себя. Да и не факт, что сможет разобраться в java коде.
"Кому нужно - сам прочитает" - так можно о чем угодно сказать.
Касаемо сонаркуба - там есть тонкости и нюансы. Наименования он не откорректирует. В частности сонаркуб не заменит хорошего рефакторинга от эксперта. Я бы сказал, что они дополняют друг друга.
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиента.СуммаДокумента = СуммаТоваров; Товар.Объект = стр.Товары.ПолучитьОбъект();
Для каждого стр.Поставщики из ТоварОбъект.Поставщики Цикл
стр.Поставщики = Неопределено;
КонецЦикла;
ТоварОбъект.Записать();
Не кажется, что это плохой пример? Тип лучше наверное вынести в докстринг, а не оставить в названии, тем более, что например edt подсказывает, если докстринг правильно оформлен. Функции, насколько могу судить, не стоит называть с "Получить..." лучше тогда ЗаказыКлиентовСДатамиПроведения(), не?
"Имена процедур в общем случае, следует образовывать от неопределенной формы глагола, от сути выполняемого действия" - из стандартов. Делаем вывод, что имена процедур в общем случае всегда от глагола.
"В имени функции рекомендуется использовать глаголы в неопределенной форме в тех случаях, когда для понимания назначения функции важно, каким образом было получено возвращаемое значение." - функция, делаем вывод, что если в функции главное возвращаемое значение - то от глагола.
"Если выполнение функции предполагает, прежде всего, какое-либо действие, и при этом возврат значения не является ее основной задачей (например, это признак успешно выполненного действия), то имена таких функций следует образовывать от неопределенной формы глагола, как и для процедур." - функция, тоже от глагола.
В итоге стандарты всегда рекомендуют от глагола начинать, меняется только его форма: определенная или неопределенная.
"Имена процедур в общем случае, следует образовывать от неопределенной формы глагола, от сути выполняемого действия" - из стандартов. Делаем вывод, что имена процедур в общем случае всегда от глагола.
"В имени функции рекомендуется использовать глаголы в неопределенной форме в тех случаях, когда для понимания назначения функции важно, каким образом было получено возвращаемое значение." - функция, делаем вывод, что если в функции главное возвращаемое значение - то от глагола.
"Если выполнение функции предполагает, прежде всего, какое-либо действие, и при этом возврат значения не является ее основной задачей (например, это признак успешно выполненного действия), то имена таких функций следует образовывать от неопределенной формы глагола, как и для процедур." - функция, тоже от глагола.
В итоге стандарты всегда рекомендуют от глагола начинать, меняется только его форма: определенная или неопределенная.
Функция ПолучитьТЗЗаказыКлиентов() по стандарту будет правильней называться
ЗаказыКлиентов()
Смотрите примеры в пункте 4
Незначимые глаголы (типа вернуть , получить, создать) - не нужно использовать
П. 6.1. Имена функций в общем случае следует образовывать от описания возвращаемого значения.
И только в том случае, если важно, как это значение получено, тогда использовать глаголы рекомендуется, но это далеко не общий случай
Не понял почему это плохо. Ведь если в расширяемый объект конфигурации добавили свой реквизит "ТЗЗаказы", то тут вероятность того что когда-нибудь появится такой же реквизит от поставщика выше, чем реквизит наименования "Расш1_ТЗЗаказы".
Или имелось ввиду что в своей объект расширения, например Расш1_Документ, добавляют реквизиты с префиксом "Расш_"?
Процедура Пупкин_СделатьЧтоТо()
Я читаю код ради ответов на два ключевых вопроса:
- что код делает?
- как код делает?
в в 99,999% случаев мне совершенно по-барабану, кто правил тот код пять лет назад, Пупкин, Залупкин или Васечкин. Это абсолютно мусорная информация, но она преследует всю дорогу
- если это переменная
- если это метод
- если это реквизит в самописном объекте метаданных
Что касается добавления реквизитов в расширяемые объекты - тут тоже не всегда используются префиксы. Если наименование точно не будет использоваться поставщиком (например, отраслевой термин не из отрасли конфигурации или сокращение, которое принято внутри компании), то префикс можно смело отбрасывать.
В общем случае префикс или суффикс без необходимости - плохо. Надеюсь моя мысль понятнее стала. Добавлю Ваше уточнение в статью пожалуй.
Максимум 2-4 аргумента. Однако есть хитрость: если у функции несколько аргументов их можно объединить в структуру, и передавать структуру как один аргумент.
Не то, чтобы хитрость, скорее требование к стандартам написания кода от 1С.
группировать однотипные параметры в один или несколько составных параметров типа Структура. Например, в структуры могут быть объединены параметры, описывающие состав и значения полей некоторого объекта (ДанныеЗаполнения, ПараметрыПроведения, ДанныеФайла и т.п.);
Как по мне, называть хитростью то, что есть в стандартах - неверно.
Что касается того, как называть это - хитрость или рекомендация стандартов, дело сугубо личное. Представление слова "хитрость" для меня и для вас может быть абсолютно разным. Я назвал хитростью, потому что фактически количество параметров не изменилось. Что было 20 параметров, завернули в структуру, так и осталось 20 параметров, только в обертке. Объем данных не уменьшился. Поэтому и называю хитростью. Могу назвать обманом неопытного юзера.
Вообще структуры в параметрах часто только к ухудшению понимания приводят, т.к. документацию к этим структурам никто не хочет писать. А ещё реже обновляют её при изменении количества параметров в структуре.
как по мне так выглядит куда лучше и компактней. Помню "увидел" подобный стиль написание печатной формы, это было не возможно воспринимать цельно, потому что печать шапки была на 2 экрана вниз
На счет метода ОчиститьПоставщиковНоменклатуры тут пример сильно упрощен, там пару строк кода. На деле в ней может быть 500 или 1000 строк кода (в типовой и такое есть). И если такую уже декомпозировать - сильно проще жить становится. Это если вы про пункт "Компактность".
С наставниками начинают немногие. Большинство (как и я ) начинают в одиночку, по необходимости.
Касаемо наставника, многие или не многие - сложно судить. У всех разное окружение, в разных компаниях были. За всю страну тоже не скажешь. В моем окружении все начинали с наставником. В моем окружении все, кто приходил на новое место - был наставник.
Опять же повторюсь, я не говорю как надо делать, а как не надо. Я рассказываю как это сделано в нашей команде (в начале статьи писал об этом). В нашей команде у всех есть наставник в обязательном порядке.
Я сейчас использую функции, которые возвращают какое-то значение, потом в коде обращаюсь к этой функции избегая "магических чисел".
// Константа количество строк по умолчанию
//
// Возвращаемое значение:
// Число -
Функция КОЛИЧЕСТВО_СТРОК_ПО_УМОЛЧАНИЮ()
Возврат 5;
КонецФункции
ПоказатьНе давно хотел на форуме обсудить эту тему, но был заклеван "труодинэснигами", и обсуждения не получилось.
Хотелось бы узнать мнение автора об этом.
В 1С нет как такового понятия констант на программном уровне (объект метаданных константа - немного другое, отличается от общепринятого понятия константы в программировании). Сонаркуб, например, рекомендует выносить магические числа в переменные непосредственно перед их использованием.
Ну я и в одном методе, если она используется в нескольких местах делаю через вызов функции, потом когда придёт время доделывать или исправлять, меньше вероятность, что кто-то по не знанию изменит переменную или передаст её в процедуру где она может быть также изменена.
Вот и в примерах из статьи хочется сказать: "вы книгу прочли, это - хорошо. А теперь переходите на следующий уровень".
И, чтобы не писать одно и тоже - я понимаю, что это примеры, но примеры не должны вводить в заблуждение.
============================================================
"Что скажите о переменной ЭлТЧФорма? "
Никакое "название" здесь вообще не удобно, т.к. самодокументированное название переменной, вы же за него ратуете?
Должно максимально соответствовать коду и "ломаться", если что-то поменялось.
Поэтому здесь уместно что-то вроде "Элементы.Товары" - везде, не надо эти самые "Элементы.Товары" пихать в промежуточную переменную.
============================================================
"ПолучитьТЗЗаказыКлиентовСДатамиПроведения"
Плохо (кстати, что вы там про венгерскую нотацию говорили?), т.к. когда вы решите, что надо возвращать не тз, а, например, массив структур, для передачи с клиента на сервер, имя метода вы скорее-всего не поменяете.
Понятно, что это из-за отсутствия типизации в 1С, увы, с этим что-то точно сделают в версии 1С 10.15.1890, надеюсь ...
============================================================
"20 строк. Именно столько нужно для выполнения любой хорошо выделенной части кода на одном уровне абстракции"
Вы же сами догадываетесь, что что-то здесь не так. Помедитируйте, что произойдет, если вместо 20 подставить 21 или 19 или 100.
20 - не магическое число, а что-то для "прикинуть палец к носу", причем зачастую еще и применительно к конкретному языку программирования.
============================================================
"Из операций можно выделить следующие: изменение строки заказа, добавление данных в массив, изменение переменной, изменение документа. Так же здесь 3 уровня: переменные, строки заказа, документ заказа. Таким образом нужно выделить 2 метода."
Выглядит как пародия. Выделение методов, когда каждый метод используется только один раз и из метода, который состоит из небольшого кол-ва строк - это антипаттерн. Будем надеяться, что вам попадет в руки какая-нибудь авторитетная для вас книга еще и про это.
И, нет, в вашем конкретном примере, все стало на порядок хуже и для чтения и для сопровождения.
============================================================
"Использовать комментарий для пояснения сложного блока кода – плохо. Лучше сложный блок обернуть в метод и дать методу понятное наименование."
Вы как-то странно понимаете обязательные комментарии.
Комментарий, по-возможности, не должен описывать как код делает что-то "сложное", это да. Он должен пояснять почему это делается. Вы же сами про это написали, нет?
Например: "наличие промежуточной переменной при чтении файла в ComSafeArray средставами ADODB (проверено на версии 2.1) - обязательно, т.к. иначе при чтении больших файлов будут возникать не понятная ошибка MS SQL про невозможность чтения в image"
Про форматирование уж не буду - это тема пятничная, но, честно говоря, некоторые "хорошие" приемы вроде вставки пустой строки после каждой строки кода..., ладно - ладно не буду.
Это же пример. Там весь кусок кода по сути бред. Конечно имеется в виду, что в реальности есть более осмысленный и большой кусок кода, который лучше декомпозировать.
- нужно приводить контекст задачи и бизнеса
- декомпозиция может быть огромной (самый простой функционал может занимать 10-15 методов)
Такое никому неинтересно читать. Поэтому привожу пример на кошках.
""Что скажите о переменной ЭлТЧФорма? "
Никакое "название" здесь вообще не удобно, т.к. самодокументированное название переменной, вы же за него ратуете?
Должно максимально соответствовать коду и "ломаться", если что-то поменялось.
Поэтому здесь уместно что-то вроде "Элементы.Товары" - везде, не надо эти самые "Элементы.Товары" пихать в промежуточную переменную." - таким образом вы каждый раз читаете элемент вместо того чтобы его переиспользовать... 5 баллов. Про то, что все должно ломаться при изменениях я вообще не писал - не надо придумывать.
""ПолучитьТЗЗаказыКлиентовСДатамиПроведения"" - прочитайте другие комментарии, уже обсуждали это
"20 строк. Именно столько нужно для выполнения любой хорошо выделенной части кода на одном уровне абстракции" - посмотрите мой комментарий к этому. Я не увидел в вашем комментарии никакого обоснования, только абстрактные слова "помедитируйте" и "прикинуть палец к носу". Если есть что сказать по существу - так и напишите. Чего ребусы загадывать. А если не нельзя сказать ничего по существу - может и не стоит...
"Из операций можно выделить следующие: изменение строки заказа, добавление данных в массив, изменение переменной, изменение документа. Так же здесь 3 уровня: переменные, строки заказа, документ заказа. Таким образом нужно выделить 2 метода." - чтение вещь субъективная. На счет сопровождения все наоборот, появляется механизм переиспользования. Если уж говорите, что какой-то механизм ухудшает какой-то аспект, потрудитесь аргументировать. Иначе - субъективное мнение, так же как и чтение.
"Использовать комментарий для пояснения сложного блока кода – плохо. Лучше сложный блок обернуть в метод и дать методу понятное наименование." - в этом пункте я вообще не пишу про обязательные комментарии, видимо не очень внимательно читали.
"приемы вроде вставки пустой строки после каждой строки кода" - этого у меня вообще нет в статье, не надо придумывать.
Вы совсем не поняли мой посыл. Прочитайте самое начало. Это не свод обязательных правил, а РЕКОМЕНДАЦИИ. Рекомендации могут как навредить, так и помочь. Надо думать, где их применять. Вы привели пример с промежуточной переменной - используйте комментарий на здоровье. Если кто-то будет так комментировать каждую переменную (буквально каждую) - ну тут я бы уже к врачу посоветовал сходить.
В последнем примере:
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров; ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
, но по той же идее должно быть:
ЗаказКлиентаОбъект = ЗаказКлиента.ПолучитьОбъект();
ЗаказКлиентаОбъект.СуммаДокумента = СуммаТоваров; ЗаказКлиентаОбъект.Провести(РежимЗаписиДокумента.Проведение);
"В последнем примере:" - я выделил область изменение заказа, в пределах такого уровня разделение не требуется. Если по коду приходится выделять другие области (получение объекта, изменение объекта, проведение), тогда конечно разделение рекомендуется. Тут много моментов, на которые с разных сторон можно смотреть. Ваш вариант тоже имеет место быть.
Ну и еще из практики. Значительного прироста в выполеннии алгоритмов потоками 1С не дает. Прирост в 15-20% по времени.
Но с автором согласен. Так называемую "многопоточность" делать сложно.
Не так сложно, как кажется. Через БСП запустить процедуру в фоне дело плевое.
Есть такой принцип в программировании. Его кстати не увидел в Вашем посте. Этот принцип называется KISS. Спойлерить не буду. Сами прочитайте.
Этот принцип я тоже использую на своих проектах.
А теперь давайте представим, что будет с сервером, если эти 30ть регламентных заданий запустит ну скажем 100 пользователей одновременно?
И я не спорю, что будет быстрее. Будет. Но какой ценой? И разве фоновое задание это многопоточность? Многопоточность в нормальных языках программирования делается на уровне операционной системы, а не копией программы в оперативке.
Я понимаю, что у вас в коллективе две бухгалтершы Клавы, главбук Ася и с десякок менеджеров. Но так бывает не везде. В некоторых огранизациях один НР отдел из 5ти человек, а с базой работет не пара менеджеров, а 1000 человек одновременно вбивают расходные накладные, а тут программист Вася решил, что запустить одновременно 100 фоновых заданий под учеткой менеджера будет хорошей идеей. А что будет с сервером 1С? Он потянет нагрузку? Или программисту Васе пофигу. Ему виднее сколько под одной учеткой должно взлететь фоновых заданий, которые при этом родят взаимные блокировки.
А я отвечу. Завод встанет и весь 1С отдел поднимут на уши. И все будут бегать и разбираться, почему 1С сервер снова вдруг внезапно упал.
П.с. И это не шутка. У нас на заводе была похожая ситуация. Правда виновник торжества был до этого уволен, но следы в ситеме были оставлены. Мина замедленного действия сработала.
Я видел много вот таких специалистов, которые выросли на крови, поте и слезах. Не просто выросли, а не смогли сделать из этого никаких выводов и ничему не учатся и до сих пор так и живут в крови, слезах и поте. Жалкое зрелище.
Правило первое - умейте ограничивать свою фантазию.
Потому, что всегда оказывается, что "ТОЧНО ТАКАЯ ЖЕ!!!!!" ситуация, это сервер с полки уронили. Но в остальном все один в один.
P.S. Я рекомендую вам тестировать код централизовано. Тогда вы уже на тестах увидите проблемы и не надо будет никого увольнять.
Kiss - Метод рабочий. Если пишите код, то надо смотреть на перспективу. Писать сразу с учётом возможной нагрузки. Тогда и переписывать ничего не придётся.
P.s. после того, как мы поняли, кто наговнокодил, код псевдо спеца мы закомменировали. Сервер поле этого вернулся в строй и сбоев с взаимными блокировками мы не увидели.
Ну если вы у нас так хорошо владеете подходом KISS, так расскажите о своём опыте. Очень интересно.
А пока нет возможности делится готовыми и работающими везде библиотеками, до clean code будет как до луны.
Там нет большого дополнительного времени, если вести изначально доработки и разработку с учетом возможности многопоточности. Просто откладывая на потом Вы достигнете пределов решения слишком быстро, а переписывать это никто не будет - проще написать новое
(47)
Кстати, если принять что библиотека = расширение, то даже по вашей логике все хорошо становится.
Я не связываю это только с библиотеками , а просто утверждаю что без нормального code reuse, который обеспечивают библиотеки чистого кода не будет. Будет чистая и красивая копипаста, мы же не просто пишем код, а максимально стараемся чтобы он повторно использовался??? и так кругом велосипеды.
Просто нужно сопоставить какой нибудь системный язык типа Java или C# c 1С в части структуры кода, чтобы почувствовать разницу.
А расширение это очередной трюк 1С подмены кода на лету, дабы не портить типовые конфигурации прямым вмешательством. Ведь больша связанность конфигурации и отсуствие понятия "интерфейс" внутри языка не оставляет других вариантов
Мне кажется вы немного путаете нормалный язык ООП с конфигуратором 1С. С моей точки зрения это вообще не язык программирования. Это скорее язык конфигурирования платформы. Все те кто столкнулся с ограничениями 1С уже давно на нормальных языках ООП вроде джавы.
У 1с много минусов. Да. Но есть и плюсы. Например можно писать и отлаживать куски кода прямо в обработке компилируя код на лету без перекомпиляции проекта. Можно использовать удобный мастер отчетов. Можно вообще не кодить, а использовать формы гененируемые конфигуратором и прочее. Создавая справочник вы сразу пишите его в базу и описываете логику взаимодействия с другими объектами. Есть удобные регистры, где все итоги уже посчитаны и где достаточно использовать виртуальные таблицы для доступа к данным. И много еще разных плюшек...
Бизнесу на самом деле наплевать на красивые кнопочки и кастомный интерфейс. Бизнес хочет быстрых и эффективных решений. 1С - как платформа решает эти задачи.
П.с.
Если очень хочется ООП в 1с, то на инфостате полно статей про эмуляцию ООП. Даже я в своих проектах эмулирую работу ООП. Например можно обработку использовать как объект. Так например в ЗУП делается расчет зарплаты. Исходные данные передаются в обрабработку (объект) она что-то там делает и в экспортную переменную (свойство объекта) записывает данные расчета.
Быстрые и эффективные решения это миф, созданный 1с. Ну, пока клепается простенькая конфигурация для ларька, функционал льётся как из ведра. Но в огромных корпорациях разработка на 1с превращается в черепаху, плетется не быстрее разработки на той же Java
Фирма занимается разработкой на Джава. У них бизнес растет и у гениального топа вонзникает идея. А почему бы нам бухню не написать на Джава? Ведь мы же можем? Можем. Все топы собираются. Прикидывают бюджет и тут внезапно выясняется, что купить типовую БП за 15к рублей гораздо дешевле, чем с нуля написать тот же проект на Джава. И так уважаемве товарищи знатоки вопрос. Что решили топы? Разрабатывать свое решение на Джава или купить коробку БП за 15к?
Я не путаю, просто считаю что язык 1С нужно использовать ровно на его возможности. А возможности можно осознать зная продвинутый язык ООП . Тогда и не нужно эмуляций
Дело в том, что мы программисты. Наша работа творческая. Если есть задача и для того, чтобы ее быстро решить нужно сделать эмуляцию ООП, то почему нет? Все в рамках правил 1с.
А вот тут я не соглашусь. Например наследования. Один раз описываешь объект и потом его свойства и методы можно наследовать "детям". Т.е. тебе не надо заново писать код. Все написано в родителе. Т.о. время разработки уменьшается.
Речь про объект ООП в нормальном языке программирования вроде Джава, а не про экспортную процедуру общего модуля в 1С.
Объект.Действие()и
Действие(Объект)суть одно и то же.
Я даже больше скажу, в модном-молодёжном и стремительно набирающем популярность языке Golang, его создатель Google преднамеренно отказался от ООП, оставив лишь некоторые элементы ООП. Ибо ООП ни разу не серебрянная пуля
Но тут я согласен. Вообще механизмы близкие к ООП я даже в языке ООП использовал редко, но использовал. В 1с сейчас вообще никакого неудобства не испытываю. Мне вполне язык 1с устраивает. Все задачи по автомазитазции бизнес процессов я успешно решаю.
Мне кажется результат и трудоемкость использования Вам самому не понравится
В других языках есть как минимум разные методы этого достичь.
Поэтому как только на 1С нужно делать костыли, сразу смотрим в сторону вебсервиса на другом языке
Очень специфическая задача для 1с. Тут я думаю главное понять, а нужно ли ее решать в рамках 1с? Может эффективнее это делать на джава?
1с не универсальна. Ее цель решать бизнес задачи. Автоматизировать бизнес. С этой задачей 1с легко справляется.
Ну а для остального есть другие языки программирования. Зачем для этого использовать 1с мне не понятно.
Сейчас даже подсистему Конграгенты нужно пересобирать под свое решение каждый раз (реквизит или название другое).
Вы тупо не можете новую БСП использовать со старым релизом Бух 3.0 поскольку обратной совместимости нет.
Т.е. БСП это не библиотека , а куски кода "доделай сам"
Тут не универсальности дело, вы просто даже свои pattern программирования не сможете демонстрировать поскольку самая маленькая единица распространения clean code это даже не подсистема, а конфигурация.
Я видел как сравнением и обьединением поженили пару конф Раруса и Бухгалтерию. Это выглядело ужасно, лучше уж через ole или вебсервисами
(66)
Если так можно было, то почему 1С так не сделало? Странно. Не находите?
(66)
Вот тут тоже все странновато выглядит. Я всегда думал, что новая версия БСП выходит с новым релизом БП? Или не так? Может надо просто вовремя обновлять БП, а не изобретать костыли и велосипеды?
(66)
Не надо путать библиотеки написанные на нормальных языках программирования с библиотеками написанными для конфигурирования на 1С. Это разные библиотеки. Я соглашусь с тем, что это куски кода, которые надо адаптировать, а разве при использовании DLL библиотеки в вашей программе не надо допиливать код?
П.с. если вам тах не хватает ООП, то почему вы еще здесь, а не на форуме Джава разрабов например? Там тоже нюансов и "радостей" хватает. В джава например нет нормальных конструкторов запросов или внешних обработок. На сколько я знаю, там надо каждый раз перекомпилировать проект, а на 1с этого можно не делать. Так что и на Джава и на 1С есть свои плюсы и минусы.
(70)
БСП собрана и работает только в рамках какой нибудь типовой конфигурации. А если вы написали свою? Тогда обновление БСП подразумевает ее сборку на уровне кусков кода, это совершенно не мотивирует ее использовать. Есть Демо БСП которая собрана, но она ограниченного применения
Если так можно было, то почему 1С так не сделало? Странно. Не находите?
Ну это рассуждения в стиле Жираф большой ему видней, и просто не замечает что у него под ногами.
1С например, в век многоядерности даже в своих типовых распараллеливание обработки пакетами почти не использует . Я про это
. Странно , не находите?
Я тоже считаю, что механизмы 1с устарели. Нет многопоточности. Это правда. Попытки перейти на современные ИДЕ вроде ЕДТ похвальны, но сколько раз я пробовал отказаться от конфигуратора и перейти на разработку в ЕДТ, то каждый раз сталкивался с тем, что ЕДТ пока еще сырой. Увы.
Да и вообще. Конфигуратор для ЕДТ запущенный в фоне я считаю КОСТЫЛЕМ. Вот когда ЕДТ напрямую в субд будет лить конфигурацию, как это делает конфигуратор, вот тогда думаю можно будет смело на него переходить.
Если Не ПроверитьРеквизит("Имя", "Иван") Тогда
ИзменитьРеквизит("Имя", "Иван");
КонецЕсли;И теперь абсолютно во всех точках вызова мы обречены писать этот трехстрочный блок из двух функций?
Что нам дает эта разбивка?
Вообще если вы задаете такие вопросы, я не очень понимаю зачем вам эта статья.
Или это за дублирование не считается?
Как вообще понять, когда такое оправдано, а когда нет?
Как понять? Ответ: никак. Если вас устраивает побочное действие метода и вы на 100500% уверены что больше никто и никогда не полезет в этот код - не меняйте.
Ещё раз привожу пример с запросом: при каждом запросе проверка на пустой результат.
Дублирование - это когда вы пишете один и тот же код много раз вместо того чтобы завернуть его в метод. Если эти 3 строки по логике вашей работы можно завернуть в один метод - пожалуйста. Но если вам нужно по отдельности проверять и изменять - вам придется это прописывать везде. Вы ведь не сможете это завернуть в один метод.
Кстати блок "Если" не будет из одинаковых строк. Параметры всегда будут разные. Даже может возникнуть ситуация, когда проверка идет на одно имя, а записывается другое. Все зависит от контекста и задачи.
А других вводных в статье вы не дали (касательно потребности отдельно изменять без проверки, или что проверка на один реквизит, а запись на другой). В таком случае может следует просто дать "старому" методу более понятное имя?
примеры:
- 1 ПолучитьДанныеХХХ или ПолучитьТаблицуХХХ - плохой пример. оба начальных слова несут шум и затрудняют понимание.
использование Получить вообще плохой паттерн.
- 2 метод ОчиститьПоставщиковНоменклатуры делает совершенно другое (
и т.п. и т.д.
(73)
Опять, таки возвращаемся к старым проблемам. Посмотрите стандарты разработки 1с. Там описано, как надо правильно называть процедуры и функции.
Пожалуйста. Вот ссылка на первоисточник:
П.с. вообще писать про "получить" правильно с моей точки зрения, если речь например про функцию получающую некий результат.
Это рекомендации. Там не будет такого. А уж соблюдаете вы стандарты или нет, тут дело вашей фирмы и команды.
Тема полезная, важная, хочется поставить плюс за статью, но сама реализация хромает
имена методов крайне неудачны
- ИзменитьШтучныеТовары, ИзменитьСтрокуЗаказа, ИзменитьСуммуЗаказа непонятны
и РассчитатьСуммуТоваров также непонятно
Метод с наименованием СуммаТоваров – плохой метод. Непонятно, что происходит с суммой в ходе выполнения метода. Такое наименование больше подходит для переменной. Наименования метода следует начинать с глагола, например РассчитатьСуммуТоваров.
С этим абзацем также несогласен.
СуммаТоваров() может быть очень хорошим вариантом
вот текст из официального стандарта 1С
Неправильно:
Функция ПолучитьПолноеИмяПользователя()
Функция СоздатьПараметрыЗаполненияЦенПоставщика()
Функция ОпределитьДатуНачалаСеанса()
Правильно:
Функция ПолноеИмяПользователя()
Функция НовыеПараметрыЗаполненияЦенПоставщика()
Функция ДатаНачалаСеанса()
а Рассчитать, Изменить, Получить, Выдать, Вычислить, Выполнить - это шумовые глаголы, которые в большинстве случаев бесполезны
Тут я скорее согласен. Автор явно игнорирует стандарты разработки 1с, о чем в заголовке статьи и пишет. Я считаю что именно со стандартов разработки надо начинать. Да скучно и не интересно, но на то они и стандарты. Причем разработанны фирмой вендором.
Но большинство фичей можно применять в ЯП другого уровня. В 1С максимум - общие модули, имена методов, упаковка в структуры. Большего вендор вам не даст сделать.
это я к чему - большинство 1С программистов просто дорабатывают типовые, неструктурированный кусок лапшекода, ставший таковым именно из-за отсутствия модульности, и им не до чистого кода.
на горьком личном опыте. а работал и с типовыми и сам писал решения с нуля там, куда не каждый 1Сник попал бы, на высоконагруженных проектах с прямой записью в БД.
в типовых модульности нет - документ А общего базового класса Документы я могу создать, а создать промежуточный документ-болванку и от нее наследоваться я не могу.
из-за чего дублируется код, который мог бы лежать в "базовом документе" какой-либо типовой.
10 лет мучений не прошли мимо меня.
вы скорее исключение из правила.
какое там, в УТ 11 такое ощущение что юнит-тестов нет, ребята проебались с переменной, потому что она уехала за область видимости IDE ))))
а вы про чистый код.
ага, такая офигенная, что разработка типового отчета в БСП превращается в адъ для неподготовленных.
Для себя вынес правило - делаю функцию только тогда, когда определенный участок кода вызывается повторно. Чтобы не копипастить сам код, делаю осмысленную функцию с параметрами итд, и затем ее вызываю. Все. Никаких ограничений брррр в виде 20 строк на метод - ерунда это все, потом сам же запутаешься
(114)
У меня типичный модуль на 1000-1500 строк. С методикой автора мне нужно под 100-150 процедур написать. Вряд ли это будет способствовать облегчению чтения кода. По мне так проще изучить работу процедуры на 100 строк, чем разобраться с 10 функциями, которые еще и ветвятся в свою очередь.
Ну и покритикую манеру автора избыточно разделять блоки текста пустыми строками. Возникает ощущение, что он зарплату он получает за количество написанных строк - крайне трудно читается его код.
Про трусы наденьте - это не обращение к вам, я просто процитировал известную поговорку. И относилась она к автору, потому что именно он объявил злом макаронный код, но сам же и агитирует писать в том же духе.
Вообще же я ярый сторонник реиспользования кода, когда одно действие всегда делается в одном месте. Это даёт возможность существенно поднять функциональность программы и удобство ее сопровождения. Так как я единственный разработчик своей конфигурации, то мне повышенная связность моего кода не сильно мешает, т.к. я отлично знаю все свои модули. Понятно, что сильная связность мешает быстро вникнуть в конфигурацию и легко менять код - без долгого изучения конфы тут ничего не сделаешь.
(119)
Думаю, что вы ошибаетесь. Весь вопрос в функциональности. Если модуль отвечает за работу с конкретной ККМ, то зачем мне создавать несколько модулей? Чтобы больше макарон прибавилось? Ну или проведение документа. Сколько мне делать модулей для этого? Не уверен, что 5 модулей по 500 строк будут легче в обслуживании, чем один на 2000.
Ну или интерфейс. Если он сложный и с большим функционалом, то деваться особо и некуда - будет модуль и на 9500 строк.
хотелось бы "автоматизации" проверки на стандарты...
и о чудо, она есть... (но не совсем из коробки)
Лучше, когда код можно проверить сразу ... прямо не выходя из конфигуратора!
1) (спасибо автору Отымко)
ставится в Windows просто 1 файлом - легко и понятно - запустить - далее-далее - готово!
пользоваться - прямо из кода модуля - Ctrl +Shift + i см. фото ниже - список ...
кликабельный - сразу перепрыгивает на строку ошибки.
сам уже года 2 наверное использую... необходимость ставить "лишние" пробелы между операторами = > < + - * /
меня лично бесят, но это не ошибка, я это игнорирую.
2) Для всей конфы - (после выгрузки в файлы) - удобнее использовать Visual Studio Code (бесплатный!), ну или кто любит - SonarQube (платный), который ещё настраивать на отдельном сервере надо...
это для "продвинутых" только... для "начинающих" я читаю он не подъёмный, уж извините.
Visual Studio Code пользоваться можно для проверки в целом уже написанного (см. скрин VSC)
(и да, там есть тёмная тема для 1С, что очень не плохо для проверки кода по ночам)
- открыть папку с файлами выгрузки из конфы ...
(установить 1 раз! "расширение для VSC": 1C (BSL) Extention Pack ) и вуа-ля... чудо проверки уже в кармане.
Насчет примеров я бы поспорил немного, ну да ладно,
разделять 1 маленькую функцию на "абстракции" по 1 строке... это только запутывает,
я бы тут добавил ещё пару "метрик" - число процедур и функций в модуле... мин - макс и среднее число строк в них
наверное это "легко" добавить, но почему-то никто это не сделал (или я не вижу где это посмотреть)
и "целесообразность" увеличения числа процедур и функций.
Оба этих инструмента работают на "одном движке" - , который постоянно обновляют и дорабатывают различные проверки по стандартам 1С.
Потому что чек-лист конечно хорошо, но ... тут могут появиться разные понимания... что лучше что хуже
и упрётся всё в то, что это "вкусовщина" или "делай как я сказал" , "я начальник - ты дурак"...
Каждый! даже начинающий разработчик должен легко уметь проверить свой код на "чистоту".
и "аргументация" в цифрах всегда выглядит убедительнее... Есть ошибки - исправляй, Предупреждения... тоже не хорошо, про Предупреждения... уже спорно, но не красиво
VSC ещё показывает и "когнитивную сложность" методов и функций - это как раз и есть "запутанность" кода
она так же меряется в цифрах... норма 5-10 , но для 1С бывает процедуры и до 50 -100 легко, тут так же не нужно очень сильно дробить 1 мега-функцию на кучу по 1-5 строк, но задуматься стоит.
P.S.
а) Оформление кода "лесенкой" делается в 2 нажатия ...
1) выделить часть кода или весь текст Ctrl + A
2) Alt +Shift + F (или через главное меню Текст - Блок - Форматировать)
б) Двойные пустые строки - считаются "дефектом кода" и в VSC и в Фениксе - они отображаются как Информация или Предупреждение - из VSC - можно сразу (по гипер-ссылке) открыть подробное описание ""
Лишние строки... я считаю излишком, да, только блоки разделять надо, а не после каждой строки - пустую
это только растягивает текст не на 1 а на 2-3 экрана и читать невозможно становится.
в "других" ЯП-ах (языках программирования) - есть понятние Геттеров и Сеттеров ...
т.е. переводя на русский - функция может только Получить_ЧтоТоТам()
Функция ПолучитьСуммуТоваров()
Сумма = 0;
// цикл
Возврат Сумма
КонецФункцииа установливать что-то надо ТОЛЬКО через Процедуру, например
Процедура УстановитьСуммуВДокумент( Док, СуммаДокумента = 0 )
ДокОб = Док.ПолучитьОбъект();
ДокОб.СуммаДокумента = СуммаДокумента;
ДокОб.Записать();
КонецПроцедуры+ сокрашения "типовые" для док, спр, рн, РегСв... Об - вполне "читабельны"
т.е.... "Венгерская запись" (в запросах например, спрНоменклатура или докЗаказКлиента )...
вполне читабельна и экономит место и "чтение паравоза" в запросе например
КАК РегистрНакопленияОстаткиТоваровОстаткиИОбороты >> КАК рнОстаткиТоваров - проще, а ОстаткиИобороты или просто Остатки - и так понятно ... по смыслу самого запроса
Что касается типовых сокращений - даже лучше писать типовые общепринятые сокращения. Тут главное знать грань - не начать выдумывать сокращения, думая, что они типовые)
1) про названия функций - наврал немного...
- Получить / Добавить / Проверить ... не надо писать в имени функции.
2) как раз для начинающих (и не только!) - Про проверку кода (на лету) - Феникс ( просто необходим)
VSC - немного сложнее - надо файлы выгружать... и там смотреть... цветовая гамма не та ... опять же
Sonar Qube многие используют... он ещё сложнее ... совсем не для 1С-ников и не для начинающих точно
Снегопат для 8.3 вроде был ещё... но не уверен, что там есть "стандарты", он скорее про другое
------------------------------------------------------------------------------------------------------------------
для любителей всего 1С-го - в конфигураторе "всё есть" [v] для полной проверки, но... "почему-то" этим никто не пользуется... наверное есть причины
+ EDT - там вроде все проверки сразу есть, но... сам EDT это паровоз со 100 вагонами... короче "на любителей"
+ АПК (отдельная конфигурация - Автоматизированная Проверка Конфигураций) - это тоже супер-чудо, своя логика... и миллион проверок, но... опять же это не "на лету" ... и не в том же конфигураторе, где пишешь
------------------------------------------------------------------------------------------------------------------
в общем остаётся только Феникс (Phoenix BSL), который по трём клавишам ( Ctrl + Shift + i ) - сразу "анализы" выдаёт. Ну и конечно "надо знать" и "сверяться" на стандарты 1С... (которые никто не читает и тем более не следует!)
стандарты есть на офиц.сайте ИТС 1С
СонарКуб используем, но крайне редко. У меня на компе развернут сервер тестовый (бесплатный). Но это опять же надо выгружать в файлы, заливать, переписывать файл на новые пути... Вообщем муторно это все.
Про EDT даже говорить не буду... Скажу лишь то, что ни на 1 компе рабочем она не работает нормально у нас, на 100% грузит железо. Только на сервере получилось запустить более-менее, но это бред.
(130)
Вот про это надо написать в статье (или в новой статье даже лучше) !
а то "читай стандарты" - многими это воспринимается, что тебя послали... далеко и надолго.
Нужен быстрый инструмент ... для самоконтроля ... и не только для начинающих.
VSC - почти тоже самое ... я иногда 1 модуль просто в файл копирую и проверяю
там как в Фениксе, но ещё и со ссылками на эти же стандарты (дефекты кода)
А потом конфу с доработками, у которой указать эту типовую как библиотечную конфу.
Тогда ошибки типовой вычитаются и можно увидеть только свои ошибки.
Дайте АПК второй шанс.)
bool check_and_get(int *user_name, int *buffer, int buffer_size) {
int _flag = get_flag(user_name);
switch (_flag) {
case 3:
{
fill_buffer_3(buffer, buffer_size);
}
return true;
case 5:
{
fill_buffer_5(buffer, buffer_size);
}
return true;
default:
break;
}
return false;
} ПоказатьТакой код в 1С можно сделать и с возвратом через структуру - вернуть и строковый буфер и флаг, что буфер был заполнен. Например, так:
Возврат Новый Структура("ДанныеЗаполнены, Данные", ТипЗнч(Данные) = Тип("Строка") И НЕ ПустаяСтрока(Данные), Данные);Но я в старой типовой конфе вижу такой код (некорректное описание и написание, но имеет место быть):
// Функция выполняет пакет запросов.
//
// Возвращаемое значение:
// Булево - Истина, если запрос выполнен успешно.
//
Функция ПакетЗапросовВыполнить(ПакетЗапросов)
Если ЗначениеЗаполнено(ПакетЗапросов.Запрос.Текст) Тогда
ПакетЗапросов.РезультатЗапроса = ПакетЗапросов.Запрос.ВыполнитьПакет();
Возврат Истина;
Иначе
Возврат Ложь;
КонецЕсли;
КонецФункции // ПакетЗапросовВыполнить()
ПоказатьВы можете заказать платную консультацию или разработку у автора. Будет создан приватный заказ на «Бирже заказов» для автора.
№ 1943161
Создание 27.09.23 12:00
Обновление 06.10.23 09:56
Просмотры 14304
Загрузки 0
Рейтинг
39
Комментарии 137
Код открыт Да
Рубрики Рефакторинг и качество кода
Кому Разработчик
Тип файла Нет файла
Платформа 1С:Предприятие 8
Конфигурация 1C:Бухгалтерия
Операционная система Не имеет значения
Страна Россия
Отрасль Не имеет значения
Налоги Не имеет значения
Вид учета Не имеет значения
Доступ к файлу Бесплатно (free)