Clean Code

1. Scrie cod curat, ușor de citit și de întreținut

Singura măsură validă a calității codului: WTF-uri pe minut

Citibilitatea este esențială. Codul curat trebuie să fie ușor de înțeles de către alți dezvoltatori. Acesta ar trebui să fie simplu, elegant și lipsit de aglomerări. Străduiește-te să scrii cod care își exprimă clar intenția, fără a necesita comentarii extinse. Folosește nume semnificative pentru variabile și funcții, menține funcțiile mici și concentrate și organizează codul logic.

Întreținerea permite evoluția. Codul care este greu de modificat devine o povară. Proiectează-ți codul pentru a fi flexibil și modular, astfel încât să se poată adapta cerințelor în schimbare. Urmează principii precum DRY (Don't Repeat Yourself) și SOLID pentru a crea sisteme slab cuplate și foarte coerente. Refactorizează fără milă pentru a îmbunătăți structura codului fără a schimba comportamentul.

Codul curat aduce beneficii. Deși scrierea codului curat necesită un efort inițial mai mare, economisește timp și dureri de cap semnificative pe termen lung. Codul curat este mai ușor de depanat, extins și întreținut. Acesta permite dezvoltatorilor să lucreze mai eficient și reduce riscul de a introduce erori în timpul modificărilor. Fă din codul curat o parte esențială a practicii tale de dezvoltare.

2. Urmează convenții semnificative de denumire

Numele unei variabile, funcții sau clase ar trebui să răspundă tuturor întrebărilor importante. Ar trebui să îți spună de ce există, ce face și cum este folosit.

Folosește nume care dezvăluie intenția. Alege nume care transmit clar scopul și comportamentul variabilelor, funcțiilor și claselor. Evită numele cu o singură literă sau abrevierile criptice. Folosește nume pronunțabile care pot fi căutate ușor. De exemplu:

• Rău: d (timpul scurs în zile)
• Bun: elapsedTimeInDays

Fii consecvent și precis. Folosește convenții de denumire consistente în întreaga ta bază de cod. Fii precis pentru a evita ambiguitatea - de exemplu, folosește distincții semnificative precum getActiveAccounts() și getActiveAccountInfo(). Evită codificările sau prefixele care adaugă zgomot fără valoare. Numele claselor ar trebui să fie substantive, iar numele metodelor ar trebui să fie verbe.

Lungimea numelui ar trebui să corespundă domeniului. Folosește nume mai lungi și mai descriptive pentru variabile și funcții cu domenii mai mari. Numele scurte sunt acceptabile pentru domenii mici și locale. Lungimea unui nume ar trebui să fie proporțională cu domeniul său de utilizare. Optimizează pentru citibilitate și înțelegere în contextul în care este folosit numele.

3. Menține funcțiile mici și concentrate

Funcțiile ar trebui să facă un singur lucru. Ar trebui să-l facă bine. Ar trebui să-l facă doar.

Micul este frumos. Funcțiile ar trebui să fie mici - de obicei, între 5 și 10 linii lungime. Ele ar trebui să încapă pe un singur ecran și să fie ușor de înțeles. Extrage codul în funcții ajutătoare bine denumite, în loc să scrii funcții lungi și complexe. Funcțiile mici sunt mai ușor de înțeles, testat și întreținut.

Fă un singur lucru bine. Fiecare funcție ar trebui să aibă un singur scop clar. Dacă o funcție face mai multe lucruri, extrage acele lucruri în funcții separate. Semne că o funcție face prea multe includ:

• Mai multe niveluri de abstractizare
• Mai multe secțiuni sau blocuri de cod
• Numeroase parametrii

Menține un singur nivel de abstractizare. Declarațiile dintr-o funcție ar trebui să fie toate la același nivel de abstractizare. Nu amesteca logica de nivel înalt cu detalii de nivel scăzut. Extrage operațiunile de nivel scăzut în funcții separate. Acest lucru îmbunătățește citibilitatea prin menținerea funcțiilor concentrate și conceptual simple.

4. Practică formatarea și organizarea corectă

Formatarea codului este despre comunicare, iar comunicarea este prima prioritate a dezvoltatorului profesionist.

Formatarea consistentă contează. Folosește indentare, întreruperi de linie și spațiere consistente în întregul tău cod. Acest lucru îmbunătățește citibilitatea și reduce sarcina cognitivă. Acordă-te asupra standardelor de formatare cu echipa ta și folosește instrumente automate pentru a le impune. Principalele linii directoare de formatare includ:

• Indentare corectă
• Plasarea consistentă a acoladelor
• Întreuperi logice de linie
• Spațiere adecvată

Organizează codul logic. Grupează codul înrudit împreună și separă codul care nu are legătură. Folosește linii goale pentru a crea "pauze" între secțiunile logice. Plasează funcțiile înrudite aproape una de cealaltă. Menține fișierele concentrate pe un singur concept sau componentă. Împarte fișierele mari în unele mai mici și mai concentrate atunci când este cazul.

Urmărește convențiile standard. Respectă convențiile standard pentru limbajul și comunitatea ta. Acest lucru face ca codul tău să fie mai familiar și accesibil pentru alți dezvoltatori. De exemplu, în Java:

• Numele claselor folosesc PascalCase
• Numele metodelor folosesc camelCase
• Constantele folosesc ALL_CAPS

5. Gestionează dependențele și evită duplicarea

Duplicarea poate fi rădăcina tuturor relelor în software.

Elimină duplicarea. Codul duplicat este o oportunitate ratată pentru abstractizare. Când observi duplicare, extrage codul comun într-o funcție sau clasă reutilizabilă. Acest lucru îmbunătățește întreținerea prin centralizarea logicii și reducerea riscului de modificări inconsistente. Tipuri de duplicare de urmărit:

• Blocuri de cod identice
• Algoritmi similari cu variații minore
• Lanțuri repetate switch/case sau if/else

Gestionează dependențele cu atenție. Minimizează dependențele între module pentru a reduce cuplajul. Folosește injecția de dependență și inversarea controlului pentru a face codul mai modular și testabil. Urmează Principiul Inversării Dependenței - depinde de abstractizări, nu de concretizări. Acest lucru face ca codul tău să fie mai flexibil și mai ușor de modificat.

Folosește principiul cunoștințelor minime. Un modul nu ar trebui să știe despre detaliile interne ale obiectelor pe care le manipulează. Acest lucru reduce cuplajul între module. De exemplu, folosește Legea lui Demeter - o metodă ar trebui să apeleze doar metodele pe:

• Obiectul său propriu
• Obiectele transmise ca parametri
• Obiectele pe care le creează
• Obiectele sale componente directe

6. Gestionează erorile cu grație

Gestionarea erorilor este importantă, dar dacă obfuscă logica, este greșită.

Folosește excepții în loc de coduri de eroare. Excepțiile sunt mai curate și nu aglomerează logica principală a codului tău. Ele permit gestionarea erorilor să fie separată de calea fericită. Când folosești excepții:

• Creează mesaje de eroare informative
• Oferă context cu excepțiile
• Definește clase de excepții în funcție de nevoile apelantului

Nu returna null. Returnarea null-ului duce la excepții de tip null pointer și aglomerează codul cu verificări de null. În schimb:

• Returnează colecții goale în loc de null pentru liste
• Folosește modelul Null Object
• Folosește Optional în Java sau Maybe în limbajele funcționale

Scrie declarații try-catch-finally mai întâi. Începe cu try-catch-finally atunci când scrii cod care ar putea arunca excepții. Acest lucru ajută la definirea domeniului și a așteptărilor pentru codul apelant. Asigură-te că resursele sunt gestionate și eliberate corespunzător, chiar și în scenariile de eroare.

7. Scrie teste unitare complete

Codul de testare este la fel de important ca și codul de producție.

Urmărește cele trei legi ale TDD. Dezvoltarea condusă de teste (TDD) îmbunătățește calitatea și designul codului:

1. Scrie un test eșuat înainte de a scrie orice cod de producție
2. Scrie doar suficient dintr-un test pentru a demonstra o eșec
3. Scrie doar suficient cod de producție pentru a trece testul

Menține testele curate și întreținute. Aplică aceleași standarde de calitate a codului la testele tale ca și la codul de producție. Refactorizează și îmbunătățește codul de testare regulat. Testele bine structurate servesc ca documentație și permit refactorizarea fără frică a codului de producție.

Vizează o acoperire cuprinzătoare a testelor. Scrie teste care acoperă cazuri limită, condiții de frontieră și scenarii de eroare - nu doar calea fericită. Folosește instrumente de acoperire a codului pentru a identifica lacunele în acoperirea testelor. Amintește-ți că 100% acoperire nu garantează cod fără erori, dar oferă încredere în refactorizare și modificări.

8. Refactorizează codul continuu

Lasă tabăra mai curată decât ai găsit-o.

Refactorizează oportunist. Îmbunătățește structura codului ori de câte ori lucrezi la o bucată de cod. Urmează Regula Scoutului: lasă codul mai bun decât l-ai găsit. Îmbunătățirile mici și incrementale se adună în timp și previn degradarea codului. Tehnici comune de refactorizare includ:

• Extracția metodelor sau claselor
• Schimbarea numelui pentru claritate
• Simplificarea condițiilor complexe
• Eliminarea duplicării

Refactorizează în siguranță cu teste. Asigură-te că ai o suită solidă de teste înainte de a refactoriza. Fă modificări mici și incrementale și rulează teste frecvent. Acest lucru îți oferă încredere că modificările tale nu rup funcționalitatea existentă. Folosește instrumente automate de refactorizare atunci când sunt disponibile pentru a reduce riscul de a introduce erori.

Echilibrează refactorizarea cu livrarea de valoare. Deși refactorizarea continuă este importantă, nu lăsa să te paralizeze progresul. Vizează "suficient de bun" în loc de perfecțiune. Concentrează-te pe eforturile de refactorizare în cele mai problematice sau frecvent modificate zone ale codului. Comunică valoarea refactorizării părților interesate pentru a asigura suportul pentru îmbunătățirea continuă a codului.

9. Aplică principii de programare orientată pe obiect și funcțională

Obiectele își ascund datele în spatele abstractizărilor și expun funcții care operează asupra acelor date. Structurile de date își expun datele și nu au funcții semnificative.

Folosește principiile orientate pe obiect cu înțelepciune. Aplică principii precum încapsularea, moștenirea și polimorfismul pentru a crea designuri flexibile și modulare. Urmează principiile SOLID:

• Principiul responsabilității unice
• Principiul deschis-închis
• Principiul substituției Liskov
• Principiul segregării interfețelor
• Principiul inversării dependenței

Valorifică conceptele de programare funcțională. Chiar și în limbajele orientate pe obiect, tehnicile de programare funcțională pot duce la cod mai curat:

• Funcții pure fără efecte secundare
• Date imuabile
• Funcții de ordin superior
• Compoziția funcțiilor

Alege abordarea potrivită pentru problemă. Paradigmele orientate pe obiect și funcționale au fiecare puncte forte și slabe. Folosește designul orientat pe obiect atunci când trebuie să modelezi domenii complexe cu comportament. Folosește abordări funcționale pentru transformarea datelor și pipeline-uri de procesare. Multe limbaje moderne suportă o abordare hibridă, permițându-ți să folosești cel mai bun instrument pentru fiecare parte a sistemului tău.

10. Consideră cu atenție concurența

Concurența este o strategie de decuplare. Ne ajută să decuplăm ce se face de când se face.

Înțelege provocările concurenței. Programarea concurentă introduce complexitate și potențial pentru erori subtile. Problemele comune includ:

• Condiții de cursă
• Blocaje
• Semnale ratate
• Probleme de vizibilitate a memoriei

Separă preocupările legate de concurență. Păstrează codul tău legat de concurență separat de alte coduri. Acest lucru face mai ușor de raționat și testat. Folosește abstractizări precum Executors, Futures și Actors pentru a gestiona concurența, în loc să lucrezi cu fire brute.

Preferă imuabilitatea și funcțiile pure. Obiectele imuabile și funcțiile pure sunt în mod inerent sigure pentru fire. Ele elimină multe probleme de concurență prin evitarea stării mutable partajate. Atunci când starea mutable este necesară, folosește tehnici de sincronizare corespunzătoare și ia în considerare utilizarea variabilelor atomice sau a colecțiilor concurente.

Ultima actualizare: January 22, 2025