Как сделать чистый код

Добавил пользователь Morpheus
Обновлено: 18.09.2024

Эта глава проект от моей предстоящей книги От одного до нуля Чтобы появиться в 2021 году с ностархом, научит вас и как писать чистый и простой код. Чтобы оставаться настроенными о выпуске книги, подписаться на Академия кодирования электронной почты Finxter (это бесплатно)!

Написать Clean & Simple Code

Сложность : В предыдущих главах вы узнали, как вредная сложность предназначена для любого кодового проекта в реальном мире. Сложность убивает вашу производительность, мотивацию и время. Потому что большинство из нас не научились говорить в исходном коде из раннего возраста, он может быстро сокрушить наши познавательные способности. Чем больше у вас код, тем более подавляющее это становится. Но даже короткие кодовые фрагменты и алгоритмы могут быть сложными. Следующий фрагмент кода одноклассника из нашей книги Python One-listers Это отличный пример куска исходного кода, который короткий и лаконичный, но все еще сложный!

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

«Действительно, соотношение времени, потраченное на чтение по сравнению с письмом, более 10 к 1. Мы постоянно читаем старый код как часть усилий, чтобы написать новый код… [следовательно,] облегчает чтение, облегчает запись. “ – Роберт С. Мартин

Эти отношения визуализируются в Рисунок 5-1 Отказ Ось X соответствует количеству строк, написанных в данном кодовом проекте. Ось Y соответствует времени для записи одной дополнительной строки кода. В общем, чем больше кода вы уже написали в одном проекте, тем больше времени требуется, чтобы написать дополнительную строку кода. Это почему? Скажем, вы написали N строки кода, и вы добавляете n + 1 st линия кода. Добавление этой строки может возникнуть потенциально все ранее написанные строки. Может иметь небольшой штраф производительности, который влияет на общий проект. Это может использовать переменную, которая определяется в другом месте. Он может ввести ошибку (с вероятностью C ) и найти эту ошибку, вы должны искать весь проект (Итак, ваши ожидаемые расходы на строку кода – C * T (N) для неуклонно Увеличение функции T с увеличением ввода n ). Это может заставить вас писать дополнительные строки кода, чтобы обеспечить обратную совместимость. Есть еще много причин, но вы получаете точку: дополнительная сложность заставляет замедлить ваш прогресс, тем больше написанного вами кода.

Рисунок 5-1: Чистый код улучшает масштабируемость и обслуживание вашей кодовой базы.

Но рисунок 5-1 также показывает разницу между записью грязных против чистого кода. Если написание грязного кода не приведет к любой выгоде, никто не сделает этого! Существует очень реальное преимущество записи грязного кода: в краткосрочной перспективе он меньше времени, а для небольших кодовых проектов. Если вы заправляете все функциональные возможности в 100-строчной кодовой скрипте, вам не нужно много времени вкладывать много времени и структурирования вашего проекта. Но, как вы добавите все больше и больше кода, файл монолитного кода вырастает от 100 до 1000 строк и в определенной точке будет гораздо менее эффективным по сравнению с более вдумбимым подходом, в котором вы структурируете код логически в разных модулях, классах, или файлы. Как правило, старайтесь всегда писать вдумчивый и чистый код – потому что дополнительные расходы на мышление, рефакторинг и реструктуризация еще много времени заплатит за любой нетривиальный проект. Кроме того, чистый код записи – это просто правильная вещь. Философия тщательно создания вашего программирования искусства будет продолжать вас в жизни.

Вы не всегда знаете последствия вашего кода второго порядка. Подумайте о космическом корабле на миссии в направлении Венеры в 1962 году, где крошечная ошибка – упущение дефиса в исходном коде, вызвало инженеров NASA, чтобы выпустить команду самоуничтожения, которая привела к убытке ракеты на сумму более 18 миллионов долларов на время.

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

Итак, давайте узнаем, как написать чистый и простой код?

Чистый код элегантный и приятный для чтения. Он сосредоточен в том смысле, что каждая функция, класс, модуль фокусируется на одной идее. Функция Transfer_Funds (A, B) В вашем банковском приложении только это передает средства со счета А Для учетной записи B Отказ Это не проверяет кредит отправителя А – для этого есть другая функция check_credit (a) Отказ Просто, но легко понять и сосредоточиться. Как вы получаете простой и чистый код? Потратив время и усилия, чтобы редактировать и пересмотреть код. Это называется рефакторингом, и он должен быть запланированным и важным элементом вашего процесса разработки программного обеспечения.

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

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

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

