Встречаются такие самописные модули, где процедуры создаются лишние. Т.е. например кусок кода используется только один раз во всей программе, но он для чего-то вынесен отдельной процедурой. Или кусочек из двух - трех строчек используется всего два раза, но тоже вызывается отдельной процедурой. И это, часто, мешает читать программу. Вместо того, чтобы просто прочитать код, нужно перескакивать с одного места кода на другое, возвращаться назад,  запоминать, как автор обозвал свою процедуру и что она делает. А если таких лишних процедур еще и много... Просто поражает, неужели сейчас не учат хорошему тону в программировании?
Я думал, что это называется заструктурированность кода, но погуглив, такого определения не нашел. Так как называется такое явление?

Это называется г*внокод.

(0) А может просто прокачать скилл чтения чужого кода?

(0) Какие мы нежные.

(1)гов'нокодом называются процедуры из 10к строк и более

Тут как раз - хороший тон в программировании. Все типовые как раз "заструктурированы" , разве нет? Хотя для 2-х строчек - да, не надо отдельную процедуру делать, но для 10 уже надо))) Весь вопрос только в том , что имена процедур и функций понятные и адекватные должны быть.

обычно борются с обратным когда все в одной функции - спагетти-код

(0) Спагетти-код вроде.

(6) ТС так и делает, с ним и надо бороться

зы, я в адекватности кодера начинаю сомневаться на 100й строке кода

(0) Макконела почитай

(7) Спагетти код это кода код запутан и процедуры влияют друг на друга через глобальные переменные или прочую шнягу.

вы так все тут говорите, как будто бы goto это что то плохое :)

(8) предлагаю сжечь у автора на спине пару томов "Совершенный код"

(6) (7) Спагетти - это совершенно другое

(12) Кто говорит?

(9) в адекватности предыдущего программера надо сомневаться сразу при открытия дерева метаданных

(15) ты пользуешь гото? покайся

(17) Не собираюсь. Я, наоборот, горжусь тем, что могу использовать гото, не запутывая код...

// а теперь позовем общую процедуру проверки

писатели типовых сами с собой общаются в коде...

(0)>>Встречаются такие самописные модули
Начало как у анекдота, встречаются такие две блондинки.

(18) парад будешь устраивать?

Где то было, что если появляется желание что либо прокомментировать в коде, то этот кусок необходимо выделить в отдельный метод.

Лазанья-код

(21) нет. Только массовые расстрелы.

(23) Тогда уж пицца-код :)

Процедуру нужно создавать только тогда, когда этот кусок кода нужно вызывать НЕСКОЛЬКО раз. Если хочешь что-то закомментировать, что мешает сделать это в коде?
Зачем, объясните мне, создавать процедуру, которая используется один раз, если это мешает читать программу?
Только не надо цитат и отсылок к "столпам". Объясните своими словами.

Спагетти-код это как раз, когда перскакиваешь с места на места. И это не только гото. Гото просто частный случай.

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

это называется острый дефицит ООП

(26)
часто не знаешь, сколько раз будет вызываться.

>Зачем, объясните мне, создавать процедуру, которая используется один раз, если это мешает читать программу?

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

(26) Ерунда! Процедуру фрагмент кода надо выносить в отдельный метод, когда у тебя есть желание написать комментарий к этому фрагменту кода. Название процедуры должно отражать суть выполняемого преобразования. У Макконела в книге "Совершенный код" - раздел "Самодокументирующийся код".

попался мне тут один дядька, за 35 наверное, матерый якобы 8шник, не знающий о стеке-вызовов в отладке...

(33) Ну может у него все сразу всегда работало без отладки :)

(34) да нет, он и о табло не знал, отлаживал через бл**ь (!) текстовый файл!!

+(35) точнее о вычислении значения, ну и о табло видимо тоже не в курсе был

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

(35) Гм я тоже так делаю и что точнее через Сообщить("Тута") отлаживаю!

Просто потому что практически без отладки пишу сразу рабочий код...

+(38) Вот нафик нужен отладчик если там проводится больше времени чем за написанием собственно кода?

(38) >Просто потому что практически без отладки пишу сразу рабочий код...

