Clean Code

1. Írj tiszta, olvasható és karbantartható kódot

A kódminőség egyetlen érvényes mérése: WTFs/perc

Az olvashatóság elsődleges. A tiszta kódot más fejlesztőknek könnyen érthetőnek kell lennie. Egyszerűnek, elegánsnak és zűrzavartól mentesnek kell lennie. Törekedj arra, hogy olyan kódot írj, amely világosan kifejezi a szándékát, anélkül, hogy kiterjedt megjegyzésekre lenne szükség. Használj jelentőségteljes változó- és függvényneveket, tartsd a függvényeket kicsinek és fókuszáltnak, és logikusan szervezd meg a kódot.

A karbantarthatóság lehetővé teszi az evolúciót. Az a kód, amelyet nehéz megváltoztatni, felelősséggé válik. Tervezd meg a kódodat rugalmasan és modulárisan, hogy alkalmazkodni tudjon a változó követelményekhez. Kövesd az olyan elveket, mint a DRY (Ne ismételd meg magad) és a SOLID, hogy lazán összekapcsolt, magasan kohéziós rendszereket hozz létre. Ne habozz refaktorálni, hogy javítsd a kód struktúráját anélkül, hogy megváltoztatnád a viselkedést.

A tiszta kód megtérül. Bár a tiszta kód írása kezdetben több erőfeszítést igényel, hosszú távon jelentős időt és fejfájást takarít meg. A tiszta kód könnyebben hibakereshető, bővíthető és karbantartható. Lehetővé teszi a fejlesztők számára, hogy hatékonyabban dolgozzanak, és csökkenti a hibák bevezetésének kockázatát a változtatások során. Tedd a tiszta kódot a fejlesztési gyakorlatod alapvető részévé.

2. Kövesd a jelentőségteljes elnevezési konvenciókat

Egy változó, függvény vagy osztály neve minden fontos kérdésre választ kell adjon. Meg kell mondania, miért létezik, mit csinál, és hogyan használják.

Használj szándékot kifejező neveket. Válassz olyan neveket, amelyek világosan közvetítik a változók, függvények és osztályok célját és viselkedését. Kerüld az egybetűs neveket vagy titkos rövidítéseket. Használj kiejthető neveket, amelyeket könnyen kereshetsz. Például:

• Rossz: d (eltelt idő napokban)
• Jó: elapsedTimeInDays

Légy következetes és precíz. Használj következetes elnevezési konvenciókat a kódodban. Légy precíz, hogy elkerüld az ambiguítást - például használj jelentős megkülönböztetéseket, mint a getActiveAccounts() és a getActiveAccountInfo(). Kerüld az olyan kódolásokat vagy előtagokat, amelyek zajt adnak hozzá érték nélkül. Az osztálynevek főnevek legyenek, a metódusnevek igék.

A név hossza illeszkedjen a terjedelemhez. Használj hosszabb, leíró neveket a nagyobb terjedelmű változók és függvények esetén. Rövid nevek elfogadhatók a kis, helyi terjedelmekhez. A név hossza arányos legyen a használati terjedelmével. Optimalizálj az olvashatóság és a megértés érdekében abban a kontextusban, ahol a nevet használják.

3. Tartsd a függvényeket kicsinek és fókuszáltnak

A függvényeknek egy dolgot kell csinálniuk. Azt jól kell csinálniuk. Csak azt.

A kicsi szép. A függvényeknek kicsiknek kell lenniük - jellemzően 5-10 sor hosszúak. Egy képernyőre kell férniük, és azonnal érthetőnek kell lenniük. Kódot jól elnevezett segédfüggvényekbe kell kiemelni, ahelyett, hogy hosszú, bonyolult függvényeket írnál. A kis függvények könnyebben érthetők, tesztelhetők és karbantarthatók.

Csak egy dolgot csinálj jól. Minden függvénynek egyetlen, világos célja kell, hogy legyen. Ha egy függvény több dolgot csinál, azokat külön függvényekbe kell kiemelni. Azt jelzi, hogy egy függvény túl sokat csinál, ha:

• Több absztrakciós szintet tartalmaz
• Több szakasz vagy kódrészlet van
• Számos paramétert használ

Tartsd meg az egy szintű absztrakciót. A függvényen belüli állításoknak mind ugyanazon absztrakciós szinten kell lenniük. Ne keverd a magas szintű logikát az alacsony szintű részletekkel. Az alacsonyabb szintű műveleteket külön függvényekbe kell kiemelni. Ez javítja az olvashatóságot azáltal, hogy a függvényeket fókuszáltan és konceptuálisan egyszerűen tartja.