Принцип 1: Вы не будете нуждаться в этом

Принцип предполагает, что вы никогда не должны реализовать код, если вы только ожидаете, что вам нужно, чтобы вы когда-нибудь нуждаетесь в его предоставленной функциональности в будущем – потому что вам это не понадобится! Вместо этого напишите код только в том случае, если вы на 100% уверены, что вам это нужно. Код для сегодняшних потребностей и не завтра.

Это помогает подумать от первых принципов: простейший и чистый код – это пустой файл. У него нет ошибок, и это легко понять. Теперь иди оттуда – что вам нужно добавить к этому? В главе 4 вы узнали о минимальном жизнеспособном продукте. Если вы минимизируете количество функций, которые вы преследуете, вы будете убирать более чистые и более простые код, чем вы могли бы когда-либо достичь методов рефакторинга или все остальные принципы объединены. Как вы знаете, о том, что оставив свои функции не только полезны, если они не нужны. Оставляя их даже имеет смысл, если они обеспечивают относительно небольшое значение по сравнению с другими функциями, которые вы могли бы вместо этого. Стоимость возможностей редко измерена, но чаще всего они очень важны. Только потому, что функция предоставляет некоторые преимущества не оправдывают его реализацию. Вам нужно действительно нужна функция, прежде чем даже рассмотреть ее реализацию. Пожимайте низкосовесные фрукты сначала до того, как вы достигнете выше!

Принцип 2: принцип наименее удивления

Этот принцип является одним из золотых правил эффективного приложения и дизайна пользователей. Если вы открываете поисковую систему Google, курсор будет уже сосредоточен на поле ввода поиска, чтобы вы могли начать вводить слово поиск прямо сейчас, не требуя, чтобы нажать на поле ввода. Не удивительно вообще – но отличный пример принципа наименее удивления. Чистый код также использует этот принцип дизайна. Скажем, вы пишете конвертер валют, который преобразует ввод пользователя с USD на RMB. Вы храните ввод пользователя в переменной. Какое имя переменной лучше подходит, user_input или var_x ? Принцип наименее удивления отвечает на этот вопрос для вас!

Принцип 3: не повторяйся

Не повторяйте себя (сухой) – это широко признанный принцип, который подразумевает, что если вы пишете код, который частично повторяется – или это даже копирование и вставляется из вашего собственного кода – это знак плохого стиля кодирования. Отрицательный пример – следующий код Python, который печатает одну и ту же строку пять раз в оболочку:

Код повторяется, поэтому принцип предполагает, что будет лучший способ написания его. И есть!

Код гораздо короче, но семантически эквивалентна. В коде нет избыточности.

Принцип также показывает вам, когда создать функцию и когда это не требуется для этого. Скажем, вам нужно преобразовать мили в километры в несколько экземпляров в вашем коде (см. Листинг 5-1 ).

Листинг 5-1: Преобразовать мили до километров дважды.

Принцип Не повторяйте себя предполагает, что было бы лучше написать функцию Miles_to_km (миль) Однажды, а не выполнять одно и то же конвертацию явно в коде несколько раз (см. Листинг 5-2 ).

Листинг 5-2: Использование функции для преобразования миль до километров.

Таким образом, код проще для обслуживания, вы можете легко увеличить точность преобразования впоследствии без поиска кода для всех экземпляров, где вы использовали методологию неточной преобразования. Также легче понимать для человеческих читателей вашего кода. Нет сомнений в целях функции miles_to_km (20) Хотя вам, возможно, придется задуматься о целях вычисления 20 * 1.60934.

Принцип Не повторяйте себя часто сокращается как сухие и нарушения его как мокрых: Нам нравится печатать , Писать

Принцип 4: код для людей не машин