Это умиляет. Все к Макконелу!

(38) суров... сразу и рабочий... боже, что я делаю в этой профессии?

(38) сопровождаешь мало чужого кода значит

(42) угадал, больше своего пишу или дописываю типовые

это называется цугцванг

(38) прям представляю сколько кода  и времени у тебя уходит на "Сообщить", когда в чужом коде нужно узнать что за дерево значений  лежит в переменной, и какие там 100500 типов значений, бгыы

+(43) но скилл чтения чужого кода прокачан счас уже пофиг свой  вспоминать или чужой с нуля

(45) не не не  -этто я в мозгу прямо на лету делаю по коду

(28) "в плане сопровождения" это не аргумент. С практической точки зрения, какой смысл лишних процедур? (30) Ну вот это может быть аргумент, соглашусь.
(31) Да вот мешает тем, что надо перескакивать с места на место, пусть даже для этого есть горячие кнопки. Запоминать, какие переменные ты туда передал, что делалось 10 строчками выше, что должна вернуть функция и т.п.

да да, в мозг 50 тысяч строк сразу закидываешь и анализируешь

(49)->(47)

(48) это не аргумент при автоматизации  ларька, согласен

(49) ну не 50 тысяч а скажем просто 50-100 строк сразу причем не обязательно все они подряд, нет читаю код и важные строки запоминаю потом анализирую что они в сумме делают

(40) а что Мак Конел по этому поводу говорит? Можно хоть небольшой отрывок? Может там как-то не так написано, или недочитано?
Прямо вот так и говрит: Захотелось тебе что-нибудь накоментить, лепи новую процедуру и ничего не бойся, пусть другие после тебя по коду как кенгуру скачут и глаза с мозгами себе ломают?!

Все 1Сные разработки делаются по одним корпоративным стандартам: "х*як, х*як, в продакшен!".
Все кто делают отсылки к "идеальному коду" должны быть сожжены как еретики!

(48) Это называется неправильное (или просто иное нераспространенное) восприятие кода.
Если функция потенциально может использоваться более одного раза (не только в данной конфе) или имеет логическую завершенность, то ее необходимо выделить. И читать такой код намного легче (если функция имеет адекватное имя).

(51) т.е. внятного ответа не будет, а будут намеки на непрофессионализм? так я и думал.

(55) +500!

(56) угадал ))

(26) Объясняю: функция или процедура делает некий законченый объем работы. Ее название и аргументы должны говорить сами за себя - что она делает, и что ей дается на вход.
при такой заменеуже не нужно читать ее код.

(0) от души посмеялся

(56) почему сразу "намеки"? :-)
открытым теккстом тебе об этом говорят...

если процедура много больше 1 экрана, то что-то надо делать

исключения тексты запросов, но я их выделяю в отдельные процедуры тоже

(55) мне кажется - ключевое здесь "может использоваться более одного раза". Так кто бы спорил. Я же про другой вариант говорю сейчас.

(56) Излишняя декомпозиция.
Но это всегда спорный момент разработки ПО.

(63) там не зря стоит "или"...

(55) какое восприятие, тут люди пишут для себя, для души так сказать... попадут в команду из 5-10 разрабов - будут бить по морде, возможно даже ногами

Да однажды встетил при собеседовании при приеме на работу одного программиста который шел на 1С-ку хотя до этого писал на delphi и прочих c++

Так отпал после вопроса (до него еще додуматься надо было) а вы в 1С на русском или на английском пишите? Ответ был неудивительный после delphi )) естественно он на английском писал в 1С

(53) Какой тебе Макконнелл? Начни хотя бы с ВанТассела...

+(67) т.е. если он один то пофиг пусть как хочет пишет а вот в коллективе как когда стандарт и все привыкли русский использовать в операторах?

(67) надо было его спросить, как будет по-английски ИсточникДоступныхНастроекКомпоновкиДанных, и если бы он ошибся хоть на одну англобукву , посцать ему на грудь

(67) А я одну полезную обработку, помнится, написал целиком на аглицком... Как мне благодарны были сопровожденцы после этого...

Garykom позабавил.

Удачного ему erp