4. Gyakorold a megfelelő formázást és szervezést

A kódformázás a kommunikációról szól, és a kommunikáció a professzionális fejlesztő elsődleges feladata.

A következetes formázás fontos. Használj következetes behúzást, sortöréseket és térközöket a kódodban. Ez javítja az olvashatóságot és csökkenti a kognitív terhelést. Állapodj meg a csapatoddal a formázási szabványokról, és használj automatizált eszközöket azok érvényesítésére. A kulcsformázási irányelvek közé tartozik:

• Megfelelő behúzás
• Következetes zárójelek elhelyezése
• Logikus sortörések
• Megfelelő fehér tér

Szervezd logikusan a kódot. Csoportosítsd a kapcsolódó kódokat együtt, és válaszd el azokat, amelyek nem kapcsolódnak egymáshoz. Használj üres sorokat a "bekezdés" törések létrehozásához a logikai szakaszok között. Helyezd a kapcsolódó függvényeket egymás közelébe. Tartsd a fájlokat egyetlen koncepcióra vagy komponensre fókuszálva. Nagy fájlokat bonts le kisebb, fókuszáltabb fájlokra, ha szükséges.

Kövesd a standard konvenciókat. Tartsd be a nyelved és közösséged standard konvencióit. Ez ismerősebbé és hozzáférhetőbbé teszi a kódodat más fejlesztők számára. Például Java esetén:

• Az osztálynevek PascalCase-t használnak
• A metódusnevek camelCase-t használnak
• Az állandók ALL_CAPS-t használnak

5. Kezeld a függőségeket és kerüld a duplikációt

A duplikáció lehet a szoftverek minden rosszának gyökere.

Szüntesd meg a duplikációt. A duplikált kód egy kihagyott lehetőség az absztrakcióra. Amikor duplikációt látsz, emeld ki a közös kódot egy újrahasználható függvénybe vagy osztályba. Ez javítja a karbantarthatóságot azáltal, hogy központosítja a logikát és csökkenti az inkonzisztens változtatások kockázatát. A figyelendő duplikáció típusai:

• Azonos kódrészletek
• Hasonló algoritmusok enyhe eltérésekkel
• Ismételt switch/case vagy if/else láncok

Kezeld a függőségeket gondosan. Minimalizáld a modulok közötti függőségeket a kapcsolódás csökkentése érdekében. Használj függőséginjekciót és vezérlésinverziót, hogy a kód modulárisabb és tesztelhetőbb legyen. Kövesd a Függőséginverziós Elvet - absztrakciókra támaszkodj, ne konkrétumokra. Ez rugalmasabbá és könnyebben változtathatóvá teszi a kódodat.

Használj minimális tudás elvét. Egy modulnak nem szabad tudnia az általa manipulált objektumok belső működéséről. Ez csökkenti a modulok közötti kapcsolódást. Például használd a Demeter törvényt - egy metódusnak csak az alábbi objektumok metódusait szabad hívnia:

• A saját objektumát
• Az átadott paraméterként kapott objektumokat
• Az általa létrehozott objektumokat
• A közvetlen komponens objektumait

6. Kezeld a hibákat elegánsan

A hiba kezelés fontos, de ha elhomályosítja a logikát, akkor rossz.

Használj kivételeket a hiba kódok helyett. A kivételek tisztábbak, és nem zavarják a kód fő logikáját. Lehetővé teszik a hiba kezelésének elkülönítését a boldog úttól. Kivételek használatakor:

• Készíts informatív hibaüzeneteket
• Adj kontextust a kivételekhez
• Határozz meg kivétel osztályokat a hívó igényei alapján

Ne adj vissza nullát. A null visszaadása null pointer kivételekhez vezet, és zavarossá teszi a kódot a null ellenőrzésekkel. Ehelyett:

• Visszaadhatsz üres gyűjteményeket null helyett listák esetén
• Használj Null Object mintát
• Használj Optional-t Java-ban vagy Maybe-t funkcionális nyelvekben

Írd a try-catch-finally állításokat először. Kezdj a try-catch-finally-vel, amikor olyan kódot írsz, amely kivételeket dobhat. Ez segít meghatározni a hatókört és az elvárásokat a hívó kód számára. Biztosítja, hogy az erőforrásokat megfelelően kezeljék és felszabadítsák, még hiba esetén is.

7. Írj alapos egységteszteket

A tesztkód éppolyan fontos, mint a termelési kód.