Основная цель исходного кода состоит в том, чтобы определить, какие машины должны делать и как это сделать. Тем не менее, если это было единственным критерием, вы бы использовали язык машины низкого уровня, такой как ассемблер для достижения этой цели, потому что это самый выразительный и самый мощный язык. Целью высокого уровня языков программирования, таких как Python, заключается в том, чтобы помочь людям писать лучший код и сделать это быстрее. Наш следующий принцип для чистого кода – постоянно напоминать себе, что вы пишете код для других людей, а не для машин. Если ваш код будет иметь какое-либо влияние в реальном мире, он будет читать несколько раз или программист, который требует ваше место, если вы перестанете работать на базе кода. Всегда предполагайте, что ваш исходный код будет прочитан другими людьми. Что вы можете сделать, чтобы облегчить свою работу? Или, чтобы положить его проще: что вы можете сделать, чтобы смягчить негативные эмоции, которые они будут испытывать против оригинального программиста кодовой базы их работы? Код для людей не машин!

Что это значит на практике? Есть много последствий. Прежде всего, используйте значимые имена переменной. Листинг 5-3 Показывает отрицательный пример без значимых имен переменной.

Листинг 5-3: Пример записи кода для машин.

Угадайте: что вычисляет код?

Давайте посмотрим на семантически эквивалентный код в Листинг 5-4 Это использует значимые имена переменной.

Листинг 5-4: Использование функции для преобразования миль до километров.

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

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

Принцип 5: стоять на плечах гигантов

Там нет значения при изобретении колеса. Программирование представляет собой десятилетие, и лучшие кодерации в мире дали нам большое наследие: коллективную базу данных миллионов тонко настроенных и хорошо проверенных алгоритмов и функций кода. Доступ к коллективной мудрости миллионов программистов так же просто, как и использование оператора Import One-Liner. Вы будете безумие не использовать эту сверхдержаву в своих собственных проектах. Помимо простых в использовании, использование библиотечного кода, вероятно, улучшит эффективность вашего кода, поскольку функции, которые использовались тысячами кодеров, как правило, намного оптимизированы, чем ваши собственные функции кода. Кроме того, библиотечные вызовы легче понимать и принимать меньше места в вашем проекте кода. Например, если вам понадобится алгоритм кластеризации, чтобы визуализировать кластеры клиентов, вы можете либо реализовать его самим или стоять на плечах гигантов и импортировать алгоритм кластеризации из внешней библиотеки и передавать ваши данные в него. Последнее гораздо больше времени эффективно – вы займете гораздо меньше времени, чтобы реализовать ту же функциональность с меньшим количеством ошибок, меньшего пространства и более качественного кода. Библиотеки являются одной из главных причин, по которым мастер-коды могут быть в 10 000 раз более продуктивными, чем средние кодеры.

Вот два-лайнер, который импортирует модуль KMAINS из библиотеки Python Scikit-Sulect Python, а не нарисованный колесо:

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

Принцип 6: Используйте правильные имена

Есть много явных и неявных правил, регулирующих правильное название ваших элементов кода. Эти правила могут даже отличаться от языка программирования к языку программирования. Например, вы будете использовать CamelcaSenaming Для переменных на языке программирования Java, пока вы будете использовать underscore_naming в питоне. Если вы начнете использовать чехол на верблюда в Python, все сразу увидят, что вы начинающий Python. Пока вам нельзя понравиться, это не очень большая проблема, которую нужно восприниматься как новичок – все были один в один момент времени. Далеко хуже состоит в том, что другие кодеры будут негативно удивлены при чтении их кода. Вместо того, чтобы думать о том, что делает код, они начинают думать о том, как ваш код написан. Вы знаете, что принцип наименьшего сюрприза – нет никакой ценности в удивительных других кодерах, выбрав нетрадиционные имена переменных.

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

Принцип 7: Принцип одностороннего ответственности

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

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

Давайте рассмотрим небольшие примеры, используя код Python, который может работать на устройстве Reader для моделирования и управления опытом чтения пользователя (см. Листинг 5-5 ).

Листинг 5-5: Моделирование класса книг с нарушением единственного принципа ответственности – класс книги отвечает за моделирование данных, так и для представления данных. У него есть две обязанности.