(71) А я в тебе и не сомневался.

(73) Ну хоть кто-то...

Вообще, прочитав заголовок, решил, что в теме про обфускацию.
А оказалось как всегда..)

(72) нафик нафик никаких ерп в ближ время счас розницу мучаю типовую чтобы шашечки и ехала

еще бы свои функции в запросах можно было рисовать ))

(76) Интерфейс такси делаешь? :))

(65) Ну а что значит Логическая завершенность функции?
Допустим она создает элемент справочника. Но создавать элемент нужно в обработке только один раз. Ведь проще при чтении программы написать //Создаем элемент справочника ... //Создали элемент. Чем прыгать в другой конец кода, разбираться, что там создается элемент справочника (особенно если из названия не понятно, что делает эта процедура).
Да и без комментариев проще прочитать код сразу, чем скакать куда-то, чтоб его прочитать.

(78) угу почти вот к примеру чтобы на кассе выдали новый сертификат на произвольную сумму - точнее ввели номенклатуру, сделали приход, и продали-пробили
дохрена действий выходит
а надо просто кнопочка открывается формочка где вводят номинал, номер сертификата и все оно все автоматом ввелося причем с формированием шк и добавление в чек номенклатуры и при пробитии вышло сертифиикат(с ШК поверх бланка) и чек к нему

+(80) и такого при обычном внедрении дохрена просто в дописке типовых

всё ясно

(79) Ну конечно очень удобно такой код читать, когда в "выполнить" создаются элементы справочника, потом создаются документы, все это разбавлено тремя-четыремя запросами на 100+ строк, где получаются какие-то данные из регистров для заполнения этого документа.

Очень хочется пожать таким разработчикам горло...

+(80) и выходит чтоб банально записать штрихкод в номенклатуру в рознице или писать кучу своего кода или использовать телепат.dll и найти функции в типовой от разработчиков и как их юзать типа ПодключаемоеОборудованиеРТ.УстановитьШтрихкод(ШтрихКод, НоменклатураСсылка, , , ОписаниеОшибки);

(84) Гыгыгы. Ты просто не видел УТ11.

(84) Да, с документацией кода в типовых плохо, это факт

(85) видел, закрыл в ужасе ))

(83) Хорошо, а теперь другая ситуация:
В коде где-то надо что-то исправить. Ты читаешь текст Выполнить, а там сплошные отсылки к процедурам с непонятными названиями. Тебе надо в каждую зайти и разобраться, правильно ли она все делает, а из нее идет вызов еще 10 процедур, а из каждой из них еще по 5. В итоге в конце ты уже забыл, с какого места кода ты сюда пришел.
Так лучше?
А так бы читал простыночку и понимал ход исполнения. Что зачем идет и где тут ошибка.

(53) Смысл в том, что бы при необходимости читать чужой код не пришлось сначала читать неправильно написанные комментарии к методам, а затем разбираться в коде метода. При этом чем более простой код метода тем легче и быстрее его можно понять.

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

(88) встречный вопрос, а зачем тебе в коде что то исправлять когда можно написать свой код в другом месте который сделает то что нужно, исправит данные или еще что?
и потом другие которые за тобой придут матом не покроют за то что наисправлял вместо дописания?

(88) Непонятные названия процедур - это совсем другая степь, в (59) тебе написали, при чем тут их количество?

(79) Ну ты умник братец. Создаем новый элемент справочника с десятком реквизитов. Один раз, 15 строк, но в цикле загрузки данных из эксель.
И вот ты сидишь в отладчике и долбишь Ф10 как дятел вместо того, чтобы зайти в эту процедуру один раз по Ф11, убедиться, что она работает правильно, а в остальные разы спокойно ее пропускать за один шаг.

(88) Выполнить это жесть :) В 1С от неё рекомендуют отказываться, но когда это невозможно то...

(89) Хорошо, согласен, логически завершенные БОЛЬШИЕ куски, с нормальными названиями и еще и желательно - подробными комментами, я и сам выделяю в отдельные процедуры бывает. Но я про то, что зачем делать кучу процедур по 3 строчки, которые вызываются 1 раз?

