Основы менеджмента кода в 1С
Разработка - Рефакторинг и качество кода
Наверное, мало кто будет спорить с тем, что программа должна быть понятной не только компьютеру, но и человеку. С увеличением сложности и времени жизни проектов легкость понимания кода становится все более критичной. Действительно, программа, которая пишется множеством людей и может неоднократно изменяться, должна быть легко читаемой, иначе изменения и исправления ошибок могут привести к потере контроля над кодом и краху проекта. Возникает проблема менеджмента кода, т.е. поддержания кода в работоспособном и понятном состоянии. Каковы основные принципы такого менеджмента? Пойдем «от печки». Что такое язык программирования? Это прежде всего язык, т.е. система, когда совокупность символов (слово, предложение) отображает какой-то, пусть и виртуальный, но объект или действие над ним.
Нам повезло, мы программируем под 1С, где объекты и действия обозначаются словами русского языка. Это облегчает выполнения главного требования для понятной программы – самодокументируемости, т.е. названия должны соответствовать тому, что за ними стоит.
Основной принцип здесь таков – глядя на идентификатор процедуры или функции должно быть возможно сообразить, что она делает. Внимание! Главное не только и не столько «как она устроена» а «что делает»! Так же и с объектами – главное отразить их смысл в контексте решаемой программой задачи, а внутренние отношения и устройство уже вторичны. (не «МассивСтрок» а «СтруктураШапкиДокумента») Ведь придумывая имена-идентификаторы, мы «конструируем» язык, на котором нам потом описывать предметную область, описывать алгоритм решения задачи. И, когда идентификаторы подобраны правильно, решение задачи будет написано «почти по-русски» и не будет требовать каких-то дополнительных пояснений. Подробнее о стандартах именования 1С можно прочитать здесь, они вполне логичны.
Другое очень важное требование нормального языка – однозначность. Т.е. одним и тем же словом не должны называться разные сущности, и одинаковые сущности должны называться одинаково. Опускаясь с языковедческих высот на программистскую «землю» получим простейшие принципы:
Другое, очень важное требование языка – обозримость. Предложения в русском языке очень редко бывают длиной в страницу текста. Почему? Возможности человеческого внимания ограничены обычно магическими цифрами 7 и 3. Человек с нормальным вниманием (а мы совсем не сверхлюди, хоть и программисты с сертификатами) легко воспринимает 7 объектов или 3 их сочетания. Откуда такие цифры? Как вы понимаете, в двоичной системе сочетания 3 объектов как раз дадут 8 комбинаций, так что это, в общем-то, одна и та же цифра. «Оперативная память» человека имеет объем примерно равный 8 ячейкам памяти. Хочешь не хочешь, от этого приходится плясать. Программистский же вывод таков:
Третье, менее формализуемое, но не менее важное свойство кода – стильность. Прежде чем изменять или дописывать чужой код, нужно в него вжиться. Понять, как он обычно манипулирует данными и объектами, как принято в нем делать определенные действия. И делать так же, в том же стиле. Понятно, что не стоит копировать ужасно написанный код, но с таким вообще сделать что-то хорошее трудно. Но если программа имеет хотя бы среднее качество, стоит перенять перед изменением даже ее стиль написания, наименований. Это позволит не отвлекаться потом на мешанину стилей тому, кто придет править код дальше (а возможно и самому через полгода).
Когда же чаще всего вносятся все эти косметические правки в код? В самый светлый момент – когда все заработало! Тут, обычно, радостный программист бросает все «как есть» и убегает дальше. Но стоит потратить 5-15 минут на «уборку рабочего места», структурирование и причесывание получившегося результата, чтобы под результатом не стыдно было подписаться.
Нужно еще обязательно отметить, что если код большой или при «причесывании» требуется изменять чужие и не до конца понятные строки, нужно действовать очень аккуратно. Маленькое изменение – тестирование – следующее маленькое изменение. Никогда не надо стирать и переписывать страницы кода, ни к чему хорошему это не приведет!
Но при должном внимании и аккуратности задача поддержания изменяемого кода в рабочем состоянии вполне разрешима и даже не требует каких-то значительных затрат.
Главное не давать себе лениться!
Основные методы рефакторинга.
Теперь можно поговорить более строго. Большинство из того, о чем говорилось выше, относится к недавно появившейся технологии программирования – рефакторингу. Рефакторингом кода называется его изменение с целью повышения логичности или понятности без изменения внешнего поведения программы. В модели программирования 1С возможны далеко не все его известные методы, но и оставшихся вполне хватит для того, чтобы сделать код ясным и четким.
Итак, что у нас в арсенале?
Было
НомерКолонкиБазовый = СоответствиеТиповЦен.Получить(БазовыйТипЦен);
Если НЕ НомерКолонки = Неопределенно
И НЕ ЭлементыФормы.ТаблицаЦен.Колонки.Найти(\"Цена\" + НомерКолонки) = Неопределено Тогда
{*******************************************}
Стало
Функция ЕстьКолонка(НомерКолонки)
Возврат НЕ НомерКолонки = Неопределено
И НЕ ЭлементыФормы.ТаблицаЦен.Колонки.Найти(\"Цена\" + НомерКолонки)=Неопределено;
КонецФункции
{*******************************************}
НомерКолонкиБазовый = СоответствиеТиповЦен.Получить(БазовыйТипЦен);
Если ЕстьКолонка(НомерКолонкиБазовый) Тогда
{*******************************************}
Было
Процедура ОчиститьТаблицуОплат()
ТаблицаОплат.Очистить();
КонецПроцедуры
{*******************************}
ОчиститьТаблицуОплат()
{*******************************}
Стало
{*******************************}
ТаблицаОплат.Очистить();
{*******************************}
Было
Процедура ДвиженияПоРегистрамУпр(РежимПроведения, СтруктураШапкиДокумента, ТаблицаПоТоварам, ТаблицаПоСкидкам,ТаблицаПоТоварамБезУслуг, Отказ, Заголовок)
{***************}
Стало (помечтаем о нормальной процедуре проведения документа….)СтруктураДанныхДокумента = Новый Структура; СтруктураДанныхДокумента.Добавить(“СтруктураШапки”,СтруктураШапкиДокумента); СтруктураДанныхДокумента.Добавить(“ТаблицаПоТоварам”,ТаблицаПоТоварам); СтруктураДанныхДокумента.Добавить(“ТаблицаПоСкидкам”,ТаблицаПоСкидкам); СтруктураДанныхДокумента.Добавить(“ТаблицаПоТоварамБезУслуг”,ТаблицаПоТоварамБезУслуг); СтруктураПараметровПроведения = Новый Структура; СтруктураПараметровПроведения.Добавить(“Режим”,РежимПроведения); СтруктураПараметровПроведения.Добавить(“Отказ”,Отказ); СтруктураПараметровПроведения.Добавить(“ЗаголовокПриОшибке”,Заголовок); Процедура ДвиженияПоРегистрамУпр(СтруктураПараметровПроведения, СтруктураДанныхДокумента);
Вступайте в нашу телеграмм-группу Инфостарт
Вы можете заказать платную адаптацию этой статьи под ваши задачи на «Бирже заказов».
- 0% комиссии — оплата напрямую исполнителю;
- Исполнители любого масштаба — от отдельных специалистов до команд под проект;
- Прямой обмен контактами между заказчиком и исполнителем;
- Безопасная сделка — при необходимости;
- Рейтинги, кейсы и прозрачная система откликов.
См. также
Нейросети Рефакторинг и качество кода Запросы Разработчик 1С 8.3 Абонемент ($m)
Нейросеть написала запрос или процедуру для вашей базы 1С, и непонятно, все ли имена в нём настоящие. Обработка компилирует текст без выполнения, сверяет его с метаданными этой базы и к каждой ошибке пишет настоящее имя, например ВНаличииОстаток вместо выдуманного КоличествоОстаток. Список ошибок с подсказками одной кнопкой копируется обратно в чат с моделью.
10 стартмани
02.11.2026 285 1 nedomolkov.ivan 1
Рефакторинг и качество кода Разработчик 1С:Предприятие 8 Россия Бесплатно (free)
Одна проверка в обработчике кнопки может выглядеть достаточной, пока ту же операцию не вызовут из другого места. На примере управляемой формы разберём, почему так происходит, как разместить проверку в общей серверной функции и чем отличается удобная проверка ввода от обязательного условия выполнения операции.
29.10.2026 323 YA_777378709 0
Рефакторинг и качество кода Разработчик Бесплатно (free)
Рассказываем, почему качественный код – это не техническая прихоть, а актив, который помогает бизнесу быстрее адаптироваться к изменениям и запускать новые фичи без бесконечного преодоления техдолга. Показываем, как объяснить бизнесу ценность рефакторинга через понятные признаки: замедление разработки, неточные оценки, страх перед legacy и хрупкость системы. Разбираем, почему неправильный рефакторинг может быть дороже его отсутствия, какие анти-паттерны ломают процесс и как не превратить улучшения в бесконечную переделку ради переделки. Объясняем, как сделать рефакторинг частью культуры команды: договориться с бизнесом, научить разработчиков видеть проблемные места, закрепить правила и поддерживать улучшения на уровне тимлидов, архитекторов и всей команды.
28.10.2026 428 Pavel791 0
Рефакторинг и качество кода HighLoad оптимизация Системный администратор Разработчик Стажер 1С 8.3 Абонемент ($m)
Если к HTTP-сервису 1С обращаются сразу несколько программ, сколько запросов в секунду он успеет обработать? Я опубликовала простой HTTP-сервис на нашей "подопытной" конфигурации «Нано-УТ» (файловая база, Apache, без прав администратора) и нагрузила его скриптом на Python. Ответ: около 15-16 запросов в секунду, сколько бы клиентов ни обращалось одновременно. Запросы ждут своей очереди, и при 32 клиентах ответ приходит через 2 секунды вместо 64 мс. Заодно разобрала скрипт из первого варианта статьи: он «проверял» сервер, который отвечал по одному, и считал ошибки вместе с успешными ответами. В архиве исправленный скрипт, учебный сервер, HTTP-сервис для 1С и инструкция по запуску.
1 стартмани
23.10.2026 483 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 431 Ninel_S 2
Рефакторинг и качество кода EDT СКД Разработчик 1С 8.3 1С 8.5 1С:Бухгалтерия 3.0 Бесплатно (free)
Одиннадцать граблей схем компоновки, которые не видно в конструкторе и не ловит EDT, на реальных отчетах БП КОРП. Формат числа задается в двух местах, и условное оформление варианта перебивает формат поля. Ресурс складывает штуки с часами, и помогает выражение «только когда единица одна». Ресурс пуст в детальных записях, параметр не появляется в шапке без userSettingID, valueListAllowed ломает границы периода, Остатки и СрезПоследних с параметром периода падают с «Несоответствием типов», title без xsi:type дает «Исключение XDTO» при загрузке. В конце код проверки схемы из файла до обновления базы, сводная таблица и чеклист.
16.10.2026 469 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 3362 Konstmax13 11
Рефакторинг и качество кода Тестирование QA Разработчик 1С 8.3 Абонемент ($m)
Инженерный анализ влияния (Impact Analysis) при изменении общего метода в 1С:Предприятии: почему штатный поиск ссылок скрывает 99% зависимостей и как обратный обход графа вызовов выявляет 370 скрытых потребителей на глубине 3 уровней. В статье — верификация сквозной цепочки обмена с маркетплейсом; в архиве-компаньоне — автономный BFS-анализатор на Python, слепки графа и план регрессионного тестирования.
1 стартмани
12.10.2026 290 Ninel_S 0
1) Каждая статья должна иметь ЦЕЛЬ - для чего все это пишет.
Цитата(опуская "куздру - муздру" ) "Много говорилось о том, что названия процедур, функций и переменных должны быть «говорящими» должны соответствовать логике их использования"
-и это есть цель статьи? Или цель поучить читающих правильному именованию переменных и процедур - для этого есть материалы самой фирмы 1С, или же цель - помочь начинающим струтуризировать свои подходы к созданию программ на 1С?
2) Если цель -2, тогда нужно начинать с методов структурного программирования, которые и лежат в основе рефакторинга.
а именно - ПРОЕКТИРОВАНИЕ ПРОГРАММ СВЕРХУ ВНИЗ. Я помню еще те времена, когда программы сначала оформлялись в виде блок-схем, так вот - Законченная блок-схема должна располагаться на 1-2 страницах. Расшифровка блока - также на 1(2) и т.д.
Метод понятен.
Поскольку от блок-схем ушли, то практически любую программу можно описать так
//==============
Процедура СделатьТоТо1(Парам1)
СделатьСеТо1(новПарам1);
...
СделатьСеТо1(новПарам1);
КонецПроцедуры // СделатьТоТо1(Парам1)
//---- основная программа
СделатьТоТо1(Параметры1) ;
СделатьТоТо2(Параметры2) ;
Если ЧтоТО Тогда
СделатьТоТо3(П3);
Иначе
СделатьТоТо4(П4);
КонецЕсли;
СделатьДействиеN(ПараметрыN);
//---
Далее развивать не имеет смысла, т.к. уже пересказан весь смысл данного выступления
3) Хота про куздру (или как там ЕЁ) - занимательно, хотя бы потому, что с этой фразы давным-давно начинал преподаватель (на курсах по английскому языку на сдачу кандидатского минимума) свой рассказ про алгоритмы перевода научно-технических текстов.
В конце концов, любая программа (неважно - на 1С, на С, на Паскале или на ассемблере) ДОЛЖНА быть грамотно спроектирована, аккуратно написана и хорошо отлажена.
А какими методами проектирования, написания и отладки пользуется аФФтар программы (или коллектив аФФтаров) - не сильно важно... :)
Хотя, лично мне кажется, что в области современного "официального" 1С-программирования господствует принцип "срубания бабла". :(((
Что, собственно, и дает основания для ведения подобных дискуссий, а также работу всем тут присутствующим... :)
А по сути дела, могу в очередной раз посоветовать прочесть вечнозеленую книжку Фредерика Брукса "Мифический человеко-месяц"... :)
А по статье Плюс, конечно :)
Вещь полезная, но ИМХО как раз к языку не нужно сильно привязываться, большинство приемов рефакторинга достаточны универсальны для любого языка программирования.
Так что пересаживаться на 1C было очень интересно и познавательно. Правда в 7ке я бы жить нормально не смог :-) А вот 8ая платформа в своем роде шедевр, но это еще не все поняли :-)
Спасибо тебе огромное за него!!! До сих пор стоит и пользуюсь! Очень удобная штуковина!! В универе, помнится, даже что-то писал для него (вот что именно - не помню, но точно не шкурку).
В предложении "До сих пор стоит и пользуюсь!" я имел ввиду NumLock Calculator )))))))
(сори за офф)
.
Правда, за слова об отсутствии ООП хочется поставить небольшой минус.
ООП нету в штатной 77 и 8, но для 77 все давно нами придумано и используется :) - ВК 1С++, лично я юзаю больше 6 лет.
8 в этом плане очень ущербна :(
Ну и Нуралиев открыто заявлял, что "ооп нет и пока не планируется"
Например, > Блок кода длиннее 7-10 строчек должен оформляться в отдельную процедуру или функцию
Это, наоборот, может привести к трудночитаемости кода и, как следствие, к ошибкам.
Я бы переформлировал бы.
Блок кода, выполняющий более N-ого количества действий, должен оформляться в отдельную процедуру или функцию
По мне - автор статьи прав. Читаемость кода будет лучше, если он будет разбит на блоки по принципу "одна функция должна умещаться на одном экране" ((с) Малюгин Дмитрий)
И не важно сколько раз она вызывается 1 или 101. Я, когда открываю глобальник ЗиКа, тихо ох*еваю. Вообще не представляю как там можно всё сопровождать...
А вот посмотрите на этот кусок
| Код |
|---|
//---------------------------------------------------------------------------
Процедура ПриНачалеРаботыСистемы()
_СпрПользователи=СоздатьОбъект("Справочник.Пользователи");
_СпрНаборыПрав=СоздатьОбъект("Справочник.КД_НаборыПрав");
_СпрИдКон=СоздатьОбъект("Справочник.КД_ИдКон");
_СпрДоступКон=СоздатьОбъект("Справочник.КД_ДоступКон");
_СпрИдСпр=СоздатьОбъект("Справочник.КД_ИдСпр");
_СпрДоступСпр=СоздатьОбъект("Справочник.КД_ДоступСпр");
_СпрДоступСпрРекв=СоздатьОбъект("Справочник.КД_ДоступСпрРекв");
_СпрИдДок=СоздатьОбъект("Справочник.КД_ИдДок");
_СпрДоступДок=СоздатьОбъект("Справочник.КД_ДоступДок");
_СпрДоступДокРекв=СоздатьОбъект("Справочник.КД_ДоступДокРекв");
_СпрИдОтч=СоздатьОбъект("Справочник.КД_ИдОтч");
_СпрДоступОтч=СоздатьОбъект("Справочник.КД_ДоступОтч");
_СпрИдОбр=СоздатьОбъект("Справочник.КД_ИдОбр");
_СпрДоступОбр=СоздатьОбъект("Справочник.КД_ДоступОбр");
_СпрИдЖур=СоздатьОбъект("Справочник.КД_ИдЖур");
_СпрДоступЖур=СоздатьОбъект("Справочник.КД_ДоступЖур");
_СпрРоли=СоздатьОбъект("Справочник.КД_Роли");
ОткрытьФорму("Обработка.КД_ЗаполнениеДоступа","НачалоРаботыСистемы");
// установка текущего пользователя
Если ПустоеЗначение(ИмяПользователя())=0 Тогда
Если _СпрПользователи.НайтиПоКоду(ИмяПользователя())=0 Тогда
_СпрПользователи.Новый();
_СпрПользователи.Код=ИмяПользователя();
_СпрПользователи.Наименование=ИмяПользователя();
_СпрПользователи.Право=НазваниеНабораПрав();
_СпрПользователи.Записать();
_СпрПользователи.НайтиПоКоду(ИмяПользователя());
Иначе
_СпрПользователи.Наименование=ИмяПользователя();
_СпрПользователи.Право=НазваниеНабораПрав();
_СпрПользователи.Записать();
КонецЕсли;
_Пользователь=_СпрПользователи.ТекущийЭлемент();
_ПользовательИмя=СокрЛП(ИмяПользователя());
_Право=_СпрПользователи.Право;
Иначе
Предупреждение("Пользователь системы не определен!"
+РазделительСтрок+"Продолжение работы невозможно.",10);
СтатусВозврата(0);
Возврат;
КонецЕсли;
КонецПроцедуры
Показать полностью |
55 строк. Его нужно было на 6 процедур разбить? :D
Согласись, что ф-ию на 500 строк трудновато читать.
Блок кода длиннее 7-10 строчек должен оформляться в отдельную процедуру или функцию
правда с небольшой оговоркой: не 10 строчек, а экран или логически полное действо.
С автором статьи я не согласен вот по этому поводу:
Свертывание процедуры/функции. Обратное выделению процедуры/функции действие. Применяется, если текст процедуры в ходе изменения упростился настолько, что понятнее будет включить его напрямую в код, где вызывалась процедура.
т.к. завтра надо будет не просто очистить таблицу оплат, а ещё и новую колонку добавить, то придётся по всему коду бегать....
Разницу этих в понятиях понимаешь? (с)
;)
> (39) Автор предлагал разбивать куски по "количеству строк", а ты по "количеству раз, который этот код используется".
в (20) я написал
Блок кода, выполняющий более N-ого количества действий, должен оформляться в отдельную процедуру или функцию
Извиняй!
Как говорил один профессор студентам - "Мы вам знания дали, но это не значит что вы их получили" :-)
"Блок кода, выполняющий более N-ого количества действий, должен оформляться в отдельную процедуру или функцию"
И где в этой фразе есть хоть одно слово "раз"?
Это должно описывать их название
(36) > А зачем их все смотреть то? Ну есть они где то там, что то делают. Если из названия процедуры понятно что она делает, то зачем смотреть ей в код?
А кто-нидудь может себе представить как разобраться в отчете, состоящем из 800 строк, разбитом на 100 процедур, из которых только 5 вызываются несколько раз?
Тем более, если это не тобой написанный отчет и который нужно изменить?
Это делается методом деления на слои. Например есть слой процедур которые собирают данные для отчета, есть те, кто их преобразовывает, есть те, кто выводит. Соответственно, главная процедура имеет три строчки - ПолучитьДанные(), ПреобразоватьДанные(), ВывестиДанные().
Не нужно же смотреть на все 800 строк сразу? Я так вот точно не могу, я обычный человек :-)
При правильном наименовании процедур и правильной передаче контекста и поиск ошибок, и добавление возможностей происходят легко.
p.s.
Язык 1С 7.7 устроен так, что оформление кода через функции часто невозможно. Увы, но это сильно ухудшает читаемость и ничего сделать с этим нельзя.
>>Согласись, что ф-ию на 500 строк трудновато читать
фи! ты, брат, ни чо не понимаешь! :-D Открой Зик, написанную чуть ли не САМИМИ создателями САМОЙ 1С! К примеру, расчетную ведомость... Там только один из вариантов (!) формирования этой ведомости состовляет чуть более 1700 строк! А есть ещё второй вариант! И это всё одна процедура!!!!
Меня на днях попросили сделать третий вариант, просто с другой группировкой (по категориям должностей), я, наивный, потирая руки от предвкушения лёгких денег открыл обработку и... молча сполз под стул. Пришлось писать третий вариант с нуля, и получился он у меня менее 150 строк вместе с тремя небольшими вспомогательными функциями!.. А ты говоришь "Согласись, что ф-ию на 500 строк трудновато читать" :-D
З.Ы. Извините за некоторый офтоп, просто недавняя рана, накипело)))) Просьба статью с приложениями в пару книг по рефакторингу отправить Нургалиеву! :-D
Как бы я сделал?
1) все переменные с подчерком объединил бы в одну структуру, которую бы сделал в цикле по метаданным. Однако строчки три, точнее не скажу - 1с под рукой дома нету. Понятно, эту структуру бы возвращала функция. (список или таблицу - нужно подумать)
2) То, что под Если и под Иначе бы тоже сделал процедурами
Единственное, я 8ку знаю и люблю гораздо больше 7ки, потому не уверен, возможен ли в 7ке цикл по метаданным.
И логично в коде завести список этих справочников, и обозвать его чем-то типа "СписокСправочниковПоСкладам", по этому списку уже создать объекты для доступа к этим справочникам.
Это однозначно было бы больше строк кода, чем при явном Создание Объекта + циклы ненужные
Или для гибкости завести справочник, в котором бы хранились идентификаторы спровочников, которые должны инициализироваться ПриНачалеРаботыСистемы? :-)
И вместо того, что бы смотреть код в Конфигураторе, надо было еще и Предпрятие открыть и там посмотреть КАКИЕ имегно справочники глобально объявляются?
Вообще, и на v.7, в частности? Я имею в виду с достаточной квалификацией, разумеется
в (30) Вы, например, пишите > потому не уверен, возможен ли в 7ке цикл по метаданным.
Но это не мешает Вам обзывать язык, успешно выдержавший на рынке не один год, и еще пяток продержится.
Между прочим, некоторые бухи еще в 6-ке работают :-)
Пока Вы где-то нахватались сомнительных утверждений, типа - процедура должна быть не больше 10 строк и пытаетесь ввести это в догму.
(60) > ЧеБурашка, нормальные среды программирования (и 1с8 в том числе) позволяют бегать от названий процедур к их реализации (F12 -Alt+-) и поэтому навигация здесь становится прозрачной и автоматической.
в (61) Вам объяснили, что 7-ка это умеет. Значит, она нормальная среда программирования? :-)
Зря наезжаешь на автора по поводу количества строка кода :(
1. Все им сказанное насчет этого - это не догма, а некое правило, при соблюдении которого получаешь более простой и читабельный код.
2. Весь смысл рефакторинга как раз в получении кода, который очень легко читать, понимать, изменять/сопровождать.
Выделение неких смысловых кусков кода и оформление их на классы/методы/процедуры/функции с удобными и понятными названиями - одно из главных правил рефакторинга.
Нет смысла заглядывать внутрь процедуры, если из названия и так понятно, что она(процедура) делает.
Очень часто хороший код и не нуждается в комментариях, все понятно из названий идентификаторов :)
3. Например, по твоему коду из ПриНачалеРаботыСистемы из (22) проще написать
| Код |
|---|
Процедура ПриНачалеРаботыСистемы()
ИнициализацияСистемыКонтроляДоступа();
Если УстановкаТекущегоПользователя() = 0 Тогда
СтатусВозврата(0);
Возврат;
КонецЕсли;
КонецПроцедурыПоказать полностью |
В итоге тому, кто читает код этого метода, становится очень легко понять, что этот метод выполняет, без всяких лишних подробностей, только засоряющих экран.
Именно количества. В комменте 20 я предложил другое толкование. Вы его читали?
Я использую разбиения кода на процедуры, но не отсчитывая по 10 строк, а разбивая по смыслу.
П.С. А давайте сделаем небольшой подсчет.
Дано 1000 строк кода
Разбиваем его на 100 процедур.
Получаем 1300 строк (Исходных 1000 + в каждой из 100 Процедур Процедура/КонецПроцедуры + 100 строк вызова процедур).
А для вызова 100 процедур нужно написать еще 10 процедур - получаем 1320 строк (кажись, нигде не просчитался :-) ).
На самом деле, это минимальные расчет. Может, кому-то захочется более смысловые процедурки писать по 5-7 строк
Лично мне кажется, что такой арифметический подход к разбиению на процедуры отрицательно скажется на понимании и быстродействии.
.
2. (20) Конечно, читал. Этот пост и его резюме мне также не нравится :(
Еще раз повторюсь - главное, это смысловое содержание и удобство чтения кода.
.
3. Сравни, плиз, свой код из (22) и мой рефакторинг этого кода из (78).
Какой код легче прочесть и быстрее понять ? :)
.
Также прошу других участников высказаться по поводу этих 2-х вариантов одного кода :)
.
4. Не в обиду, но желательно тебе все-таки прочесть какую-нибудь книгу по рефакторингу. Рекомендую Фаулера "Рефакторинг" - это базовые знания по построению кода.
Почитай, думаю, что многое станет проще и легче понять.
по п.1 > Блок кода длиннее 7-10 строчек должен оформляться в отдельную процедуру или функцию, с названием, которое описывает, что, собственно, этот блок делает.
Где-то там есть слово смысл?
по п.2 А я разве спорил с этим? Наоборот :-)
по п.4 Спасибо, обязательно. Как только будет время...
Может, конечно, и не он первый это сказал. Я этот принцип услышал от Константина (ака 33lab, noprogrammer).
Но... надо же и чувство мерки иметь. Догм быть не должно.
Отсчитал 10 строк - новая процедура, отсчитал 10 строк - новая процедура, отсчитал 10 строк - новая процедура... и т.д.?
(21) to JohnyDeath. У вас во dсех процедарах и функциях не более 10 строк?
Хотелось бы увидеть Ваш глобальный модуль, оформленный по этому принципу :-)
А зачем их все смотреть то? Ну есть они где то там, что то делают. Если из названия процедуры понятно что она делает, то зачем смотреть ей в код?
В (20) я просто предложил свое толкование. Это же коллективное творчество? Или все-таки догма? :-)
Тогда к чему вообще возможность писать комментарии?
> В хорошем коде
А как понять достаточно ли хорош код? Особенно, если он чужой?
Вот буквально сегодня натолкнулся в базе на новой работе
| Код |
|---|
Процедура Меню()
Перем Зн;
Меню = СоздатьОбъект("СписокЗначений");
Меню.ДобавитьЗначение(1,"общий");
Меню.ДобавитьЗначение(2,"общий с задолжностью");
Меню.ДобавитьЗначение(3,"по клиентам");
Если Меню.ВыбратьЗначение(Зн,,,,1) = 0 Тогда
Возврат;
КонецЕсли;
Если Зн = 1 Тогда
ПланОплат(Зн); //!!!!!!!!!!!!!!!
ИначеЕсли Зн = 2 Тогда
ПланОплат(Зн); //!!!!!!!!!!!!!!!
ИначеЕсли Зн = 3 Тогда
ПланОплат(Зн); //!!!!!!!!!!!!!!!
КонецЕсли;
КонецПроцедуры
Показать полностью |
> насчет других можно будет уже вести более предметную полемику
А чем моя полемика непредметна? Кое-кто из принципа накинулся на (20). Вопрос почему? Ответьте хоть кто-то
Желательно, предметно :-)
(133) > А тут тебе дают на одной страничке всё.
Что всё? Такого же качества как и "Учебник по 1Сv77 от Казанского государственного университета"?
По поводу некоторых аспектов качества я высказался в (114). Кажется, предметно :-)
Мне кажется, что ты уже просто из принципа раздуваешь спор.
Магические значения 1, 2, 3 наверняка используются и в методе ПланОплат.
.
Я бы исправил/отрефакторил его, наверное, так:
1. Для каждой константы (1, 2, 3) заводим спец.переменные-константы с четким наименованием:
| Код |
|---|
чОбщий = 1;
чОбщийСЗадолженностью = 2;
чПоКлиентам = 3;Показать полностью |
2. Преобразую код - это только первое преобразование :)
[/code]Процедура ВыбратьВариантПланаОплат_ЗдесьМожноВставитьНовоеНазваниеСтаройПроцедуры_ПланОплат() // поменяем название
Перем лВариант;
Меню = СоздатьОбъект("СписокЗначений");
Меню.ДобавитьЗначение(чОбщий, "общий");
Меню.ДобавитьЗначение(чОбщийСЗадолженностью, "общий с задолженностью");
Меню.ДобавитьЗначение(чПоКлиентам, "по клиентам");
Если Меню.ВыбратьЗначение(лВариант,,,,1) = 0 Тогда
Возврат;
КонецЕсли;
ЭтоНазваниеЛучшеПоменятьДляБолееТочногоСмысл_Старый_ПланОпла
КонецПроцедуры[/code]
.
3. Блок кода по созданию меню и выбора из него лучше также вынести в отдельный метод-функцию ВыбратьПланОплат.
.
В итоге будет видно, что исходная процедура выродилась в две строки с вызовом 2-х разных методов. И если данный блок кода вызывается всего лишь один раз, его нужно перенести в место вызова, а процедуру удалить.
.
Вариантов множество :)
| Код |
|---|
Процедура ВыбратьВариантПланаОплат_ЗдесьМожноВставитьНовоеНазваниеСтаройПроцедуры_ПланОплат() // поменяем название
Перем лВариант;
Меню = СоздатьОбъект("СписокЗначений");
Меню.ДобавитьЗначение(чОбщий, "общий");
Меню.ДобавитьЗначение(чОбщийСЗадолженностью, "общий с задолженностью");
Меню.ДобавитьЗначение(чПоКлиентам, "по клиентам");
Если Меню.ВыбратьЗначение(лВариант,,,,1) = 0 Тогда
Возврат;
КонецЕсли;
ЭтоНазваниеЛучшеПоменятьДляБолееТочногоСмысл_Старый_ПланОплат(лВариант); // например, ВывестиПланОплатВПечатнуюФорму(лВариант)
КонецПроцедурыПоказать полностью |
.
ЗЫ блин, как неудобно постить :(
>> > насчет других можно будет уже вести более предметную полемику
>>А чем моя полемика непредметна?
Зачем фразы вырываешь из контекста? :(
Я специально написал обе фразы в одном предложении "После прочтения книг некоторые вопросы для тебе станут яснее, насчет других можно будет уже вести более предметную полемику."
Глобальные переменные -зло, и их можно объявлять только при существенных проблемах с производительностью.
Недаром в последних редакциях 1с торговли (10.3.4 и выше) их изжили практически полностью.
Однако, Вам уже пора читать первоисточники по рефакторингу, т.к. уже начали выходить за рамки статьи :-)))
Потому как предлагаемое в 1С, например, свертывание длинных именований через точку в одну переменную прямо противоречит классическим принципам рефакторинга, (где все наоборот) и потому этот метод, чтобы не пугать сильно народ, в текст не вошел :-)
ну и что?
вполне допустима процедура на 500 строк, лишь бы смысловой блок был ясно определен... и вот он как раз бы - умещался на экране... и даже если он не умещается на экране - прозрачность связей и наименований позволяет легко ориентироваться....
..сильнее всего напрягают многоэтажные если....
я например предпочитаю вместо
Цикл
Если Условие Тогда
тралалаля длинное
Иначе
тпрутропурнгавов
КонецЕсли;
КонецЦикла
..
юзать
Цикл
Если Условие Тогда
тралалаля длинное
ПРОДОЛЖИТЬ; //сразу ясно что смысловой блок - закончен, а не продолжается где-то в хвосте цикла
КонецЕсли;
//а тут пишу коомент типа
//сюда попадаем если не нашли подходящей дельты
тпрутропурнгавов
КонецЦикла
Если ФункцияВыбора() тогда
Процедура1()
Иначе
Процедура2()
КонецЕсли
Хочеться подробнее - жмешь F12/
Наверное, следует все-таки в статье подчеркнуть особо, что то, что в ней говорится, применимо в основном к 1с8. С семеркой все в этом смысле плохо, у ней нет навигатора по методам, и, как совершенно уникальное явление, при работе со списками (в том числе с базами данных) не функции возвращают контекст
Результат = объект.функцияПоиска()
а контекст устанавливается процедурой поиска, что убивает нафиг на корню половину методов рефакторинга.
Был когда-то у нас неплохой истребитель И-16. Был он в свое время весьма передовым, но отличался особой техникой пилотирования.
Отличной от всех других истребителей, что в начале войны сыграло нехорошую штуку - И-16 в начале войны уже безнадежно устарел, а переучиваться на новые Як-3 и даже ЛаГГи и МиГи народу было долго и тяжело. Так вот произлошло с 1с7.7 - это неплохая среда, но она настолько вне мэйнстрима программирования, что начавшие программировать в 1с7 программисты потом очень тяжело переходят на другие языки и оказываются постепенно в изоляции.
Меня убил когда-то такой, очень даже неглупый программер с большим опытом работы, который никогда не писал функций и не понимал, зачем они нужны.
Все мои знакомые программисты на 7.7 не пытаются сейчас подняться от 7.7 к чему-то выше просто потому, что в свое время они снизошли до 1С до 1С с приличных языков. И в этом отношении для них 8-ка легче - привычнее программить
ржунимагу!!!
те восьмерочники, котрые есть сейчас они с неба упали уже готовыми программерами 1С v8 и на v.7 никогда не программировали? :-)
> 64. Altair777 18.10.2008
>
> (60) > Так вот произлошло с 1с7.7 - это неплохая среда, но она настолько вне мэйнстрима программирования, что начавшие программировать в 1с7 программисты потом очень тяжело переходят на другие языки и оказываются постепенно в изоляции.
>
> ржунимагу!!!
> те восьмерочники, котрые есть сейчас они с неба упали уже готовыми программерами 1С v8 и на v.7 никогда не программировали? :-)
> [-]: Lomok
Объянитесь, плиз, по поводу минуса
Я тоже не понял зачем ты мне минус поставил. Если хочешь хоть заминусуйся, мне пофигу на рейтинг. Минус тебе не за это, а за нежелание слушать и упирание рогами, тебе куча народу в этом треде одно и тоже объясняют, а ты все брыкаешься. Просто я дошел до этого поста и уже не выдержал.
>те восьмерочники, котрые есть сейчас они с неба упали уже готовыми программерами 1С v8 и на v.7 никогда не программировали? :-)
Да, а что? Представь себе, людям имевшим дело с "большими" средами для разработки, гораздо проще разобраться в восмере чем в семерке.
>тебе куча народу в этом треде одно и тоже объясняют
разве? посмотри уточнение JohnyDeath в (35), Сhe Burashka в (58)
>>те восьмерочники, котрые есть сейчас они с неба упали уже готовыми программерами 1С v8 и на v.7 никогда не программировали? :-)
>Да, а что?
И ни один из них никогда не работал в 7-ке?
И кстати, по поводу рог... так как тебе самому "этика в обычной жизни, хороший стиль, воспитание" (см.29) не присуща...
пнх
Знаешь чел, во-первых это форум, я могу ответить через 10 тысяч лет, если тему не сдадут в архив. Во-вторых мне на самом деле по барабану, я тебе ничем не обязан.
А если ты в (29) увидел оскорбление то извини...откуда ж мне знать что народ нынче такой нежный.
Насчет коммента Abbadonы - я плюсую то что мне нравится, это не твое дело.
Сраться с тобой по поводу того, кто что и как сказал, не собираюсь.
>И ни один из них никогда не работал в 7-ке?
А что, это обязательно?
>И кстати, по поводу рог... так как тебе самому "этика в обычной жизни, хороший стиль, воспитание" (см.29) не присуща...
Может и нет, а может и да. Не мне судить. Я такой какой есть, уж извините.
>пнх
А вот это говорит о твоем воспитании. Точнее о длинне аргумента.
Просто пытаюсь говорить на одном языке. Опыт внедрения мне подсказывает, что с бухами нужно говорить на языке проводок, сальдо, etc., с производственниками - планов, объемов, сменных заданий и т.д. и т.п.
И, кстати, и в мыслях не было меряться у кого аргмент длиннннннннннннее... Для тебя это идея фикс?
Это цепочка обсуждения началась в (60) очередным категорическим утверждением насчет негибкости мышления семерочников при переходе на другие языки. Своего рода клеймением, как мне показалось :-)
Как и самих программистов, так и 1С версии 7, выпавшей из некого "мэйнстрима программирования".
Пожалуйста, укажите ссылки на первоисточники с его стандартами и на доказательства несоответствия 7-ки им.
Мое глубокое убеждение: можно не знать ни одного языка программирования, даже компьютер в глаза не видать никогда, но быть Программистом (есть алгоритмическое мышление и его некоторая нестандратность). А можно знать кучу языков, но при этом остаться простым шифровальщиком (ну не дал Бог!)
Для конфигуратор 7.7 есть OpenConf и telepat ( ), которые делают работу в конф-ре НАМНОГО удобнее нежели в 8-ке. (даже таже работа со св-вами и методами объектов через ".") Навигация по методам ещё лучше чем! Например, там можно встать на наименование ф-ии в коде (точнее на её вызов), нажать ctrl+entr и тебя автоматом перекидывает на эту ф-ию! Вообще очень много прелестей нам подарил Саша Орефков (про телепат можно почитать тут: ).
Также для 7.7 есть проект 1с++ ( ), который предоставляет нам ООП (и не только) для 1С!
В общем не всё так плохо в 7-ке ;)
имхо очередное заблуждение...
цель 7.7 - быть не в мейнстриме программирования, а решать задачи юзеров, быстро и эффективно. В целом 7-ка с этим справляется.
То, что сделано в 8-ке - по сравнению с 7-ой не настолько революционно, чтобы оправдывать НАСТОЛЬКО выросшие аппетиты к железу...
..у меня лично сложилось впечатление, что команда, писавшая клюшки, - куда-то "исчезла" и провести дальшейшее развите эволюционное клюшек - никто не смог... поэтому начали ваять "с нуля" 8-ку... имхо это еще подтверждается тем, что у 8-ки был весьма длительный срок старта... и только только сейчас снеговик выходит на такие позиции, когда в нем появляется что-то действительно новое, что с трудом можно было сделать в 7-ке...
.. резюмируя: в деревне из 30 дворов вполне достаточно ездить на уазике, Камаз там - не нужен...
Такая безапелляционность в своих суджениях, мяшко говоря, пугает.
Тем более от человека, который не может прочитать не извратив фразу специально выделенную жирным шрифтом
см. п. 20,21,25, 27,28,30 (в котом Вы, кстати, утверждаете что 7-ку знаете не очень, а в 61 хаете), 35,40,43-47,49,50
"опаньки" и заморские "сорри" тут не прокатят! Извиняйся. ;))))))))))))
Довольно полезная информация.
Недавно судьба принудила меня разбираться в коде регламентного отчёта. 1С назвала переменную как-то так "НДСвходящий", а хранился в ней НДС реализации. Благо в этом модуле в принципе не может быть входящего НДС. Разобрался. Но осадочек остался.
Просто коды реализации (на самом языке 1С) пишут у них полуграмотные студенты.
Пример: справочник "ДоговорА" просуществовал несколько лет, пока кто-то нормальный не переделал
в "Договоры". А уж парсинг строки с запятыми у них ваще отпад
10 строк кода может написать каждый
100 строк кода может написать упорный
1000 строк кода может написать талант
10 000 строк кода может написать гений
П.С. некоторым читать как "... строк неповторяющегося кода может написать гений
закон программирования - в 10 строках кода есть хотя бы одна ошибка...
вывод: оформляя каждые 10 строк в отдельную процедуру можно повысить не только читаемость программы но и сократить время поиска ошибки... хотя, конечно, не всё так однозначно но тем не менее
воо-ООО-оот тАкОе есть мнение...
Удачи во всем!
Вооот такое ... Вам пожелание....
(75) 1С-конфигурации ОЧЕНЬ улучшились за последний год. Они научились!
Но вот рефакторинг стандарных конфигураций без объектного программирования (а конкретно - без полиморфизма, который позволяет переопределять код) очень трудоемок для нас с вами. Стоить рефакторить хорошенько версию, как обновление на нее хоть чуть переписанной франчами конфигурации становится невозможным :-( Такое было, например, в УТ 10.3.4.
(67) Я умею программировать. Не на 1с, вообще. Программирование - это описание предметной области на строго формализованном языке. 7ку я не обзываю, она очень и очень сильная среда, именно благодаря своей изученности, отработанности и расширяемости. Но она в ближайшее время умрет, т.к. 8ка сейчас достигла практически такой же степени отработанности и изученности (эх, расширяемость бы :-) но она масштабируется на два порядка лучше, а это для систем управления один из самых главных показателей.
А вообще моя позиция проста - 1с-никам хорошо бы оставить кесарю-кесарево, сделать порт языка 1С для .net и сосредоточиться на написании конфигураций, и методологии, где они действительно уже очень сильны. Сэкономили бы и время, и силы :-)
Причем это даже не очень сложно сделать :-)
угумс.. кто же тебе будет методики продавать, которые бабло прносят? продавать будут РЕЗУЛЬТАТЫ использования методики...
| Код |
|---|
Процедура Права()
Перем Зн;
Если ПустоеЗначение(ТекущийЭлемент())=1 Тогда
Предупреждение("Не выбран Пользователь");
Возврат;
КонецЕсли;
Если спДействийПрава.ВыбратьЗначение(Зн,,,,1) = 0 Тогда
Возврат;
КонецЕсли;
Если Зн="ДляПользователя" Тогда
Если _СпрПользователи.Выбрать("Выберите Пользователя","КД")=1 Тогда
_КД_КопироватьПрава(ТекущийЭлемент(),_СпрПользователи.ТекущийЭлемент());
КонецЕсли;
ИначеЕсли Зн="ДляРоли" Тогда
Если _СпрРоли.Выбрать("Выберите Роль","ФормаСписка")=1 Тогда
_КД_КопироватьПрава(ТекущийЭлемент(),_СпрРоли.ТекущийЭлемент());
КонецЕсли;
ИначеЕсли Зн="ИзПользователя" Тогда
Если _СпрПользователи.Выбрать("Выберите Пользователя","КД")=1 Тогда
_КД_КопироватьПрава(_СпрПользователи.ТекущийЭлемент(),ТекущийЭлемент());
КонецЕсли;
ИначеЕсли Зн="ИзРоли" Тогда
Если _СпрРоли.Выбрать("Выберите Роль","ФормаСписка")=1 Тогда
_КД_КопироватьПрава(_СпрРоли.ТекущийЭлемент(),ТекущийЭлемент());
КонецЕсли;
КонецЕсли;
КонецПроцедуры // Права
Показать полностью |
На сколько процедур нужно разбить? На 2 или 3? Подскажите как :-)
| Код |
|---|
Процедура Права()
Перем Зн;
Если ПустоеЗначение(ТекущийЭлемент())=1 Тогда
Предупреждение("Не выбран Пользователь");
Возврат;
КонецЕсли;
Если спДействийПрава.ВыбратьЗначение(Зн,,,,1) = 0 Тогда
Возврат;
КонецЕсли;
КопироватьПрава(Зн);
КонецПроцедуры // Права
Процедура КопироватьПрава(Зн)
Если Зн="ДляПользователя" Тогда
Если _СпрПользователи.Выбрать("Выберите Пользователя","КД")=1 Тогда
_КД_КопироватьПрава(ТекущийЭлемент(),_СпрПользователи.ТекущийЭлемент());
КонецЕсли;
ИначеЕсли Зн="ДляРоли" Тогда
Если _СпрРоли.Выбрать("Выберите Роль","ФормаСписка")=1 Тогда
_КД_КопироватьПрава(ТекущийЭлемент(),_СпрРоли.ТекущийЭлемент());
КонецЕсли;
ИначеЕсли Зн="ИзПользователя" Тогда
Если _СпрПользователи.Выбрать("Выберите Пользователя","КД")=1 Тогда
_КД_КопироватьПрава(_СпрПользователи.ТекущийЭлемент(),ТекущийЭлемент());
КонецЕсли;
ИначеЕсли Зн="ИзРоли" Тогда
Если _СпрРоли.Выбрать("Выберите Роль","ФормаСписка")=1 Тогда
_КД_КопироватьПрава(_СпрРоли.ТекущийЭлемент(),ТекущийЭлемент());
КонецЕсли;
КонецЕсли;
КонецПроцедуры
Показать полностью |
Тогда процедуру Права() из (101) нужно переделать
| Код |
|---|
Функция _ПроверкаНаПустоеЗначение(ЧтоПроверяем) Экспорт
Если ПустоеЗначение(ЧтоПроверяем)=1 Тогда
Возврат 1;
Иначе
Возврат 0;
КонецЕсли;
КонецФункции //_ПроверкаНаПустоеЗначение
Функция _ПроверкаВыбораЗначения(ОткудаВыбираем, ЧтоВыбрали) Экспорт
//Лень писать, т.к. конфигуратора нет под рукой, пишу на коленке :-)
КонецФункции //_ПроверкаВыбораЗначения
Функция ПроверкаВыбораЭлементовДляКопирования(спДействийПрава, Зн)
Перем флагВозврата;
флагВозврата=1;
Если _ПроверкаНаПустоеЗначение(ТекущийЭлемент())=1 Тогда
Предупреждение("Не выбран Пользователь");
флагВозврата=0;
КонецЕсли;
Если _ПроверкаВыбораЗначения(спДействийПрава,Зн) = 0 Тогда
флагВозврата=0;
КонецЕсли;
Возврат флагВозврата;
КонецФункции // ПроверкаВыбораЭлементовДляКопирования
Процедура Права()
Перем Зн;
Если ПроверкаВыбораЭлементовДляКопирования(Зн)=1
КопироватьПрава(Зн);
КонецЕсли;
КонецПроцедуры // Права
Показать полностью |
.
1. Например, код ПроверкаВыбораЭлементовДляКопирования ты сделал очень запутанным
Есть простой рефакторинг избавления от результирующих переменных типа флагВозврата
[code]Функция ПроверкаВыбораЭлементовДляКопирования(спДействийПрава, Зн)
Если _ПроверкаНаПустоеЗначение(ТекущийЭлемент())=1 Тогда
Предупреждение("Не выбран Пользователь");
Возврат 0;
КонецЕсли;
Если _ПроверкаВыбораЗначения(спДействийПрава,Зн) = 0 Тогда
Возврат 0;
КонецЕсли;
Возврат 1;
КонецФункции[code]
.
2. Метод _ПроверкаНаПустоеЗначение здесь явно не нужен, т.к. он 100% аналогичен встроенному ПустоеЗначение. Этот метод был бы нужен, если бы был какой-то явный функционал или название встроенного метода не отображало его смысл :)
.
3. Метод _ПроверкаВыбораЗначения назван очень плохо, на самом деле он же не только проверяет, но сначала выбирает значение, а уж затем проверяет.
Если уж хочешь выделить его явно, называй правильно - ВыборЗначенияИзСписка или ВыборЗначенияИзСписка и определяй как функцию, возвращающую результат успеха/неуспеха.
Опять же, если он вырождается, как в п.2, во встроенный аналог, он фактически не нужен.
.
4. Вот единственное, что ты сделал верно :) - это выделение отдельной функции ПроверкаВыбораЭлементовДляКопирования, хотя ее название также не очень :) ИМХО лучше и проще функция ВыборЭлементовДляКопирования.
.
Вот и получается, что даже на этом простом примере можно увидеть несколько полезных приемом рефакторинга -
избавление от временной результирующей переменной;
избавление от ненужных, вырожденных функций;
задание правильных смысловых наименований для методов;
выделение функции;
| Код |
|---|
Функция ВыборЭлементовДляКопирования(спДействийПрава, Зн)
Если _ПроверкаНаПустоеЗначение(ТекущийЭлемент())=1 Тогда
Предупреждение("Не выбран Пользователь");
Возврат 0;
КонецЕсли;
Если _ПроверкаВыбораЗначения(спДействийПрава,Зн) = 0 Тогда
Возврат 0;
КонецЕсли;
Возврат 1;
КонецФункцииПоказать полностью |
Ну вот допустим ты знаешь, что у тебя какой-то косяк происходит при выводе результатов на печать.
Есть моя процедура:
| Код |
|---|
Процедура Тест()
СборДанных();
СверткаДанныхПоПравилам();
ВыводНаПечать(); Показать полностью |
Нахрена ты будешь влазить в "СборДанных" и "СверткаДанныхПоПравилам" ??
А в твоём случае всё было бы в одной процедуре и там надо было бы усиленно работать коёсиком, чтобы добраться до нужного тебе куска кода в процедуре "Тест"
(112) 2-е высказывание: написал код на мильон строк, потом на реальных даных понял что неоптимально...начал менять, оптимизировал одну общую функцию на два документа..в одном стало вызываться оптимизированно, а во втором в принципе тоже побыстрее..только результат стал отличаться от ожидаемого.
>> в любом случае... любая функция это черный ящик,
>>и пока его не откроешь не увидешь что там твориться.
Вот как раз в этом твое заблуждение :)
В хорошем коде смысл/назначение функции понятен из ее наименования, и не нужно заходить внутрь, чтобы разобраться, как же она работает.
.
Да и вообще схема поиска ошибки в хорошем коде будет немного отличаться: ты уже не заходишь внутрь функции, а просто проверяешь/надеешься на ее результат ее работы. Если результат совпадает с требуемым, значит, все в порядке, и ты анализируешь другой код. Если же нет, значит, ошибка найдена.
Естественно, сначала желательно анализировать работу большой функции/большого куска кода, а уж потом спускаться по коду для точной локализации ошибки.
.
(124) Так твои куски кода и должны отвечать за свою работу. И если ты не знаешь, как проверить результаты их работы, значит, код у тебя недостаточно хорош :)
.
Я же говорю, возьми какую-нибудь книгу по рефакторингу + по тестированию, многие вопросы, которые мы обсуждаем, там проанализированы. Сам все поймешь :)
1. На то и нужны анализ логики при рефакторинге + обязательное тестирование своей работы, желательно автоматизированное тестирование и много тестов.
.
2. Если у тебя каждая функция выполняет только явные блоки, и не выполняет неявные, тогда никаких проблем не будет. Т.е. каждый блок кода должен делать только то, за что он отвечает.
Если один блок кода выполняет разные действия, не связанные с друг другом, значит, это предпосылка к выделению доп. кусков кода, например, в виде функции и т.д.
То, что не нужно оптимизировать весь код, это приводит к очень большому росту трудоемкости при разработке (в 4-5 раз). Достаточно оптимизировать 20% кода, скорость выполнения которого действительно влияет на конечное быстродействие.
Т.к. все профайлеры ведут учет времени выполнения с точностью до процедуры, то хорошо рефакторенная программа сразу покажет процедуры, написанные неоптимально, над ними и стоит подумать и изменить код. А так как рефакторенная программа хорошо переносит изменения, то и общее быстродействие, и время разработки будет в общем случае меньше, чем у программы, не подвергавшейся рефакторингу.
А конкретно для 1С:
1) Основное время выполнения занимают неоптимальные запросы. Возможности их рефакторинга появились в последних редакциях 8.1, но их обзор выходит за пределы данной статьи.
2) Для 8.1 1С совместно с инженерами Intel довольно здорово оптимировала код, так что потери на вызов процедур минимальны.
Если конкретно - только что провел испытания. 100 000 вызовов функций на моем core2duo 1.8 занимают 2 сек. (Простейший однострочный код выполнялся в функции с передачей и возвратом значения и без нее, считалась разница, без функции 13 сек с функцией - 15сек).
Т.е даже если каждую строчку делать вызовом своей функции получим проигрыш в 15 %. Считайте сами :-)
Далее - а зачем передавать по значению и растить стек? Да, так несколько надежнее, но можно быть реалистом, передавать по ссылке но этим не пользоваться и не изменять параметры процедур, предпочитая писать функции.
Но это не значит что надо весь код валить в одну большую функцию и обзывать там переменные типа А, Б, и А1... делить просто надо все логичнее.
.
2. По оптимизиции/производительности
Основное правило - не нужно преждевременной, пессимистической оптимизации, т.е. пишем хороший код, не слишком пристально думая об его оптимизации. После получения работающего кода можно проанализировать его производительность и уже на основе данных профайлера выполнять работу по оптимизации.
.
3. Как раз когда код хорошо написан, смысл работы функции/процедуры понятен из ее названия, и поэтому не нужно каждый раз в нее заходить в отладчике, а только в том случае, если есть подозрения, что она и неработоспособна.
Как раз в хорошо структурированном коде намного проще искать глюки.
.
4. Тестирование, автоматическое, функциональное, юнит-тестирование очень помогает при различных рефакторингах кода.
При наличии большого числа тестов, проверяющих логику работы, намного спокойнее работать и добавлять/исправлять код.
Т.е. пишем немного кода - провели тестирование - если все работает, идем дальше.
А вот если не работает, причина ошибка сразу ясна - она в том коде, что добавили.
В итоге ошибки исправляются очень легко и быстро.
Т.е. разработка обязательно должна идти через тестирование, и тестирование нужно запускать как можно чаще.
.
В этой истине я сам убедился при работе над проектами ВК 1С++ и ФормЕкс, а также при собственной разработке в 1С.
Тестирование рулит :)
Очень меня смущают эти фразы
> Человек с нормальным вниманием (а мы совсем не сверхлюди, хоть и программисты с сертификатами) легко воспринимает 7 объектов или 3 их сочетания.
Уточните, какие именно сочетания? 7 в третьей степени? :-)
А лучше дайте ссылки на первоисточники.
> в двоичной системе сочетания 3 объектов как раз дадут 8 комбинаций, так что это, в общем-то, одна и та же цифра
"сэм-восэм... где-та так..." :-)
И это говорит программист? Который обязан учитывать все нюансы?
И, вообще, какой-то нумерологией веет....
> «Оперативная память» человека имеет объем примерно равный 8 ячейкам памяти
А что помещается в одну ячейку? Слово, фраза или целый роман?
"Факты! Больше фактов!" :-)
Вот, кстати, нашел
"Кратковременная память (КП) ограничена по объему, при однократном предъявлении в КП помещается в среднем 7±2. Это магическая формула памяти человека, т. е. в среднем с одного раза человек может запомнить от 5 до 9 слов, цифр, чисел, фигур, картинок, кусков информации."
Вы учли, что кроме кратковремнной памяти есть еще "долговременная, оперативная, промежуточная память"?
А автор перепутал КП и "оперативку" :-)
Лично у меня складываеся впечатление, что Вы вполуха смотрели передачу на Дискавери, а теперь по памяти (какой? :D)излагаете.. в своей интерпретации :-)
А, может, нужно везде полазить? :-)
А через год Вы не забудете что после свертки куда попадет и что именно сворачивается?
И не колесиком придется плавно перемещаться и восстанавливать в памяти логику, а метаться как головки на ИДЕшных винтах при работе с базами данных в многопользовательском приложении :-)
Еще раз повторяю - я не против использование процедур и функций. смотрите мой коммент 20...
20. Altair777 17.10.2008
Ставлю плюсик, хотя не со всеми утверждениями согласен.
Например, > Блок кода длиннее 7-10 строчек должен оформляться в отдельную процедуру или функцию
Это, наоборот, может привести к трудночитаемости кода и, как следствие, к ошибкам.
Я бы переформулировал бы.
Блок кода, выполняющий более N-ого количества действий, должен оформляться в отдельную процедуру или функцию
Вот ты вроде бы со всеми согласен, а всё равно споришь. ;)
Нет, не из первых 2-х процедур. Я расшифровку устанавливаю/не устанавливаю для каждой ячейки непосредственно перед её выводом. Если в значении всё нормально, а в расшифровке косяк - это явно говорит о том, что сначала надо посмотреть место, где она устанавливается.
> Я расшифровку устанавливаю/не устанавливаю для каждой ячейки непосредственно перед её выводом
А что попадет в эту расшифровку? Где и как сформировались данные для рассшифровки?
В самой процедуре вывода на печать? В ее теле или еще в какой-то дополнительной процедуре/функции?
В ее теле или еще в какой-то дополнительной процедуре/функции?
Вполне возможно, что внутри ф-ии стоит вызов ф-ии "УстановитьРасшифровкуЯчейки(ОбластьЯчейки)". ИМХО, не трудно будет найти.
Они плодятся!!!! ааааааааааааа!!!
:-)
(127) Если это мои куски кода, я их как-то помню
Я их писал, и возможно не один десяток раз использовал в разных конфах. А если чужие куски?
Проверять нужно всё! И прыгать :-)
> Я же говорю, возьми какую-нибудь книгу по рефакторингу + по тестированию, многие вопросы, которые мы обсуждаем, там проанализированы. Сам все поймешь :)
Вразумительного ответа я так и не получил... Тогда нафик эти блоги, комменты? Все дружно го читать книги и сами всё понимать
В хорошем коде нет нужды слишком пристально изучать внутреннее строение кода.
.
И вообще мы от построения хорошего кода отклонились в сторону поиска/исправления ошибок в программе, а это интересная, но совершенно другая тема :), которая лишь краем касается данной темы :)
.
Рекомендации насчет книг даю для того, чтобы сам, осознанно, прочитал классиков, поразмыслил над книгой. Все равно мы также хорошо, как они, не сможем преподнести материал :)
После прочтения книг некоторые вопросы для тебе станут яснее, насчет других можно будет уже вести более предметную полемику.
.
Пойми, что я не отсылаю тебя подальше :)
Они плодятся!!!! ааааааааааааа!!!
:-)
Не понял юмора.
Тогда нафик эти блоги, комменты? Все дружно го читать книги и сами всё понимать
ну если б все читали, то конечно нафиг не нужны. А тут тебе дают на одной страничке всё. Не надо целую книгу читать! ;)
> Например, если данные сформированы верно,
А как узнать что они сформированы верно? На печать выводиться не то, внутрь мы не заглядываем....
Автор Кент Бек
"Экстремальное программирование: разработка через тестирование"
В электронном виде найди здесь
.
В ней описаны как назначение, плюсы и минусы тестирование, так и сами приемы тестирования + построение своей системы тестирования.
.
На базе этой книги нами, например, были созданы системы юнит-тестирования 1С на базе ВК 1С++ и ее классов.
Есть у кого-то свои мысли?
"Рефакторинг позволяет разрабатывать архитектуру программы постепенно, откладывая проектные решения до тех пор, пока не станет более ясной их необходимость." (
Обратите внимание - пока не станет более ясной их необходимость
А тут предлагется сразу даже не думая, надо это или не надо, 20 строк на 5 процедур разбивать.
Складывается такое впечатление, что некоторые "спецы" по рефакторингу или вообще не читали или не поняли, что там написано.
Так что опыта рефакторинга у меня хватает :), а не только знаний по нему.
.
2. Вике не нужно сильно доверять :), если уж хочешь разобраться, иди к классикам и первоисточникам.
Естественно, т.к. процесс проектирования/разработки - это творческий процесс, то в нем нет догм.
И рефакторинг - это только инструмент в умелых руках. Эти руки/голова должны самостоятельно решать, что и как нужно рефакторить.
.
ЗЫ Если все-таки в мою сторону :( - и опыт работы над скриптами/плагинами для Опенконф также большой имеется.
.
В любых своих работах, в т.ч. и для 1С, я активно применяю как рефакторинг, так и тестирование.
.
Те, кто меня знает, об этом уже наслышаны :)
.
И к словам автора ИМХО также не нужно слишком уж докапываться :) - в творчестве нет догм.
> И к словам автора ИМХО также не нужно слишком уж докапываться :) - в творчестве нет догм.
Для этого и нужно обсужать :-)
> Вике не нужно сильно доверять :)
Так дополните эту статью, исправьте и завершите.
> Те, кто меня знает, об этом уже наслышаны :)
И тогда не только они, а и мы будем не только наслышаны, а еще и начитаны :-))
Сразу же после абзацев по поводу количества строк, параметров и т.д. автор не зря ставит следующий абзац:
Цитата:
>>Понятно, что перечисленные рекомендации не догма, а лишь повод к размышлению.
>>Можно нагородить и однострочный код так, что его невозможно будет понять.
>>Главный принцип здесь таков – если код нельзя понять с первого взгляда,
>>а особенно если захотелось написать комментарий, поясняющий его работу,
>>значит, этот код требует изменения.
.
Вот это главное, а не количество, к котором ты привязался :)
> Блок кода длиннее 7-10 строчек должен оформляться в отдельную процедуру или функцию, с названием, которое описывает, что, собственно, этот блок делает.
Я привязался к слову "должен". Не "может", а именно должен. Вот это и есть догма :-)
П.С. Автор, исправьте, плиз, блог. Уберите "должен" и свои надуманные 7-10 строк. И тогда я успокоюсь. Наверно :-)
"Также правило: один метод не должен занимать более чем один экран (25-50 строк, в зависимости от условий редактирования), в противном случае некоторые его фрагменты имеют самостоятельную ценность и подлежат выделению."
Как-то противоречит "Блок кода длиннее 7-10 строчек должен оформляться в отдельную процедуру или функцию"
Или у автора блога 4-дюймовый монитор?
Сначала формулируется правило, потом, когда начинаются возражения, следует уход с доводами о том, что это "не догма, а руководство к действию".
Хотелось бы более или менее четких правил, каким образом действовать, если модуль достаточно большой (например, несколько тысяч строк).
Если работа над данной статьей была недолгой, есть большая вероятность, что можно додумать еще много чего полезного.
- выделить независимые или слабозависимые куски кода и оформить в виде отдельных методов;
- выделить повторяющиеся куски кода и оформить в виде отдельных методов;
- избавляться от переменных, которые используются несколько раз с разным назначением;
- выделить данные, которыми оперируем, и постараться выделить методы, которые специфичны для этих данных.
и многое другое.
| Код |
|---|
ИЗ
Документ.ПриходныйКассовыйОрдер КАК ПриходныйКассовыйОрдер
ГДЕ
[b]ПриходныйКассовыйОрдер.ПометкаУдаления = ЛОЖЬ[/b]
И ПриходныйКассовыйОрдер.Дата МЕЖДУ &НачИтоги И &ДатаКон
И ПриходныйКассовыйОрдер.Организация = &Организация
И ПриходныйКассовыйОрдер.ОтражатьВБухгалтерскомУчете = ИСТИНА
И ПриходныйКассовыйОрдер.Проведен
И [b]ПриходныйКассовыйОрдер.ПометкаУдаления = ЛОЖЬ[b]
И (ПриходныйКассовыйОрдер.Оплачено ИЛИ НЕ ПриходныйКассовыйОрдер.ОтражатьВУправленческомУчете)
Показать полностью |
если серьезно, это можно было бы и в функции сделать, если не все условие, то хотя бы часть, часто встречающуюся
- избыточный код (проверка на проведенность и непометку на удаление :-) )
дважды проверку на неудаленность :-))
Именно после этого появления я считаю 8ка сравнилась по отработанности языка с 7.7, потому как раньше были иногда запросы по 1500 строк с повторяющимися кусками кода, которые было невозможно написать оптимальнее.
И никакое ХР и рефакторинг их не спасут, впрочем, как и 1С... Вот уж точно - "Сатана там правит бал!" :)
Хотя, да - закон Мэрфи "Два из трех" еще никто не отменял...
А как Вам вот такой опус :
-----
<gram|work> про индийский код
<gram|work> Какой самый извращенный способ проверить в условии if () булевскую переменную ?
<gram|work> bool b;
<gram|work> b = false;
<gram|work> if (b == true){...}
<gram|work> Это децкий лепет
<gram|work> ИТАК, ПЕРВОЕ МЕСТО
<gram|work> Знакомый говорит, что нашел только что в коде:
<gram|work> if (b.ToString().length < 5){...}
-----
По-моему, как раз в стиле 1С... :)
И уже "на закуску" (чтобы не сильно отвлекаться от темы рефакторинга) - интересная статейка :
"Русский код - бессмысленный и беспощадный"
ага, помним ещё Маяковского - эдакого пионера в этих делах! :)))
Можно в начале модуля делать сводную таблицу используемых процедур и переменных, можно делать таблицу кросс-ссылок, можно проверять на возможное несоответствие
числа параметров вызова Фн/Пр, да мало ли что еще можно наизвращать... :)
Ну, а по поводу статьи - всё правильно, просто и понятно. Сам читал несколько книг по рефакторингу и мне нравится его осуществлять. Автор - молодец!
Только что попробовал - функция с двумя параметрами-строками, по значению, длина строк от 3 до 30000 в цикле. Те же 15 %, как ни странно.
Три раза проверил - все правильно.
Приятно удивлен. (8.1.12.101)
Наверное, тормозить начинает, если туда ТаблицуЗначений по значению передавать, но это уже совсем издевательство над бедным интерпретером.
Вот код обработки, которой я проверял быстродействие.
Функция Тестовая(знач Параметр1, знач Параметр2)
Возврат Параметр1+Параметр2;
КонецФункции
Процедура КнопкаВыполнитьНажатие(Кнопка)
Параметр1 = "111";
Параметр2 = "222";
Сообщить("Без процедуры начало "+ТекущаяДата());
Для Счетчик=1 по 100000 Цикл
Параметр1 = Параметр1+Параметр2;
КонецЦикла;
Сообщить("Без процедуры конец "+ТекущаяДата());
Параметр1 = "111";
Параметр2 = "222";
Сообщить("С процедурой начало "+ТекущаяДата());
Для Счетчик=1 по 100000 Цикл
Параметр1 = Тестовая(Параметр1, Параметр2);
КонецЦикла;
Сообщить("С процедурой конец "+ТекущаяДата());
КонецПроцедуры
Если сделать код без роста строчек (максимально простым, например Результат=Параметр1+Параметр2) то можно добиться 140% роста затрат.
Но это, уже, кажется, максимально замедление, которого можно добиться, оно реальность уже совсем не отражает. И, кстати, даже при этом по значению и по ссылке время не различается.
1) Основное время выполнения занимают неоптимальные запросы. Возможности их рефакторинга появились в последних редакциях 8.1, но их обзор выходит за пределы данной статьи.
а подскажите где про это почитать? а то очень интерсно...
ну или может автор на эту тему статью напишет?
Вы можете заказать платную консультацию или разработку у автора. Будет создан приватный заказ на «Бирже заказов» для автора.
№ 57335
Создание 17.10.08 10:02
Обновление 17.10.08 10:17
Просмотры 38460
Загрузки 0
Рейтинг
126
Комментарии 194
Код открыт Не указано
Рубрики Рефакторинг и качество кода
Кому Разработчик
Тип файла Нет файла
Платформа Не имеет значения
Конфигурация Универсальные
Операционная система Не имеет значения
Страна Россия
Отрасль Не имеет значения
Налоги Не имеет значения
Вид учета Не имеет значения
Доступ к файлу Бесплатно (free)