Код в Листинг 5-5 Определяет класс Книга С четырьмя атрибутами: название, автор, издатель и текущий номер страницы. Вы определяете методы Getter для атрибутов, а также несколько минимальных функций для перемещения на следующую страницу. Функция next_page () Может быть вызван каждый раз, когда пользователь нажимает кнопку на устройстве для чтения. Другая функция print_page () отвечает за печать текущей страницы на устройство для чтения. Это дается только как заглушка, и он будет более сложным в реальном мире. Хотя код выглядит чистым и простым, оно нарушает единственный принцип ответственности: классная книга отвечает за моделирование таких данных, как содержание книги, но он также несет ответственность за печать книги на устройство. У вас есть несколько причин для изменения. Возможно, вы захотите изменить моделирование данных книги, например, используя базу данных вместо файлового метода ввода/вывода. Но вы также можете захотеть изменить представление моделированных данных, например, используя другую схему форматирования книги на экранах другого типа. Моделирование и печать – это две разные функции, инкапсулируемые в одном классе. Давайте изменим это в Листинг 5-6 !

Листинг 5-6: Придерживаясь принципов одной ответственности – класс книги отвечает за моделирование данных, а класс печати отвечает за представление данных.

Код в Листинг 5-6 выполняет ту же задачу, но это удовлетворяет единственному принципу ответственности. Вы создаете как книгу, так и класс принтера. Класс книги представляет книгу META информацию и текущий номер страницы. Класс принтера печатает книгу на устройство. Вы передаете книгу, для которой вы хотите распечатать текущую страницу в метод Принтер.Print_page () Отказ Таким образом, моделирование данных и представление данных развязаны, и код становится легче поддерживать.

Вы хотите развивать навыки Хорошо округлый Python Professional То же оплачивается в процессе? Станьте питоном фрилансером и закажите свою книгу Оставляя крысиную гонку с Python На Amazon ( Kindle/Print )!

Рекомендации:

Куда пойти отсюда?

Достаточно теории, давайте познакомимся!

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

Практические проекты – это то, как вы обостряете вашу пилу в кодировке!

Вы хотите стать мастером кода, сосредоточившись на практических кодовых проектах, которые фактически зарабатывают вам деньги и решают проблемы для людей?

Затем станьте питоном независимым разработчиком! Это лучший способ приближения к задаче улучшения ваших навыков Python – даже если вы являетесь полным новичком.

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

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

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

Что такое качественный код

Отличительные признаки хорошего кода:

  1. Читаемость — не только для компьютера, но и для людей. Это позволит менять, дополнять и исправлять код даже тем, кто видит его первый раз.
  2. Стабильность. Избежать багов получается не всегда, но даже в этом случае они должны быть легко поправимы и немногочисленны.
  3. Модифицируемость. Внесение изменений не должно вызывать сложностей и приводить к появлению ошибок.

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

Почему качество кода так важно


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

Источник: Cyanide and Happiness

Признаки хорошего кода

Линейность


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

Краткость

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

Наличие комментариев

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

Ошибки при создании кода

Слишком много кода в комментариях

Иногда перенос блоков кода в комментарии объясняется благими намерениями программистов: мало ли, кому он может понадобиться в будущем. Например, это происходит, когда часть программы полностью переписывается, но перечеркивать проделанную работу жалко — вот она и пылится в комментариях месяцами. Если часть кода можно убрать, то это нужно сделать.

Отсутствие тестов

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

Одержимость производительностью и правильностью

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

Война с ошибками

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

Работа над качеством кода в Azoft

Разработка архитектуры

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

Рефакторинг

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

Code Review

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

Статический анализ

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

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

Что такое качественный код

Отличительные признаки хорошего кода:

  • Читаемость – не только для компьютера, но и для людей. Это позволит менять, дополнять и исправлять код даже тем, кто видит его первый раз.
  • Стабильность. Избежать багов получается не всегда, но даже в этом случае они должны быть легко поправимы и немногочисленны.
  • Модифицируемость. Внесение изменений не должно вызывать сложностей и приводить к появлению ошибок.

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

Почему качество кода так важно

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


Источник: Cyanide and Happiness

Признаки хорошего кода

Линейность

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

Чистый код проще бутерброда

Краткость

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

Наличие комментариев

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

Ошибки при создании кода

Слишком много кода в комментариях

Иногда перенос блоков кода в комментарии объясняется благими намерениями программистов: мало ли, кому он может понадобиться в будущем. Например, это происходит, когда часть программы полностью переписывается, но перечеркивать проделанную работу жалко – вот она и пылится в комментариях месяцами. Если часть кода можно убрать, то это нужно сделать.

Отсутствие тестов

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

Одержимость производительностью и правильностью

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