+(89) Макконел "Совершенный код", раздел 32.3. Комментировать или не комментировать? стр 764-767

(92) Я ж не про цикл говорю, а когда процедура вызывается ОДИН раз. Т.е. не в цикле, а просто в тексте модля.

(13) Жестоко, но эффективно.

(88) А ты при отладке все последовательно читаешь, и только текущую строчку. Так что пофиг, куда скакать. А если забыл контекст, то всегда можно по стеку прыгнуть вверх и вернуться.
А уж если возник "выполнить" то тебе полюбому труба, так как в выполнении константы смысла нет, а в праметрических выполнить все рано опа.

(0) Это назвается экстремальное программирование.

(94) легче читается основной код откуда они вызываются? там нет простыни из этих много по 3 строчки вместо них вызовы процедур/функций?

(90) Т.е. пусть прога сначала отработает неправильно, а затем вызовет процедуру и все за собой подчистит?
Первый раз встречаю такой подход.

(94) Это нужно для того, что бы выделить логически завершенное преобразование данных в отдельный метод. В дальнейшем, справочник может дополниться прочими реквизитами. Тогда не придется ковырять код непонятно где, ты точно знаешь, что элементы справочника создаются в этом методе...

(101) нормальный подход, чем не нравится?
У вас цель написать идельный код или чтоб работало и легко сопровождалось/изменялось?

(96) Так не пофиг ли, в цикле или нет. В коде то все равно один раз.
А три строчки обычно выделяются либо в модуль "переопределяемый" или в нескольких местах вызываются. А если вызывается хотя-бы в двух местах одно и тоже, то это уже повод задуматься о процедуре даже из одной строки. Так как потом стопудово забудешь синхронно поправить.

(100) конечно легче. читаешь по порядку и все, ничего не повторяется, все идет так, как исполняется. а лучше скакать из процедуры в процедуру и на 10-м вызове забыть точку входа в первый?

(105) Как ты можешь при открытом окне стека забыть, откуда ты вызвался?

(0) Весь сыр бор только в уровнях абстракции. Для того чтобы не смешивать в коде эти уровни, и делают процедуры/функции с красноречивыми именами, которые вызываются всего 1-2 раза.

(106) у него "память - как один килобайт. вроде и есть - и хрен что запомнишь!"©

(106) В окне стека только названия процедур, я могу забыть, что в них происходило. Я могу забыть еще, что означают и откуда берутся переданные в процедуру переменные. А еще я могу читать код не при отладке, а просто, и тогда не могу вызвать окно стека.

Эта предлагаю вместо конкурсов по программированию сделать конкурс по депрограммированию, т.е. по написанному коду понять и расписать что и где происходит ))

Сразу стока внедренцев 1С на 1-е места выйдут...

(108) Под старость память ухудшается, а профессия остается. Грех смеятся над пожилыми людьми.
Да и у многих молодых память не ахти.

(110) Так при сопровождении и доработках это и есть основная задача - найти что где происходит. Каждый наверно был бы рад быть только разработчиком, но такой работы гораздо меньше.

(109) А ты по нему пощелкай. Как раз аккуратно перемещаешься между уровнями абстракции при правильно написанном коде.

(109) пффф... как будто код  скрывается при этом...
наоборот, когда программа состоит из нескольких тысяч строк, тебе не обязательно шагать в отладке по всем кускам, а перепрыгнуть блок из пары или десятка тысяч строк не заходя в этот блок (это когда в 1Ске жмакаешь F10 "Шагнуть через")

кто этого не оценил, видимо не писали и не сопровождали тонны кода

(0) очень большие тексты запросов выношу в функцию

Запрос = Новый Запрос(ПолучитьБольшойТекстЗапроса())

а вот ты покажи свою большую процедуру без подобных выносов

все суета сует. Если у меня текст внутри цикла сильно велик, могу вынести самодостаточные части в отдельные процедуры-функции. Имхо, читабельней.

(0) Смешались в кучу поне, люди...
Как раз отдельная функция или процедура вида ТекКонтрагент = ПолучитьКонтрагента(...) и т. п. позволяет быстрее понять модуль в целом, даже если используется внимание(!) один раз.

