Принципы чистого кода

Будьте последовательны

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

Значимые имена

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

Отступы и стиль кода

Отступы - это практика использования пробелов для визуальной группировки связанных строк кода вместе, что облегчает чтение и понимание структуры кода. Стиль кода относится к соглашениям и руководящим принципам, используемым для форматирования и структурирования кода, таким как соглашения об именовании, комментарии и использование пробелов.

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

Держи маленьким

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

Чистые функции

Чистая функция - это определенный тип функции, который удовлетворяет следующим критериям:

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

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

Сведите к минимуму цикломатическую сложность

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

Вот несколько способов минимизировать цикломатическую сложность в системной архитектуре:

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

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

Избегайте передачи нулевых логических значений

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

Используйте опции или, возможно, типы вместо нулей, чтобы указать на отсутствие значения. Это позволяет определить, когда значение отсутствует, и предотвращает исключения, связанные с нулевой ссылкой.
Используйте значение по умолчанию для аргументов функции вместо того, чтобы позволять им быть нулевыми или логическими. Это устраняет необходимость проверять наличие нулевых или логических значений и снижает вероятность возникновения ошибок.
Используйте шаблон Null Object для замены нулевых значений специальным объектом, который имеет определенное поведение. Это устраняет необходимость проверять наличие нулевых значений и делает код более читабельным.
Используйте троичный оператор (?:) вместо операторов if-else при работе с логическими значениями. Это может сделать код более кратким и легким для чтения.
Используйте функцию assert, чтобы проверить правильность аргументов функции и вызвать исключение, если они недействительны.

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

Используйте правильные конструкции

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

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

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

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

Сохраняйте независимость тестов

Сохранение независимости тестов помогает гарантировать, что тесты надежны, воспроизводимы и просты в обслуживании. Когда тесты независимы, изменение в одном тесте не повлияет на результаты других тестов.

Вот несколько способов сохранить независимость тестов в системной архитектуре:

Используйте внедрение зависимостей, чтобы отделить тестовый код от кода приложения. Это позволяет запускать тесты без необходимости непосредственного создания экземпляров объектов приложения.
Используйте макеты или заглушки, чтобы изолировать тест от внешних зависимостей, таких как базы данных, API-интерфейсы или другие службы.
Используйте тестовые данные, которые являются автономными и не зависят от внешних данных или состояния.
Используйте платформу тестирования, поддерживающую параллельное выполнение тестов, чтобы тесты можно было запускать независимо друг от друга.
Используйте test-driven development (TDD), которая предполагает написание тестов перед написанием кода приложения. Это гарантирует, что тесты независимы и что код написан с учетом тестируемости.
Избегайте глобального состояния и общего изменяемого состояния, так как это может привести к неожиданным результатам.

Используйте осмысленные имена

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

Вот несколько способов использования осмысленных имен в системной архитектуре:

Используйте описательные и значимые имена для переменных, функций, классов и других элементов кода.
Используйте согласованные соглашения об именовании во всей кодовой базе, такие как camelCase для переменных и PascalCase для функций и классов.
Используйте сокращения с осторожностью и только в том случае, если они широко понятны.
Используйте значимые префиксы или суффиксы для указания типа или назначения переменной или функции, такие как “is” или “get” для логических переменных или “list” для переменных массива
Избегайте использования однобуквенных имен переменных или общих названий, таких как “temp” или “x”, которые не передают никакого смысла.
Избегайте использования чрезмерно длинных или сложных имен, которые затрудняют чтение кода.

Код по субъекту

“Код по субъектам” - это метод разработки программного обеспечения, который побуждает разработчиков организовывать свой код вокруг субъектов или сущностей, которые с ним взаимодействуют. Участниками могут быть пользователи, системы или процессы, которые выполняют определенную роль или функцию в приложении. Такой подход помогает создать четкое разделение задач, делая код более модульным, пригодным для повторного использования и более простым для понимания.

Разделение командных запросов

Разделение команд и запросов (CQS) - это принцип разработки программного обеспечения, который разделяет обязанности метода или функции на две категории: команды и запросы. Команды - это методы, которые изменяют состояние системы, в то время как запросы - это методы, которые возвращают информацию, но не изменяют состояние системы.

Избегайте поспешных абстракций

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

Вот несколько способов избежать поспешных абстракций в системной архитектуре:

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