Clean Code

1. Skriv ren kode, der er læsbar og vedligeholdelsesvenlig

Den eneste gyldige måling af kodekvalitet: WTFs/minut

Læselighed er altafgørende. Ren kode skal være let at forstå for andre udviklere. Den skal være simpel, elegant og fri for rod. Stræb efter at skrive kode, der klart udtrykker sin hensigt uden behov for omfattende kommentarer. Brug meningsfulde variabel- og funktionsnavne, hold funktioner små og fokuserede, og organiser koden logisk.

Vedligeholdelse muliggør udvikling. Kode, der er svær at ændre, bliver en byrde. Design din kode til at være fleksibel og modulær, så den kan tilpasse sig ændrede krav. Følg principper som DRY (Don't Repeat Yourself) og SOLID for at skabe løst koblede, højt sammenhængende systemer. Refaktorer ubarmhjertigt for at forbedre kode-strukturen uden at ændre adfærd.

Ren kode betaler sig. Selvom det kræver mere indsats at skrive ren kode i starten, sparer det betydelig tid og hovedpine på længere sigt. Ren kode er lettere at fejlfinde, udvide og vedligeholde. Det gør det muligt for udviklere at arbejde mere effektivt og reducerer risikoen for at introducere fejl under ændringer. Gør ren kode til en kernekomponent i din udviklingspraksis.

2. Følg meningsfulde navngivningskonventioner

Navnet på en variabel, funktion eller klasse skal besvare alle de store spørgsmål. Det skal fortælle dig, hvorfor det eksisterer, hvad det gør, og hvordan det bruges.

Brug intention-afslørende navne. Vælg navne, der klart formidler formålet og adfærden af variabler, funktioner og klasser. Undgå enkeltbogstavnavne eller kryptiske forkortelser. Brug udtalelige navne, der nemt kan søges. For eksempel:

• Dårligt: d (forløbet tid i dage)
• Godt: elapsedTimeInDays

Vær konsekvent og præcis. Brug konsekvente navngivningskonventioner i hele din kodebase. Vær præcis for at undgå tvetydighed - for eksempel, brug meningsfulde forskelle som getActiveAccounts() og getActiveAccountInfo(). Undgå kodninger eller præfikser, der tilføjer støj uden værdi. Klassenavne skal være substantiver, metode-navne skal være verber.

Navnelængde skal matche omfang. Brug længere, mere beskrivende navne til variabler og funktioner med større omfang. Korte navne er acceptable for små, lokale omfang. Længden af et navn skal være proportional med dets anvendelsesområde. Optimer for læsbarhed og forståelse inden for den kontekst, hvor navnet bruges.

3. Hold funktioner små og fokuserede

Funktioner skal gøre én ting. De skal gøre det godt. De skal kun gøre det.

Små er smukke. Funktioner skal være små - typisk 5-10 linjer lange. De skal kunne være på én skærm og være lette at forstå. Udtræk kode til velnavngivne hjælpefunktioner i stedet for at skrive lange, komplekse funktioner. Små funktioner er lettere at forstå, teste og vedligeholde.

Gør én ting godt. Hver funktion skal have et enkelt, klart formål. Hvis en funktion gør flere ting, skal du udtrække disse til separate funktioner. Tegn på, at en funktion gør for meget inkluderer:

• Flere niveauer af abstraktion
• Flere sektioner eller kodeblokke
• Talrige parametre

Vedligehold ét niveau af abstraktion. Udsagnene inden for en funktion skal alle være på samme niveau af abstraktion. Bland ikke høj-niveau logik med lav-niveau detaljer. Udtræk lavere niveau operationer til separate funktioner. Dette forbedrer læsbarheden ved at holde funktioner fokuserede og konceptuelt enkle.

4. Praktiser korrekt formatering og organisering

Kodeformatering handler om kommunikation, og kommunikation er den professionelle udviklers første prioritet.

Konsistent formatering betyder noget. Brug konsekvent indrykning, linjeskift og mellemrum i hele din kode. Dette forbedrer læsbarheden og reducerer den kognitive belastning. Aftal formateringsstandarder med dit team og brug automatiserede værktøjer til at håndhæve dem. Nøgleformateringsretningslinjer inkluderer:

• Korrekt indrykning
• Konsistent placering af klammer
• Logiske linjeskift
• Passende mellemrum

Organiser koden logisk. Grupper relateret kode sammen og adskil urelateret kode. Brug blanke linjer til at skabe "afsnit" mellem logiske sektioner. Placer relaterede funktioner tæt på hinanden. Hold filer fokuseret på et enkelt koncept eller komponent. Opdel store filer i mindre, mere fokuserede, når det er passende.

Følg standardkonventioner. Overhold standardkonventioner for dit sprog og samfund. Dette gør din kode mere velkendt og tilgængelig for andre udviklere. For eksempel, i Java:

• Klassenavne bruger PascalCase
• Metodenavne bruger camelCase
• Konstanter bruger ALL_CAPS

5. Håndter afhængigheder og undgå duplikation

Duplikation kan være roden til alt ondt i software.

Eliminer duplikation. Duplikeret kode er en tabt mulighed for abstraktion. Når du ser duplikation, skal du udtrække den fælles kode til en genanvendelig funktion eller klasse. Dette forbedrer vedligeholdelsen ved at centralisere logik og reducere risikoen for inkonsistente ændringer. Typer af duplikation, du skal være opmærksom på:

• Identiske kodeblokke
• Lignende algoritmer med små variationer
• Gentagne switch/case eller if/else kæder

Håndter afhængigheder omhyggeligt. Minimer afhængigheder mellem moduler for at reducere kobling. Brug afhængighedsinjektion og kontrolinversion for at gøre koden mere modulær og testbar. Følg princippet om afhængighedsinversion - afhængig af abstraktioner, ikke konkretiseringer. Dette gør din kode mere fleksibel og lettere at ændre.

Brug princippet om mindst viden. Et modul bør ikke vide om indholdet af de objekter, det manipulerer. Dette reducerer koblingen mellem moduler. For eksempel, brug Demeter-loven - en metode bør kun kalde metoder på:

• Sit eget objekt
• Objekter, der sendes som parametre
• Objekter, det opretter
• Dens direkte komponentobjekter

6. Håndter fejl elegant

Fejlbehandling er vigtig, men hvis den skjuler logik, er den forkert.

Brug undtagelser frem for fejlkoder. Undtagelser er renere og roder ikke hovedlogikken i din kode. De tillader, at fejlbehandling adskilles fra den glade sti. Når du bruger undtagelser:

• Opret informative fejlinformationer
• Giv kontekst med undtagelser
• Definer undtagelsesklasser baseret på kalders behov

Returner ikke null. At returnere null fører til null-pointer undtagelser og roder koden med null-tjek. I stedet:

• Returner tomme samlinger i stedet for null for lister
• Brug Null Object-mønsteret
• Brug Optional i Java eller Maybe i funktionelle sprog

Skriv try-catch-finally udsagn først. Start med try-catch-finally, når du skriver kode, der kan kaste undtagelser. Dette hjælper med at definere omfanget og forventningerne til den kaldende kode. Det sikrer, at ressourcer håndteres og frigives korrekt, selv i fejlscenarier.

7. Skriv grundige enhedstest

Testkode er lige så vigtig som produktionskode.

Følg de tre love om TDD. Testdrevet udvikling (TDD) forbedrer kodekvalitet og design:

1. Skriv en fejlslagende test, før du skriver nogen produktionskode
2. Skriv kun nok af en test for at demonstrere en fejl
3. Skriv kun nok produktionskode til at bestå testen

Hold tests ren og vedligeholdelsesvenlig. Anvend de samme standarder for kodekvalitet på dine tests som på din produktionskode. Refaktorer og forbedr testkode regelmæssigt. Velstrukturerede tests fungerer som dokumentation og muliggør frygtløs refaktorering af produktionskode.

Sigte efter omfattende testdækning. Skriv tests, der dækker kanttilfælde, grænseforhold og fejlscenarier - ikke kun den glade sti. Brug kode-dækningsværktøjer til at identificere huller i testdækningen. Husk, at 100% dækning ikke garanterer fejlfri kode, men det giver tillid til refaktorering og ændringer.

8. Refaktorer kode kontinuerligt

Efterlad campingpladsen renere, end du fandt den.

Refaktorer opportunistisk. Forbedr kode-strukturen, når du arbejder på et stykke kode. Følg Boy Scout-reglen: efterlad koden bedre, end du fandt den. Små, inkrementelle forbedringer samler sig over tid og forhindrer kodeforringelse. Almindelige refaktoreringsmetoder inkluderer:

• Udtrækning af metoder eller klasser
• Omdøbning for klarhed
• Forenkling af komplekse betingelser
• Fjernelse af duplikation

Refaktorer sikkert med tests. Hav altid et solidt testsuite, før du refaktorerer. Foretag små, inkrementelle ændringer og kør tests ofte. Dette giver dig tillid til, at dine ændringer ikke bryder eksisterende funktionalitet. Brug automatiserede refaktoreringsværktøjer, når de er tilgængelige, for at reducere risikoen for at introducere fejl.

Balancér refaktorisering med at levere værdi. Selvom kontinuerlig refaktorisering er vigtig, må du ikke lade det lamme fremskridt. Sigte efter "godt nok" frem for perfektion. Fokuser refaktoreringsindsatsen på de mest problematiske eller ofte ændrede områder af koden. Kommuniker værdien af refaktorisering til interessenter for at sikre støtte til løbende kodeforbedring.

9. Anvend objektorienterede og funktionelle programmeringsprincipper

Objekter skjuler deres data bag abstraktioner og eksponerer funktioner, der opererer på disse data. Datastrukturer eksponerer deres data og har ingen meningsfulde funktioner.

Brug objektorienterede principper klogt. Anvend principper som indkapsling, arv og polymorfi for at skabe fleksible, modulære designs. Følg SOLID-principperne:

• Enkeltansvarsprincippet
• Åben-lukket princippet
• Liskov substitutionsprincippet
• Interface-segregeringsprincippet
• Afhængighedsinversionsprincippet

Udnyt funktionelle programmeringskoncepter. Selv i objektorienterede sprog kan funktionelle programmeringsteknikker føre til renere kode:

• Rene funktioner uden bivirkninger
• Uforanderlige data
• Højere ordens funktioner
• Funktionskomposition

Vælg den rigtige tilgang til problemet. Objektorienterede og funktionelle paradigmer har hver deres styrker og svagheder. Brug objektorienteret design, når du skal modellere komplekse domæner med adfærd. Brug funktionelle tilgange til datatransformation og behandlingspipelines. Mange moderne sprog understøtter en hybrid tilgang, der giver dig mulighed for at bruge det bedste værktøj til hver del af dit system.

10. Overvej samtidighed omhyggeligt

Samtidighed er en afkoblingsstrategi. Det hjælper os med at adskille, hvad der bliver gjort fra hvornår det bliver gjort.

Forstå samtidighedsudfordringer. Samtidig programmering introducerer kompleksitet og potentiale for subtile fejl. Almindelige problemer inkluderer:

• Race conditions
• Deadlocks
• Miste signaler
• Problemer med hukommelses synlighed

Adskil samtidighedsproblemer. Hold din samtidighedsrelaterede kode adskilt fra anden kode. Dette gør det lettere at ræsonnere om og teste. Brug abstraktioner som Executors, Futures og Actors til at håndtere samtidighed i stedet for at arbejde med rå tråde.

Foretræk uforanderlighed og rene funktioner. Uforanderlige objekter og rene funktioner er iboende tråd-sikre. De eliminerer mange samtidighedsproblemer ved at undgå delt, ændrbar tilstand. Når ændrbar tilstand er nødvendig, skal du bruge passende synkroniseringsteknikker og overveje at bruge atomare variabler eller samtidige samlinger.

Last updated: January 22, 2025