Kövesd a TDD három törvényét. A Teszt-vezérelt Fejlesztés (TDD) javítja a kód minőségét és tervezését:

1. Írj egy hibás tesztet, mielőtt bármilyen termelési kódot írnál
2. Írj csak annyit a tesztből, hogy demonstrálja a hibát
3. Írj csak annyit a termelési kódból, hogy a tesztet átmenjen

Tartsd a teszteket tisztán és karbantarthatónak. Alkalmazd a kódminőség ugyanazokat a szabványait a tesztjeidre, mint a termelési kódodra. Refaktoráld és javítsd a tesztkódot rendszeresen. A jól struktúrált tesztek dokumentációként szolgálnak, és lehetővé teszik a termelési kód félelem nélküli refaktorálását.

Cél a széleskörű tesztlefedettség. Írj teszteket, amelyek lefedik a szélsőséges eseteket, határfeltételeket és hibahelyzeteket - nem csak a boldog utat. Használj kódlefedettségi eszközöket a tesztlefedettség hiányosságainak azonosítására. Ne feledd, hogy a 100%-os lefedettség nem garantálja a hibamentes kódot, de bizalmat ad a refaktorálásban és a változtatásokban.

8. Refaktoráld a kódot folyamatosan

Hagyj a táborhelyen tisztábban, mint ahogy találtad.

Refaktorálj opportunisztikusan. Javítsd a kód struktúráját, amikor csak egy darab kódon dolgozol. Kövesd a Boy Scout Szabályt: hagyd a kódot jobban, mint ahogy találtad. A kis, fokozatos javítások idővel összeadódnak, és megakadályozzák a kód elöregedését. A gyakori refaktorálási technikák közé tartozik:

• Metódusok vagy osztályok kiemelése
• Nevek átnevezése a világosság érdekében
• Bonyolult feltételek egyszerűsítése
• Duplikáció eltávolítása

Refaktorálj biztonságosan tesztekkel. Mindig legyen egy szilárd tesztcsomagod a refaktorálás előtt. Végezzen kis, fokozatos változtatásokat, és futtasd a teszteket gyakran. Ez bizalmat ad abban, hogy a változtatásaid nem törik meg a meglévő funkciókat. Használj automatizált refaktoráló eszközöket, amikor csak lehetséges, hogy csökkentsd a hibák bevezetésének kockázatát.

Egyensúlyozd a refaktorálást az érték szállításával. Bár a folyamatos refaktorálás fontos, ne hagyd, hogy megbénítsa a haladást. Cél a "megfelelő" helyett a tökéletesség. A refaktorálási erőfeszítéseket a legproblémásabb vagy leggyakrabban változó kódterületekre összpontosítsd. Kommunikáld a refaktorálás értékét az érdekelt felek felé, hogy biztosítsd a folyamatos kódjavítás támogatását.

9. Alkalmazd az objektum-orientált és funkcionális programozási elveket

Az objektumok elrejtik az adataikat absztrakciók mögött, és olyan függvényeket kínálnak, amelyek azokon az adatokon működnek. Az adatszerkezetek felfedik az adataikat, és nincsenek jelentős funkcióik.

Használj objektum-orientált elveket bölcsen. Alkalmazd az olyan elveket, mint az enkapszuláció, öröklődés és polimorfizmus, hogy rugalmas, moduláris terveket hozz létre. Kövesd a SOLID elveket:

• Egységes Felelősség Elve
• Nyitott-Zárt Elve
• Liskov Helyettesítési Elve
• Interfész Szegregációs Elve
• Függőséginverziós Elve

Használj funkcionális programozási fogalmakat. Még objektum-orientált nyelvekben is a funkcionális programozási technikák tisztább kódhoz vezethetnek:

• Tiszta függvények mellékhatások nélkül
• Immutable adatok
• Magasabb rendű függvények
• Függvénykompozíció

Válaszd ki a megfelelő megközelítést a problémához. Az objektum-orientált és funkcionális paradigmák egyaránt rendelkeznek erősségekkel és gyengeségekkel. Használj objektum-orientált tervezést, amikor bonyolult domainokat kell modellezni viselkedéssel. Használj funkcionális megközelítéseket az adatok átalakítására és feldolgozási csövekre. Sok modern nyelv támogatja a hibrid megközelítést, lehetővé téve, hogy a rendszer minden részéhez a legjobb eszközt használd.

10. Gondolj a párhuzamosságra gondosan

A párhuzamosság

Utoljára frissítve: January 22, 2025