Считаю такой код нормальным. сам пишу так. Где то когда то прочитал в учебнике по программированию, что если процедура больше 30ти строк то что то надо выносить в отдельную процедуру.

Имхо тоже - читабельней.

(119) возможно это про то, что раньше среда разработки была текстовой, с высотой экрана 25 строк. следовательно это требование, чтобы процедура помещалась на экран.

Советую всем умникам, которые говорят, что это плохой код почитать - Чистый код. Создание, анализ и рефакторинг
Автор: Роберт К. Мартин

Даже если процедура вызывается один раз, но это помогает лучше читать код, это оправдано и приветствуется!

Опять же хорошая инкапсуляция всегда делает код гибче

Хороший код - это читабельный код. Автор (0) не дорос.

Неужели умные книги читать не учат в университетах?

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

Самая жуть, что я видел - обработка, написанная так:
В модуле объявлено m переменных модуля.
В модуле написано n процедур без параметров, которые как-то внутри себя меняют вышеуказанные переменные. То есть никакого интерфейса ни у чего нет вообще, весь модуль невозможно разобрать на составные части, "убираешь столб - умирает Пьер Безухов".
А то, что в (0) - нормально, если конечно имена у процедур понятные, а не А1(о, _м).

А, ещё хохма - целая процедура "получить номер без разделителей", которая убирает неразрывные пробелы из длинных номеров-чисел. Кто-то не умел использовать Формат(), ну и наваял. И даже в общий модуль засунул.

(0) автор, ты код на джава не читал - на каждый чих - класс, или на С не видел как пишут - на каждые полчиха - свое определение типа. И что удивительно - не видно нигде вопросов - зачем так много функций, а почему все не собрать в одну простыню и читать станет проще?
А вот в 1С - это повод спросить...
Не умеешь читать - не берись, или (как любят тут говоить на форуме ) - "пригласите специалиста"

(0) разработчик молодец - правильно написал.
А автор из (0) проверил ли все места - внешние обработки, базы которые подлючаются через COM, отчеты СКД. Если код используется уже в 2 местах, то надо выносить в отдельные процедуры и функции.
Кроме того, можно сэконить на комментариях

(5) если 2 строчки используеются нескольк раз, то надо.
(53) это если название процедуры не понятное

(101) например, когда тебе надо модифицировать движения по РАУЗ - они формируются в общем модуле, который используется кучей других объектов и вероятность сломать, что либо очень высока. В этом случае лучше прочитать сформированный набор записей и подкорректировать его

(22) "если появляется желание что либо прокомментировать в коде, то этот кусок необходимо выделить в отдельный метод"
Годно. Лучшие комментарии к коду - отсутствие комментариев!

(116) "Запрос = Новый Запрос(ПолучитьБольшойТекстЗапроса()) "
Лучше большие запросы хранить в макетах:
Запрос = Новый Запрос(ПолучитьМакет("НуОченьБольшойТекстЗапроса").ПолучитьТекст())

а чтобы окончательно снесло крышу у ТС, 1с внедряет новые механизмы даже в платформу )))

http://v8.1c.ru/o7/201312ref/index.htm
как то - Инструменты рефакторинга

Функции рефакторинга

Функции рефакторинга позволяют сделать код более понятным и удобным для восприятия. Например, вы можете оформить часть кода в виде отдельной процедуры или функции (команда Выделить фрагмент):

(0) Метод последовательной детализации. Выносить блоки в процедуры и функции - хороший стиль. Зря ТС ругает.
(1) (18) - что-то эти два высказывания как-то не сходятся.

(135) У тебя не сходятся. Значит, ты ещё не дорос.

(134) Не, для сноса крыши нужен обфусцированный код

http://infostart.ru/public/183177/

(132) Код должен быть "самокомментируемым" и в лучшем случае - "самодостаточным"

(107)
Браво. Забавно, что никто смысла поста не понял.