Война с ошибками

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

Работа над качеством кода в Azoft

Разработка архитектуры

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

Рефакторинг

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

Code Review

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

Статический анализ

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

Заключение

Подпишитесь

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

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №1

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

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

Ваш код должен читаться, как хорошая статья. Можете считать свои классы/файлы заголовками, методы – абзацами, а строки – предложениями. Вот несколько характеристик чистого кода:

  1. Чистый код сфокусирован: каждая функция, класс и модуль должны делать какое-то одно действие, но делать его хорошо.
  2. Он должен быть элегантным. Чистый код прост для чтения. Когда вы читаете такой код, у вас должна непроизвольно появляться улыбка. У вас должна быть уверенность, что вы точно знаете, что именно делает этот код.
  3. Чистый код это заботливо написанный код. Кто-то потратил время, чтобы сделать его простым и упорядоченным. Этот человек уделил соответствующее внимание деталям. Он явно был неравнодушен к своему делу.
  4. У вас не должно возникать проблем с тестами: чистый код не может быть сломанным!

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

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

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

Чтобы сделать код понятным и легким для чтения, следите за тем, чтобы отступы, переносы строк и форматирование были последовательными (одинаковыми в рамках одного файла/проекта). Вот примеры хорошего и плохого кода:

Хорошо

  • Лишь взглянув на код, вы видите, что там внутри функции есть блок if/else.
  • Благодаря последовательности в отступах и расположении скобок легко видеть, где начинаются и кончаются блоки кода.
  • Скобки располагаются последовательно. Обратите внимание, что открывающие скобки function и if расположены одинаково.

Плохо

Вах! А вот здесь много неправильных вещей.

  • Беспорядочные отступы – невозможно сказать, где кончается функция или где начинается блок if/else (да, здесь он есть!).
  • Скобки перемешаны и непоследовательны.
  • Нелогичная разбивка кода на блоки с помощью межстрочного интервала.

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

К счастью, есть множество доступных IDE-плагинов, которые могут автоматически форматировать ваш код. Аллилуйя!

  • VS Code: Prettier
  • Atom: Atom Beautify
  • Sublime Text: Prettify

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №2

Используйте понятные имена для переменных и методов

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

Этот отрывок кода хорош по многим причинам:

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

Бонусный совет: если вы не можете придумать имя для своей функции или метода, есть вероятность, что эта функция делает слишком много всего. Разбейте ее на более мелкие! Например, если ваша функция (исходя из того, что она делает) должна называться updateCarAndSave(), создайте два разных метода: updateCar() и saveCar().

При необходимости используйте комментарии

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

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

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

Просто лишние и бесполезные комментарии:

Забавные или обидные комментарии:

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №3

Дублирующийся код может стать кошмаром в плане поддержки и внесения изменений. Рассмотрим пример.

Допустим, вы на заказ создаете веб-приложение для отдела кадров. Это приложение позволяет админам через API добавлять в базу данных пользователей с указанием их ролей. Есть три вида ролей: сотрудник, менеджер и админ. Давайте рассмотрим несколько функций, которые могут быть при этом:

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №4

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №5

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

Итак, что если нам изменить этот код, чтобы он стал более сфокусированным? Посмотрите на следующий вариант:

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №6

Мы перенесли логику, создающую вызов API, в ее собственный метод saveUserToDatabase(user) (хорошее ли это имя? Вам решать!). Этот метод будут вызывать другие методы, чтобы сохранить пользователя. Теперь, если нам снова нужно будет изменить логику API, нам придется внести правки лишь в один метод. Более того, если нам нужно будет добавить другой метод, создающий пользователей, у нас уже будет готовый метод для сохранения пользователя в базе данных через API. Ура!

Пример рефакторинга с применением полученных знаний

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

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №7

  • Отступы непоследовательны. Не важно, какой именно формат отступов мы используем, главное, чтобы он сохранялся во всем коде.
  • Вторая функция имеет ненужные комментарии. Прочитав имя функции и код внутри нее, мы и без комментариев понимаем, что она делает.
  • В третьей и четвертой функции хромает нейминг. doStuffWithNumbers() это не лучшее имя для функции, к тому же, оно не поясняет, что именно делает эта функция. (x, y) тоже не слишком описательны. Что они из себя представляют? Это функции? Числа? Бананы?
  • Методы делают больше одного действия. Они осуществляют вычисления, но также и отображают результаты. Мы можем выделить логику отображения результатов в отдельный метод, следуя принципу DRY.

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

