Clean Code

1. Skriv ren kod som är läsbar och underhållbar

Den enda giltiga mätningen av kodkvalitet: WTFs/minut

Läsbarhet är avgörande. Ren kod ska vara lätt att förstå för andra utvecklare. Den ska vara enkel, elegant och fri från onödig komplexitet. Sträva efter att skriva kod som tydligt uttrycker sin avsikt utan behov av omfattande kommentarer. Använd meningsfulla variabel- och funktionsnamn, håll funktioner små och fokuserade, och organisera koden logiskt.

Underhållbarhet möjliggör evolution. Kod som är svår att ändra blir en belastning. Designa din kod för att vara flexibel och modulär så att den kan anpassas till förändrade krav. Följ principer som DRY (Don't Repeat Yourself) och SOLID för att skapa löst kopplade, högkohesiva system. Refaktorisera obarmhärtigt för att förbättra kodstrukturen utan att ändra beteendet.

Ren kod lönar sig. Även om det tar mer tid att skriva ren kod i början, sparar det betydande tid och huvudvärk på lång sikt. Ren kod är lättare att felsöka, utöka och underhålla. Den gör det möjligt för utvecklare att arbeta mer effektivt och minskar risken för att introducera buggar vid förändringar. Gör ren kod till en kärnkomponent i din utvecklingspraxis.

2. Följ meningsfulla namngivningskonventioner

Namnet på en variabel, funktion eller klass bör besvara alla stora frågor. Det ska berätta varför det finns, vad det gör och hur det används.

Använd avsiktsavslöjande namn. Välj namn som tydligt förmedlar syftet och beteendet hos variabler, funktioner och klasser. Undvik enstaka bokstavsnamn eller kryptiska förkortningar. Använd uttalbara namn som enkelt kan sökas. Till exempel:

• Dåligt: d (förfluten tid i dagar)
• Bra: elapsedTimeInDays

Var konsekvent och precis. Använd konsekventa namngivningskonventioner genom hela din kodbas. Var precis för att undvika tvetydighet - till exempel, använd meningsfulla distinktioner som getActiveAccounts() och getActiveAccountInfo(). Undvik kodningar eller prefix som tillför brus utan värde. Klassnamn ska vara substantiv, metodnamn ska vara verb.

Namnets längd bör matcha omfattningen. Använd längre, mer beskrivande namn för variabler och funktioner med större omfattningar. Korta namn är acceptabla för små, lokala omfattningar. Längden på ett namn bör vara proportionell mot dess användningsområde. Optimera för läsbarhet och förståelse inom den kontext där namnet används.

3. Håll funktioner små och fokuserade

Funktioner ska göra en sak. De ska göra det bra. De ska göra det endast.

Små är vackert. Funktioner ska vara små - typiskt 5-10 rader långa. De ska få plats på en skärm och vara omedelbart begripliga. Extrahera kod till väl namngivna hjälpfunktioner istället för att skriva långa, komplexa funktioner. Små funktioner är lättare att förstå, testa och underhålla.

Gör en sak bra. Varje funktion ska ha ett enda, klart syfte. Om en funktion gör flera saker, extrahera dessa till separata funktioner. Tecken på att en funktion gör för mycket inkluderar:

• Flera abstraktionsnivåer
• Flera sektioner eller kodblock
• Många parametrar

Upprätthåll en nivå av abstraktion. Uttalandena inom en funktion ska alla vara på samma abstraktionsnivå. Blanda inte hög nivå logik med lågnivådetaljer. Extrahera lägre nivåoperationer till separata funktioner. Detta förbättrar läsbarheten genom att hålla funktioner fokuserade och konceptuellt enkla.

4. Praktisera korrekt formatering och organisering

Kodformatering handlar om kommunikation, och kommunikation är den professionella utvecklarens första prioritet.

Konsekvent formatering spelar roll. Använd konsekvent indragning, radbrytningar och mellanrum genom hela din kod. Detta förbättrar läsbarheten och minskar den kognitiva belastningen. Kom överens om formateringsstandarder med ditt team och använd automatiserade verktyg för att upprätthålla dem. Viktiga formateringsriktlinjer inkluderar:

• Korrekt indragning
• Konsekvent placering av klamrar
• Logiska radbrytningar
• Lämpligt vitt utrymme

Organisera koden logiskt. Gruppera relaterad kod tillsammans och separera orelaterad kod. Använd tomma rader för att skapa "stycke" pauser mellan logiska sektioner. Placera relaterade funktioner nära varandra. Håll filer fokuserade på ett enda koncept eller komponent. Dela stora filer i mindre, mer fokuserade när det är lämpligt.

Följ standardkonventioner. Håll dig till standardkonventioner för ditt språk och din gemenskap. Detta gör din kod mer bekant och tillgänglig för andra utvecklare. Till exempel, i Java:

• Klassnamn använder PascalCase
• Metodnamn använder camelCase
• Konstanter använder ALL_CAPS

5. Hantera beroenden och undvik duplicering

Duplicering kan vara roten till allt ont inom mjukvara.

Eliminera duplicering. Duplicerad kod är en missad möjlighet för abstraktion. När du ser duplicering, extrahera den gemensamma koden till en återanvändbar funktion eller klass. Detta förbättrar underhållbarheten genom att centralisera logik och minska risken för inkonsekventa förändringar. Typer av duplicering att se upp för:

• Identiska kodblock
• Liknande algoritmer med små variationer
• Upprepade switch/case eller if/else kedjor

Hantera beroenden noggrant. Minimera beroenden mellan moduler för att minska kopplingen. Använd beroendeinjektion och kontrollinversion för att göra koden mer modulär och testbar. Följ principen om beroendeinversion - bero på abstraktioner, inte konkretioner. Detta gör din kod mer flexibel och lättare att ändra.

Använd principen om minsta kunskap. En modul bör inte veta om detaljerna i de objekt den manipulerar. Detta minskar kopplingen mellan moduler. Till exempel, använd Demeter-lagen - en metod bör endast anropa metoder på:

• Ditt eget objekt
• Objekt som skickas som parametrar
• Objekt som den skapar
• Dess direkta komponentobjekt

6. Hantera fel på ett smidigt sätt

Felhantering är viktig, men om den döljer logik, är den felaktig.

Använd undantag istället för felkoder. Undantag är renare och rör inte till den huvudsakliga logiken i din kod. De tillåter felhantering att separeras från den lyckliga vägen. När du använder undantag:

• Skapa informativa felmeddelanden
• Ge kontext med undantag
• Definiera undantagsklasser baserat på anroparens behov

Returnera inte null. Att returnera null leder till nullpekare undantag och rör till koden med null-kontroller. Istället:

• Returnera tomma samlingar istället för null för listor
• Använd Null Object-mönstret
• Använd Optional i Java eller Maybe i funktionella språk

Skriv try-catch-finally satser först. Börja med try-catch-finally när du skriver kod som kan kasta undantag. Detta hjälper till att definiera omfattningen och förväntningarna för den anropande koden. Det säkerställer att resurser hanteras och frigörs korrekt, även i fel-scenarier.

7. Skriv grundliga enhetstester

Testkod är lika viktig som produktionskod.

Följ de tre lagarna för TDD. Testdriven utveckling (TDD) förbättrar kodkvalitet och design:

1. Skriv ett misslyckat test innan du skriver någon produktionskod
2. Skriv bara tillräckligt av ett test för att visa ett misslyckande
3. Skriv bara tillräckligt med produktionskod för att klara testet

Håll tester rena och underhållbara. Tillämpa samma standarder för kodkvalitet på dina tester som på din produktionskod. Refaktorisera och förbättra testkod regelbundet. Välstrukturerade tester fungerar som dokumentation och möjliggör orädd refaktorisering av produktionskod.

Sträva efter omfattande testtäckning. Skriv tester som täcker kantfall, gränsvillkor och fel-scenarier - inte bara den lyckliga vägen. Använd kodtäckningsverktyg för att identifiera luckor i testtäckningen. Kom ihåg att 100 % täckning inte garanterar felfri kod, men det ger förtroende för refaktorisering och förändringar.

8. Refaktorisera koden kontinuerligt

Lämna campingplatsen renare än du fann den.

Refaktorisera opportunistiskt. Förbättra kodstrukturen närhelst du arbetar med en del av koden. Följ Boy Scout-regeln: lämna koden bättre än du fann den. Små, inkrementella förbättringar lägger upp över tid och förhindrar kodförfall. Vanliga refaktoriseringstekniker inkluderar:

• Extrahera metoder eller klasser
• Byta namn för tydlighet
• Förenkla komplexa villkor
• Ta bort duplicering

Refaktorisera säkert med tester. Ha alltid en solid uppsättning tester innan du refaktorerar. Gör små, inkrementella förändringar och kör tester ofta. Detta ger dig förtroende för att dina förändringar inte bryter befintlig funktionalitet. Använd automatiserade refaktoriseringverktyg när de finns tillgängliga för att minska risken för att introducera fel.

Balans mellan refaktorisering och att leverera värde. Även om kontinuerlig refaktorisering är viktig, låt det inte förlama framsteg. Sikta på "tillräckligt bra" snarare än perfektion. Fokusera refaktorisering på de mest problematiska eller ofta ändrade områdena av koden. Kommunicera värdet av refaktorisering till intressenter för att säkerställa stöd för pågående kodförbättringar.

9. Tillämpa objektorienterade och funktionella programmeringsprinciper

Objekt döljer sin data bakom abstraktioner och exponerar funktioner som arbetar på den datan. Datastrukturer exponerar sin data och har inga meningsfulla funktioner.

Använd objektorienterade principer klokt. Tillämpa principer som inkapsling, arv och polymorfism för att skapa flexibla, modulära designer. Följ SOLID-principerna:

• Enskild ansvarighetsprincip
• Öppen-stängd princip
• Liskovs substitutionsprincip
• Gränssnittssplittringsprincip
• Beroendeinversionsprincip

Utnyttja funktionella programmeringskoncept. Även i objektorienterade språk kan funktionella programmeringstekniker leda till renare kod:

• Renodlade funktioner utan sidoeffekter
• Oföränderliga data
• Högre ordningens funktioner
• Funktionskomposition

Välj rätt tillvägagångssätt för problemet. Objektorienterade och funktionella paradigmer har var och en sina styrkor och svagheter. Använd objektorienterad design när du behöver modellera komplexa domäner med beteende. Använd funktionella tillvägagångssätt för datatransformation och bearbetningspipelines. Många moderna språk stöder en hybridansats, vilket gör att du kan använda det bästa verktyget för varje del av ditt system.

10. Tänk noga på samtidighet

Samtidighet är en avkopplingsstrategi. Den hjälper oss att separera vad som görs från när det görs.

Förstå samtidighetsutmaningar. Samtidig programmering introducerar komplexitet och potentiella subtila buggar. Vanliga problem inkluderar:

• Tävlingstillstånd
• Dödslås
• Missade signaler
• Problem med minnesvisibilitet

Separera samtidighetsrelaterade bekymmer. Håll din samtidighetsrelaterade kod separat från annan kod. Detta gör det lättare att resonera kring och testa. Använd abstraktioner som Executors, Futures och Actors för att hantera samtidighet istället för att arbeta med råa trådar.

Föredra oföränderliga objekt och rena funktioner. Oföränderliga objekt och rena funktioner är i grunden trådsäkra. De eliminerar många samtidighetsproblem genom att undvika delad, förändringsbar status. När förändringsbar status är nödvändig, använd lämpliga synkroniseringstekniker och överväg att använda atomära variabler eller samtidiga samlingar.

Senast uppdaterad: January 22, 2025