А ТС просто не работал в команде. Зачем читать книги, учиться программировать?? Дали мяч - }{уячь - вот и все 1С-ные паттерны.

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

(138) Код никому и ничего не должен

(133) Не нужно так делать. Нужно так, что бы название функции отражала её предназначение:

Запрос = Новый Запрос(ПолучитьТекстЗапросаШапкаДокумента())

или как-то так

Запрос = Новый Запрос(ПолучитьТекстЗапросаПодсчетаОстатков())


ТС, вон из профессии!!!

(0) Выносить в отдельную процедуру код нужно как раз таки для удобства разбора кода, а не для многоразового использования.
Это стандарты 1С.

(145) И не только 1С.

Хотя конечно налицо последствия школьного обучения.
Если не изменяет память, то Паскаль именно так и пишется... Одной сплошной простыней. И впитывается в мозг почти намертво. Потом выбить сложно.

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

(147) Это хреновые были учителя.
Pascal - образец структурированности, увы, недостижимый разрабами языка 1С.

(0) Я сомневаюсь что есть такой термин.

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

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

Вот как-то так.

:)

(116) Тексты запросов в отдельную функцию это спорно как-то, хотя почти стандарт типовых. По мне так логичнее возвращать готовую выборку. А то текст в одной функции, установка параметров в другой, нарушение абстракции.

(147) Не наговаривайте на Паскаль, в нем тоже можно писать отдельные процедуры и функции. И все чудесно структурировалось

(151) Перепутал человек Паскаль с Бейсиком.
Бывает...

Угу. Как изучал - такие и представления :)

"Садись, два"(с)

(152) В Бейсике тоже все отлично структурируется.

(154) Бейсики разные бывают

(136) Корона за нимб не цепляется?
Приведи-ка пример задачи, в которой правильнее всего использовать команду goto (или её аналог).

(156) А кто ты такой, чтобы я тебе что-то приводил или доказывал?
Не знаешь - сиди, прозябай в невежестве.

в 1С есть команда

Перейти (Goto)
Синтаксис:
    Перейти ~<Метка>;

Англоязычный синтаксис:
    Goto ~<Метка>;

бейсик йопта

(156) почитай СП в 1С))

там пример выхода из двойного цикла

(159) Это слабость языка 1С. В нём нет цикла с постусловием. Аналога repeat ... until из Pascal.
Но, тем не менее, это легко решается без команды Перейти.

(157) Аргумент веский. Убедительный. Придётся согласиться.

(159) И это не портит читабельность? уж лучше еще один флажок завести, типа "мы все сделали" и поставить  в оба условия цикла в конец " и не мыВсеСделали"

(162) Портит читабельность именно такое применение.
С перейти в таком использовании нагляднее.
Представляю нагромождения с условиями, если нужно выйти например из тройного цикла.
В языке не хватает что то вроде Прервать <Уровень>

(158)
http://bash.im/index?text=%F2%E0%EC+%F1%E8%ED%F2%E0%EA%F1%E8%F1+%EA%E0%EA+%E1%F3%E4%F2%EE+%E1%FD%E9%F1%E8%EA+%EF%E5%F0%E5%E2%E5%EB%E8+%EF%F0%EE%EC%F2%EE%EC

(163) Но если что, я не агитирую ни за один способ. Оба применяю там где это лучше подходит.

(156) Использование возврата, Продолжить или Прервать в начале метода/тела цикла при нарушении входных условий

(148) "Pascal - образец структурированности"
Ага. Там даже можно процедуру определить внутри области видимости другой процедуры, а не глобально в модуле.

Всем тем, кто считает, что методы нужны только для предотвращения дублирования кода - пламенный привет.

Макконнелл выделяет 16 причин, и предотвращение дублирования всего лишь на 3м месте.

(167) А это плохо?

(0) Вот проблемы у людей. Мне в основном приходится матерится из-за прямо противоположного.

(0) это еще в 1С лямбд нет и функций первого порядка.
можешь себе представить функцию, которая принимает другую функцию в качестве параметра и возвращает третью функцию?

ИМХО, если "кусочек кода" обладает законченной и изолированной функциональностью, то логично вынести его в отдельную функцию даже если он сейчас только один раз используется. Пусть это лишний вызов, но читабельность кода как раз повышается.

(171) Как представил себе, что это будет использовано в типовых...
Борода резко начала седеть...

