Clean Code

1. Пишете чист код, който е четим и поддържан

Единственото валидно измерване на качеството на кода: WTFs/минута

Четливостта е от съществено значение. Чистият код трябва да бъде лесно разбираем от другите разработчици. Той трябва да бъде прост, елегантен и без излишни елементи. Стремете се да пишете код, който ясно изразява намерението си, без нужда от обширни коментари. Използвайте смислени имена на променливи и функции, поддържайте функциите малки и фокусирани, и организирайте кода логично.

Поддръжката позволява еволюция. Кодът, който е труден за промяна, става бреме. Проектирайте кода си да бъде гъвкав и модулен, за да може да се адаптира към променящите се изисквания. Следвайте принципи като DRY (Не повтаряйте се) и SOLID, за да създадете слабо свързани, но силно свързани системи. Рефакторирайте безмилостно, за да подобрите структурата на кода, без да променяте поведението.

Чистият код се отплаща. Въпреки че писането на чист код изисква повече усилия в началото, то спестява значително време и главоболия в дългосрочен план. Чистият код е по-лесен за отстраняване на грешки, разширяване и поддръжка. Той позволява на разработчиците да работят по-ефективно и намалява риска от въвеждане на бъгове по време на промени. Направете чистия код основна част от практиката си на разработка.

2. Следвайте смислени конвенции за именуване

Името на променлива, функция или клас трябва да отговаря на всички важни въпроси. То трябва да обяснява защо съществува, какво прави и как се използва.

Използвайте имена, които разкриват намерението. Избирайте имена, които ясно предават целта и поведението на променливи, функции и класове. Избягвайте имена с една буква или криптични съкращения. Използвайте произносими имена, които могат да бъдат лесно търсени. Например:

• Лошо: d (изминало време в дни)
• Добро: elapsedTimeInDays

Бъдете последователни и точни. Използвайте последователни конвенции за именуване в целия код. Бъдете точни, за да избегнете неясноти - например, използвайте смислени различия като getActiveAccounts() и getActiveAccountInfo(). Избягвайте кодировки или префикси, които добавят шум без стойност. Имената на класовете трябва да бъдат съществителни, а имената на методите - глаголи.

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

3. Дръжте функциите малки и фокусирани

Функциите трябва да правят едно нещо. Те трябва да го правят добре. Те трябва да го правят само.

Малкото е красиво. Функциите трябва да са малки - обикновено 5-10 реда. Те трябва да се побират на един екран и да бъдат моментално разбираеми. Извличайте код в добре именувани помощни функции, вместо да пишете дълги, сложни функции. Малките функции са по-лесни за разбиране, тестване и поддръжка.

Правете едно нещо добре. Всяка функция трябва да има една единствена, ясна цел. Ако функцията прави множество неща, извлечете ги в отделни функции. Признаци, че функцията прави твърде много, включват:

• Множество нива на абстракция
• Множество секции или кодови блокове
• Множество параметри

Поддържайте едно ниво на абстракция. Изявленията в рамките на функцията трябва да бъдат на едно и също ниво на абстракция. Не смесвайте логика на високо ниво с детайли на ниско ниво. Извлечете операции на по-ниско ниво в отделни функции. Това подобрява четливостта, като поддържа функциите фокусирани и концептуално прости.

4. Практикувайте правилно форматиране и организация

Форматирането на кода е свързано с комуникацията, а комуникацията е основната задача на професионалния разработчик.

Последователното форматиране е важно. Използвайте последователно отстъп, разчупвания на редове и разстояния в целия код. Това подобрява четливостта и намалява когнитивното натоварване. Съгласувайте стандартите за форматиране с екипа си и използвайте автоматизирани инструменти, за да ги наложите. Основни насоки за форматиране включват:

• Правилен отстъп
• Последователно разположение на скобите
• Логични разчупвания на редовете
• Подходящо разстояние

Организирайте кода логично. Групирайте свързания код заедно и отделяйте несвързания код. Използвайте празни редове, за да създадете "параграфни" паузи между логичните секции. Поставяйте свързани функции близо една до друга. Дръжте файловете фокусирани върху един единствен концепт или компонент. Разделяйте големите файлове на по-малки, по-фокусирани, когато е уместно.

Следвайте стандартни конвенции. Придържайте се към стандартни конвенции за вашия език и общност. Това прави кода ви по-познат и достъпен за другите разработчици. Например, в Java:

• Имената на класовете използват PascalCase
• Имената на методите използват camelCase
• Константите използват ALL_CAPS

5. Управлявайте зависимостите и избягвайте дублирането

Дублирането може да бъде коренът на всичкото зло в софтуера.

Премахнете дублирането. Дублираният код е пропусната възможност за абстракция. Когато видите дублиране, извлечете общия код в повторно използваема функция или клас. Това подобрява поддръжката, като центрира логиката и намалява риска от несъответстващи промени. Внимание към видовете дублиране:

• Идентични кодови блокове
• Подобни алгоритми с малки вариации
• Повторени switch/case или if/else вериги

Внимателно управлявайте зависимостите. Минимизирайте зависимостите между модулите, за да намалите свързаността. Използвайте инжектиране на зависимости и инверсия на контрола, за да направите кода по-модулен и тестван. Следвайте принципа на инверсия на зависимостите - разчитайте на абстракции, а не на конкретики. Това прави кода ви по-гъвкав и по-лесен за промяна.

