Лучшие практики: Много небольших функций/методов или большие функции с логическими встроенными компонентами процесса? [закрытый]

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

Fowler Рефакторинг является всем об этой теме, и я настоятельно рекомендую его.

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

Размер метода непосредственно связан с цикломатическая сложность .

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

• лучшее поблочное тестирование (из-за низкой цикломатической сложности)
• лучшая отладка из-за более явного отслеживания стека (вместо одной ошибки в рамках одного гигантского метода)

Поскольку всегда можно сказать: это зависит. Это - больше вопрос именования и определения задачи метода. Каждый метод должен сделать один (не больше) четко определенная задача и должен сделать их полностью. Название метода должно указать на задачу. Если Ваш метод называют DoAandB (), может быть лучше иметь отдельные методы DoA () и DoB (). При необходимости в методах как setupTask, executeTask, FinishTask, может быть полезно объединить их.

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

• метод А не может использоваться один без использования других методов.
• необходимо стараться назвать некоторые зависимые методы в правильном порядке.

Некоторые точки, которые указывают, что раскол метода мог быть полезным:

• Некоторые строки существующего метода имеют ясную независимую задачу.
• Поблочное тестирование большого метода становится проблематичным. Если тесты легче записать для независимых методов, то разделенный большой метод.

Как объяснение к аргументу модульного теста: Я записал метод, который сделал некоторые вещи включая IO. IO-часть было очень трудно протестировать, таким образом, я думал об этом. Я пришел к выводу, что мой метод сделал 5 логических и независимых шагов, и только один из них включил IO. Таким образом, я разделил свой метод на 5 меньших, четырех из них было легко протестировать.

Маленькие методы каждый раз.

Они сам документирующий (er, если хорошо названо)

Они ломают проблему в управляемые части - Вы - KeepingItSimple.

можно использовать методы OO для более легко (и очевидно) включают поведение. Большой метод является по определению более процедурным и настолько менее гибким.

Они - тестируемая единица. Это - уничтожитель, Вы просто can’t модульный тест некоторый огромный метод, который выполняет загрузку задач

Что-то я узнал из Кода о Полной книге:

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

Hope это помогает

Я заставляю каждую функцию сделать одну вещь и одну вещь только, и я пытаюсь не вложить слишком много уровней логики. Как только Вы начинаете разламывать свой код на хорошо названный функции, становится намного легче читать, и практически самодокументирование.

Я нахожу, что наличие многих маленьких методов делает код легче считать, поддержать и отладить.

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

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

существует искусство, я думаю к знанию, что инкапсулировать. У всех есть некоторые незначительные различия мнения. Если бы я мог бы поместить его в слова, я сказал бы, что каждый метод должен сделать одну вещь, которая может быть описана как выполнять задача.

Некоторые эмпирические правила:

• Функции не должны быть более длительными, чем, что может быть отображено на экранных
• функциях Повреждения в меньшие, если это делает код более читаемым.

Чем больше метод, тем тяжелее протестировать и поддержать. Я нахожу, что его намного более легкое понимает, как большой процесс работает когда его разломанный на атомарные шаги. Кроме того, выполнение этого является большим первым шагом для создания классов расширяемыми. Можно отметить те отдельные шаги как виртуальные (для наследования) или переместить их в другие объекты (состав), делая поведение приложения легче настроить.

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

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

Лично, я значительно склоняюсь в направлении предпочтения больше, меньших методов, но не на грани религиозного стремления к максимальному количеству строки. Мой основной критерий или цель должны сохранить мой DRY кода. Минута у меня есть блок кода, который дублирован (ли в духе или на самом деле текстом), даже если это могли бы быть 2 или 4 строки долго, я высушил тот код в отдельный метод. Иногда я буду делать так заранее, если я буду думать, что существует хороший шанс, он будет использоваться снова в будущем.

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

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