(171) а я вот где то видел такое в 1С, где передавались куски кода и в выполнить подсовывались. Да и в УП и УТ11 все больше код движется в эту сторону

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

(175) а я как раз не путаю, продолжить это гото в конец тела цикла, прервать - гото в первую строчку после цикла, возврат - гото в конец метода

Давненько срачей по поводу гоу ту не было.

(171) Это откуда?

(174) Выполнить — это ужас-ужас

(178) откуда что? лямбды и ФПП? из старого доброго функционального программирования.

(180) Старого - да. Доброго - ой сомневаюсь... :-)

(180) Ни разу не сталкивался и изучал. Сейчас почитал, правда, достаточно специфично.

(179) через Выполнить() все обормотчики событий в КД2 работают

(171)
В 1С нет функций высшего порядка, а не первого, адепт.

(184) поймал на терминологии? ну, ок, возьми с полки пирожок

оставлю здесь https://en.wikipedia.org/wiki/First-class_function

(186) тю. вот библия каждого уважающего себя программиста
http://cs7009.vk.me/c540105/v540105830/25a04/icOk10-ri1s.jpg

(171) а вот этого действительно жутко не хватает. как и макросов. И никакими выполнить/вычилсить не компенсировать

(188) В 1С и указателей, как таковых, нет.
Есть только псевдообъекты, с заранее заданными наборами свойств.
Если кому интересно - сравните время вызова функций, работы Выполнить и обращения к объектам - сразу станет понятно, что интерпретатор, какой бы он умный не был - быстротой никогда не отличиться.

(0) Не согласен с озвученным определением лишних процедур.

(169) А чего хорошего? Если ты делаешь узкоспециализированную процедурку, которая используется лишь в одном месте - логично было бы ограничить её область видимости этим местом. Это как приватные методы класса, только без классов - в чисто процедурном подходе.

+(191) Да, и эта дочерняя процедура видит все переменные родительской процедуры, что позволяет и не заморачиваться с передачей параметров, и не вводить глобальных переменных..

(0) Автор не выделяет блоки кода до тех пор, пока они не будут использоваться повторно? Здравствуйте многостраничные процедуры. Очень удобно. "Хороший тон в программировании".

(193) Более того! Когда блок используется повторно - он тупо копипастится! Скорость разработки поднимается в разы, ибо даже думу подключать не нужно. Зачем делать красиво там, куда обычно "почитать" не лазят?

И это тоже нормально:

Процедура УстановитьВидимость()
    УстановитьВидимостьКнопкиПодписания();
КонецПроцедуры

особенно, если по опыту знаешь, что в будущем будут еще "хотелки".

(194) И повторное копирование блока ускоряет исполнение.
P.S. у меня под некоторые языки есть "сборщики кода" - ему пишешь просто и ясно, что нужно сделать, а он уже разворачивает в процедуры и функции, доступные для выбранного языка - то, что кто-то в этом "чуде" разобраться не сможет - это его личные проблемы - можно вверху модуля в комментариях вставить то, что было изначально.

(188) спасибо, кэп!

При этом, быстрые и лёгкие деньги, и даже не всегда маленькие платят именно за гомнокод. А потому чем его бельше тем лучше.

(198) Ну, тот кто платит, код оценивает только по работоспособности.

(199) И это правильно. Так зачем делать лучше если можно потом срубить з улучшение? Как в совке, сначало выпускаем форматку на спецболт, потом вносим рацуху на замену стандартным изделием. И всем хорошо.

(200) именно поэтому и стало программирование - ремеслом куда ломанулись ПТУшники - тупо рубить бабки

(201) Ничего в этом плохого нет.

(0) давайте назовем это "полиморфизированный инкапсулят"!

да, напридумывали пустых ссылок вагон и радуются

(204) еще null, неопределено придумали... логичненько так получилось.. чисто по одноэсовкси

(0) кстати, тоже мучался с возвратом на прежнее место в коде (откуда вызывалась процедура), пока не нашел для себя кноку alt+F2 и F2. Очень полезные.

Только не хватает стрелочек вперед-назад (как в браузерах), чтобы перейти к прошлому куску кода

(206) А еще есть мечта насчет "обратного отладчика" ) Чтобы вернуться назад в исполнении, с восстановлением контекстов.

(59) Полностью согласен.

Так легко читать код и легко работать над отдельными частями.
В основной процедуре написано как оглавление из подпроцедур, в итоге сразу видно - что делается. А если надо детально что-то посмотреть - ныряешь в процедуру и смотришь.

(94) "зачем делать кучу процедур по 3 строчки, которые вызываются 1 раз"
   Ну, это лишнее. Правда, я не читал кода, тебе виднее.

(205) NULL уже был до них, они просто вынуждены были его использовать
Неопределено - тоже нужно, но в БД хранить нельзя его, только для неинициализированных объектов (nil в паскале)

(207) Об этом я тоже мечтал
(208) +1
(209) Бывает и такое нужно.

В тему. Порадовала функция из БСП:

// Создает массив и помещает в него переданное значение
//
Функция ЗначениеВМассиве(Значение) Экспорт
    
    Массив = Новый Массив;
    Массив.Добавить(Значение);
    
    Возврат Массив;
    
КонецФункции

Причины её появления, в принципе, понятны. Но всё равно прикольно смотрится :)

я конечно не профи. Но на мой взгляд даже маленькие процедуры/функции на несколько строк которые используются всего один раз - лучше.
Например название функций% УдалитьПробелыВСтроке(МояСтрока)
ПолучитьАдресКонтрагентаПоЕгоКоду(КодКонтрагента)

По названии сразу понятно что она делает и что должна возвращать.
Если вписать эти несколько строк а основном модуле без комментариев, придётся анализировать что происходит в этих строках.

(213) Уточню про "маленькие процедуры/функции на несколько строк которые используются всего один раз". Только если их суть не прозрачна и не читается "в лёт". Функция из (212) при однократном использовании смысла не имеет и только ухудшает читабельность.

Если правильно названы процедуры - то даже перескакивать туда не обязательно, чтобы понять что она делает.

(214) Согласен. На каждый "чих" ненужно писать функции, но и лепить все в одну процедуру тоже неверно.

(214) Вообще для таких целей было бы неплохо иметь inline-функции. Это бы позволило не заморачиваться с передачей информации через параметры. Или сделать как в паскале - внутренние функции.

(216) А в чем проблема собственно? Тебе строк жалко или что?
У меня например есть такое:
Функция ПолучитьМассивИзСтрокиСРазделителем(пСтрока, пРазделитель = ".") Экспорт
    
    Возврат ирПлатформа.ЛксПолучитьМассивИзСтрокиСРазделителем(пСтрока, пРазделитель);
    
КонецФункции

Функция МассивИзСтрокиСРазделителем(пСтрока, пРазделитель = ".") Экспорт
    
    Возврат ирПлатформа.ЛксПолучитьМассивИзСтрокиСРазделителем(пСтрока, пРазделитель);
    
КонецФункции

Функция МассивИзСтрокиСРазделителями(пСтрока, пРазделитель = ".") Экспорт
    
    Возврат ирПлатформа.ЛксПолучитьМассивИзСтрокиСРазделителем(пСтрока, пРазделитель);
    
КонецФункции

Функция ИзСтрокиСРазделителем(пСтрока, пРазделитель = ".") Экспорт
    
    Возврат ирПлатформа.ЛксПолучитьМассивИзСтрокиСРазделителем(пСтрока, пРазделитель);
    
КонецФункции

Функция ИзСтрокиСРазделителями(пСтрока, пРазделитель = ".") Экспорт
    
    Возврат ирПлатформа.ЛксПолучитьМассивИзСтрокиСРазделителем(пСтрока, пРазделитель);
    
КонецФункции

Это называется "синонимы" и тебе просто не надо запоминать как он там пишется - все что не напишешь будет правильно.

(207) Есть мечта, что бы появилась возможность останавливаться по ошибке содержащей текст

(219) А что, уже убрали в новых релизах??

+(219) Наоборот, не останавливаться на ошибках, содержащих текст. Например когда ошибки в попытках маскируются :)

сорри :)