Пишем чистый и читаемый код: руководство для начинающих разработчиков, изображение №8

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

Поздравляю! Теперь вы можете гордо заявлять на собеседованиях и в своем резюме, что знакомы с принципами написания чистого кода!

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

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


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

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

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

Как писать чистый код?

1. Указывайте имена, говорящие сами за себя

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

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

Что означает переменная с именем dxy? Кто знает. Вам, вероятно, придется прочитать весь код, чтобы хотя бы понять его смысл. Например, значение переменной distanceBetweenXY логически понятно. То же самое верно для классов и функций. Не пишите CalcTan (), если можно написать CalculateTangent () или CalcTangentAngle ().

2. Каждый класс/модуль должен заниматься только одним набором конкретных функций

Вы когда-нибудь разбирали фрагмент кода, который длился сотни или даже тысячи строк? Если у вас есть такой опыт, то вы знаете, насколько это трудно просто прочесть данный код, не говоря уже о его понимании и редактировании. Комментарии, конечно, могут помочь, но они “не вытянут” плохой код.

“Программирование представляет собой разбиение одного большого невозможного таска в несколько мелких вполне возможных.”

— John Woods

Чистый код представляет собой код, разбитый на мелкие части. Где каждая функция должна отвечать только за одну вещь, и каждый класс должен стремиться реализовывать одну конкретную идею. На практике сложный расчет, как GetCreditScore (), следует разбить на несколько вспомогательных функций, таких как GetCreditReports (), ApplyCreditHistoryAge () и FilterOutstandingMarks ().

3. Избавляйтесь от ненужного кода

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

4. Читаемость > Умный код

“Все знают: отладка в два раза сложнее написания первоначального кода. Если вы также умны, как и код, который вы написали, скажите, как его теперь отлаживать? ”

— John Woods

Говоря о чистом коде, оставьте где-то далеко этот „умный” код. Под умным кодом подразумевается тип кода, который больше похож на загадку, чем на решение, и существует только для того, чтобы показать, насколько вы умны. На самом деле, никого это не волнует.

Хороший программист и читаемый код идут рука об руку. Делайте комментарии при такой необходимости. Придерживайтесь определенного стиля, независимо от того, диктуется ли он языком (например, Python) или компанией (например, Google). Наблюдайте за языковыми идиомами и прекратите писать Java-код на Python или наоборот. См. Нашу статью о советах по написанию более чистого кода.

5. Придерживайтесь последовательности в написании кода

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

Но что бы вы ни делали, оставайтесь последовательными!

Если вы собираетесь использовать camelCaseNaming, не используйте тогда underscore_naming. Если вы используете GetThisObject () в одном месте, не используйте FetchThatObject () где-то еще.

6. Выбор правильной архитектуры

“Если опустить требования и дизайн, программирование – это искусство создания багов в пустом текстовом файле.”

— Louis Srygley

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

Шаблон Entity-Component-System (ECS) очень популярен сейчас в разработке игр, потому что он помогает распределить игровые данные по блокам и построить логику таким образом, чтобы упростить работу, при этом создавая код, который легче читать.

7. Изучайте особенности языка

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

“Язык, не влияющий на ваше восприятие процесса программирования, не стоит изучения.”

— Alan J. Perlis

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

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

8. Перенимайте опыт у более опытных программистов

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

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

“Любой дурак может написать код, который компьютер поймет. Хорошие программисты пишут такой код, который будут понимать другие люди.”

— John Woods

9. Оставляйте исчерпывающие комментарии

“Всегда пишите код так, как будто заканчивать за вами проект будет чокнутый садист, который знает, где вы живете.”

— John Woods

Вот хорошее правило: комментарии существуют, чтобы объяснять ДЛЯ ЧЕГО этот кусок кода, а не ЧТО он делает. Чистый код не нужно комментировать, чтобы пояснить, что он делает – комментарий должен пролить свет на причину написания того или иного фрагмента кода.

10. Рефакторинг, рефакторинг и еще раз рефакторинг

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

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

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

Постоянное самосовершенствование и самообразование

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

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

Читайте также: