Ваша роль как программиста заключается в написании кода, который работает должным образом и обеспечивает желаемый результат. Однако код также должен быть простым для понимания, поддержки и расширения. Чтобы справиться с этой задачей, вам необходимо объединить ключевые концепции программирования с принципами хорошего кодирования.
В этой статье мы поделимся 10 лучшими принципами программирования, которые помогут вам улучшить способ написания кода, что облегчит жизнь вам, вашим коллегам–разработчикам и конечным пользователям.
Почему важны принципы программирования?
Потратив время на изучение некоторых принципов программирования и дальнейшее их использование в своем коде, вы станете лучшим разработчиком. Следование этим рекомендациям повышает общее качество кода и облегчает вам или кому-либо еще внесение изменений или добавление функциональности в будущем.
Принципы программирования помогут вам избежать таких проблем, как беспорядочный или чрезмерно сложный код, программы, которые ломаются после одной настройки, и переменные, которые не имеют смысла. Соблюдение их также позволит вам более успешно сотрудничать, гарантируя, что другие программисты смогут понять ваш код.
Независимо от того, создаете ли вы базовую программу или приложение корпоративного уровня, стоит ознакомиться с этими 10 принципами.
1. Делай проще, тупица! (KISS)
Сохранение простоты и чистоты кода — один из важнейших принципов программирования. Некоторым разработчикам нравится хвастаться, написав слишком длинный или сложный код, но даже если это выглядит умно, код может быть не особенно понятным.
Вы всегда должны стремиться к тому, чтобы ваш код был легким для понимания – если вы можете написать скрипт в одну строку, то сделайте это! Вы можете разбить сложную задачу на более мелкие фрагменты или удалить какой-нибудь ненужный код. Цель состоит в том, чтобы уменьшить сложность и решить проблемы, а не произвести впечатление на людей.
Использование понятных имен переменных — еще один способ упростить задачу. Не забывайте пользоваться библиотеками кодирования и существующими инструментами.
2. Не повторяйтесь! (DRY)
Повторение — распространенная ошибка, потому что, если вы дублируете данные, логику или функцию, ваш код будет длинным, и на его поддержку, отладку или модификацию потребуется больше времени.
Повторение включает в себя копирование и вставку кода в вашу программу. Вместо дублирования строк лучше найти алгоритм, который вместо этого использует цикл, поскольку гораздо проще отладить один цикл, который обрабатывает 20 повторений, чем 20 блоков кода, каждый из которых обрабатывает одно повторение.
3. Вам это не понадобится! (YAGNI)
Вы не должны писать код исключительно на тот случай, если он вдруг может понадобиться в будущем. Другими словами, принцип YAGNI говорит вам писать код только для текущей ситуации, а не пытаться решить проблему, которой не существует здесь и сейчас.
Свойства и функционал следует добавлять только при необходимости, в противном случае ваше программное обеспечение станет больше и сложнее, чем это необходимо. YAGNI исходит из методологии разработки программного обеспечения Extreme Programming (XP), которая направлена на снижение неэффективности.
Программисты иногда нарушают этот принцип, пытаясь придерживаться методов кодирования DRY, поэтому убедитесь, что вы помните и о том, и о другом.
4. Документируйте свой код
Итак, вы написали свой код и понимаете его (надеемся!). Но только потому, что для вас он имеет абсолютный смысл, это не значит, что написанное будет понятно кому-то еще. Вы можете помочь своим коллегам-разработчикам, задокументировав свой код комментариями, а также улучшив имена ваших переменных и функций.
Например, если вы разрабатывали алгоритм маршрутизации вызовов для использования в решениях центров обработки вызовов VoIP, вы могли бы оставлять комментарии, объясняющие различные функции и облегчающие их понимание другими разработчиками или тестировщиками.
Все языки программирования предоставляют вам возможность прикреплять комментарии к вашему коду, поэтому вы должны сделать это своей привычкой. Да, это небольшая дополнительная работа, но она важна при сотрудничестве с другими. Кроме того, если вы вернетесь, чтобы изменить код через несколько месяцев, вы будете рады, что сделали это!
5. Композиция важнее наследования
Если вы повторно используете код, который уже написали, есть два способа сделать это: наследование и композиция. Большинство программистов предпочитают композицию (хотя наследование имеет свои преимущества, так что не игнорируйте его полностью).
Принцип композиции вместо наследования особенно полезен, если вы используете объектно-ориентированное программирование или ООП (которое на самом деле имеет свой собственный набор принципов). В нем говорится, что объекты со сложным поведением должны содержать экземпляры объектов с индивидуальным поведением – они не должны наследовать класс и добавлять новые модели поведения.
С наследованием фреймворки классов быстро становятся громоздкими, что приводит к появлению множества классов, которые могут соответствовать или не соответствовать вашим потребностям. Иерархии классов трудно изменить после их развертывания, поскольку вы не можете изменить суперкласс, не рискуя нарушить подкласс пользователя. И существует меньшая гибкость для определения поведения в особых случаях.
Композиционное программирование проще в написании и обслуживании, а также обеспечивает более простую и тестируемую кодовую базу. Оно позволяет определять гибкость поведения — вы можете создавать классы для легкого добавления или изменения и откладывать создание компонентов до тех пор, пока они не понадобятся.
6. Открыто/Закрыто
Если вы создаете библиотеку или фреймворк, которые будут использовать другие, важным принципом является «открытость/закрытость». Это означает, что программные артефакты, такие как классы и модули, открыты для расширения, но закрыты для модификации. Такой подход делает код более стабильным и простым в обслуживании.
Допустим, вас просят написать код для шаблона агентского соглашения компании, занимающейся разработкой программного обеспечения для электронной подписи. Вы выпускаете версию фреймворка, чтобы программисты могли напрямую изменять и интегрировать ваш выпущенный код. Но если вы выпустите крупное обновление в будущем, код будет нарушен. Лучше выпускать код, который поощряет расширение, предотвращая при этом прямое изменение, что сводит к минимуму риск появления новых ошибок.
7. Единственная ответственность
Этот принцип гласит, что каждый класс или модуль в программе должен предоставлять только одну конкретную функциональность, и не должно быть более одной причины для изменения класса. Цель состоит в том, чтобы избежать умножения побочных эффектов или обязанностей в одном методе или классе.
Классы усложняются, если вы добавляете слишком много обязанностей, и становится труднее создать дополнительную функциональность для конкретного модуля. Лучше разбить их на более мелкие классы и модули, чтобы было легче изолировать определенный модуль для устранения неполадок.
Единственная ответственность и открыто/закрыто являются частью принципов SOLID, изложенных Робертом Мартином (принципы объектно-ориентированного программирования).
8. Разделение ответственности (SoC)
Этот принцип программирования представляет собой абстрактную версию единой ответственности. SoC утверждает, что программа должна быть разработана с использованием разных контейнеров, которые не должны иметь доступа друг к другу. Каждый фрагмент кода полностью независим.
Это способ разделения сложного приложения на различные разделы или домены, каждый из которых выполняет определенную работу или решает разные проблемы. Такого рода подход упрощает обслуживание, обновление, повторное использование и отладку кода.
Хорошо известным примером является дизайн «Модель-Представление-Контроллер» (MVC), используемый в настоящее время в популярных веб-фреймворках. Программа разделена на три отдельных раздела – данные (модель), логика (контроллер) и то, что видит конечный пользователь (представление), — и каждый раздел обрабатывается независимо.
9. Минимизируйте связь
Кодовая связь — это когда два модуля или два уровня имеют определенную степень взаимозависимости, например, совместно используют код или имеют доступ к одним и тем же данным. Это может создать проблемы, в том числе код, который трудно отслеживать и поддерживать.
Например, если разработчик связывает свои конечные точки API с определенным представлением в интерфейсном приложении, таком как многоканальная телефонная система, конечная точка не может быть повторно использована для другого представления, такого как мобильное приложение.
Программистам необходимо понимать, как связан код, чтобы минимизировать взаимодействие, что включает в себя понимание обязанностей каждого уровня. Единственная ответственность также уменьшает взаимосвязь между отдельными компонентами программного обеспечения и кода.
10. Рефакторинг
Кодовые базы постоянно развиваются, поэтому будут моменты, когда вам потребуется пересмотреть, переписать или переработать целые фрагменты кода. Вместо того чтобы рассматривать это как неудачу вашей первой попытки, думайте об этом как о возможности учиться.
Рефакторинг кода означает его пересмотр и поиск способов оптимизации, повышения эффективности при сохранении точно таких же результатов. Однако вам следует избегать преждевременной оптимизации. Не оптимизируйте свой алгоритм на ранней стадии разработки, потому что вы не можете предсказать узкие места, а требования могут измениться.
В заключение
Если бы мы сократили этот список до одного ключевого принципа, он был бы таким: сделайте ваш код легким для понимания и обслуживания. Несколько принципов программирования в нашем списке преследуют эту цель, начиная с KISS и DRY до единственной ответственности и документирования вашего кода.
Следуя выше описанным принципам, вы сможете создать простой код, который делает то, что от него требуется, и понятен другим. Кроме того, вы будете знать подходящее время для его оптимизации. И последний совет – продолжайте учиться, чтобы продолжать совершенствоваться.
Всем успешной работы и творчества!
0 комментариев