Използвайте принципа на най-малкото познание. Един модул не трябва да знае за вътрешностите на обектите, които манипулира. Това намалява свързаността между модулите. Например, използвайте Закона на Деметър - методът трябва да извиква методи само на:

• Своя собствен обект
• Обекти, предадени като параметри
• Обекти, които създава
• Преки компоненти на обекта си

6. Обработвайте грешките елегантно

Обработката на грешки е важна, но ако затруднява логиката, е грешна.

Използвайте изключения вместо кодове за грешки. Изключенията са по-чисти и не замърсяват основната логика на кода ви. Те позволяват обработката на грешки да бъде отделена от щастливия път. Когато използвате изключения:

• Създавайте информативни съобщения за грешки
• Осигурявайте контекст с изключения
• Определяйте класове на изключения въз основа на нуждите на извикващия

Не връщайте null. Връщането на null води до изключения с нулеви указатели и замърсява кода с проверки за null. Вместо това:

• Връщайте празни колекции вместо null за списъци
• Използвайте шаблона Null Object
• Използвайте Optional в Java или Maybe в функционални езици

Пишете try-catch-finally изявления първо. Започнете с try-catch-finally, когато пишете код, който може да хвърли изключения. Това помага да се определи обхватът и очакванията за извикващия код. То осигурява правилно управление и освобождаване на ресурси, дори в сценарии на грешки.

7. Пишете задълбочени модулни тестове

Тестовият код е също толкова важен, колкото и производственият код.

Следвайте трите закона на TDD. Разработката, ръководена от тестове (TDD), подобрява качеството и дизайна на кода:

1. Напишете неуспешен тест преди да напишете какъвто и да е производствен код
2. Напишете само толкова от теста, за да демонстрирате неуспех
3. Напишете само толкова производствен код, за да преминете теста

Дръжте тестовете чисти и поддържани. Прилагайте същите стандарти за качество на кода към тестовете си, както и към производствения код. Рефакторирайте и подобрявайте тестовия код редовно. Добре структурираните тестове служат като документация и позволяват безстрашно рефакториране на производствения код.

Стремете се към обширно покритие на тестовете. Пишете тестове, които обхващат крайни случаи, гранични условия и сценарии на грешки - не само щастливия път. Използвайте инструменти за покритие на кода, за да идентифицирате пропуски в покритието на тестовете. Помнете, че 100% покритие не гарантира безгрешен код, но предоставя увереност при рефакториране и промени.

8. Рефакторирайте кода непрекъснато

Оставете къмпинга по-чист, отколкото го намерихте.

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

• Извличане на методи или класове
• Преименуване за яснота
• Оптимизиране на сложни условия
• Премахване на дублиране

Рефакторирайте безопасно с тестове. Винаги имайте солидна тестова среда преди рефакториране. Правете малки, инкрементални промени и стартирайте тестовете често. Това ви дава увереност, че промените ви не нарушават съществуващата функционалност. Използвайте автоматизирани инструменти за рефакториране, когато са налични, за да намалите риска от въвеждане на грешки.

Баланс между рефакториране и предоставяне на стойност. Въпреки че непрекъснатото рефакториране е важно, не позволявайте то да парализира напредъка. Стремете се към "достатъчно добро", а не към съвършенство. Фокусирайте усилията си за рефакториране върху най-проблематичните или често променяни области на кода. Комуникирайте стойността на рефакториране на заинтересованите страни, за да осигурите подкрепа за продължаващото подобряване на кода.

9. Прилагайте принципите на обектно-ориентирано и функционално програмиране

Обектите скриват данните си зад абстракции и излагат функции, които работят с тези данни. Данните структури излагат данните си и нямат смислени функции.

Използвайте принципите на обектно-ориентираното програмиране разумно. Прилагайте принципи като инкапсулация, наследяване и полиморфизъм, за да създадете гъвкави, модулни дизайни. Следвайте принципите SOLID:

• Принцип на единствената отговорност
• Принцип на отвореност-затвореност
• Принцип на заместване на Лисков
• Принцип на разделение на интерфейса
• Принцип на инверсия на зависимостите

Използвайте концепции от функционалното програмиране. Дори в обектно-ориентирани езици, техниките на функционалното програмиране могат да доведат до по-чист код:

• Чисти функции без странични ефекти
• Непроменливи данни
• Функции от по-висок ред
• Съставяне на функции

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

10. Внимателно обмисляйте конкурентността

Конкурентността е стратегия за декуплиране. Тя ни помага да отделим какво се прави от кога се прави.

Разберете предизвикателствата на конкурентността. Конкурентното програмиране въвежда сложност и потенциал за фини грешки. Чести проблеми включват:

• Условия на състезание
• Задръствания
• Пропуснати сигнали
• Проблеми с видимостта на паметта

Отделете проблемите с конкурентността. Дръжте кода, свързан с конкурентността, отделен от другия код. Това улеснява разсъжденията и тестването. Използвайте абстракции като Executors, Futures и Actors, за да управлявате конкурентността, вместо да работите с сурови нишки.

Предпочитайте непроменливост и чисти функции. Непроменливите обекти и чистите функции са по същество безопасни за нишки. Те елиминират много проблеми с конкурентността, като избягват споделено изменяемо състояние. Когато изменяемото състояние е необходимо, използвайте подходящи техники за синхронизация и обмислете използването на атомни променливи или конкурентни колекции.

Последна актуализация: January 22, 2025