3 kraftfulla kodningstekniker för att ta bort röriga villkor

Inom mjukvaruutveckling stöter vi ofta på kodlogik som behöver hantera flera scenarier. Om dessa logiker inte hanteras ordentligt kan de lätt utvecklas till långa if-else-kedjor eller massiva switch-satser. Denna artikel kommer att introducera flera effektiva tekniker för att optimera dessa strukturer, vilket förbättrar kodens kvalitet och underhållbarhet.

1. Defensiv programmering: tidig retur#

Låt oss säga att vi utvecklar ett användarautentiseringssystem som behöver kontrollera olika användarstatusar innan tillgång ges:

Denna kod har uppenbara strukturella problem. Den använder djupt inbyggda if-else-strukturer som gör koden svår att läsa och underhålla. När antalet kontrollvillkor ökar, fördjupas kodens indenteringsnivå och formar så kallad "pilsymbolsformad" kod. Felfunktionslogik är spridd över olika inbäddningsnivåer, vilket inte gynnar centraliserad hantering. Viktigast av allt, kärnlogiken i koden om när åtkomst tillåts, är djupt begravd i flera lager av villkorsbedömningar och saknar intuitivitet. Denna kodstil minskar inte bara kodens läsbarhet, utan ökar också risken för fel och gör kodexpansion svår.

Vi kan optimera denna kod med metoden "tidig retur":

Genom att anta metoden "tidig retur" har vi framgångsrikt optimerat den ursprungliga kodstrukturen.

Denna metod ger flera förbättringar:

• Den minskar avsevärt kodens inbäddningskomplexitet. Varje kontrollvillkor hanteras oberoende, vilket gör den övergripande logiken tydligare och mer begriplig. Denna plattade struktur förbättrar inte bara kodens läsbarhet utan minskar också avsevärt underhållssvårigheter.
• Denna optimeringsmetod uppnår centraliserad hantering av felfunktionslogik. Genom att returnera resultat direkt efter varje kontrollvillkor undviker vi onödig kodexekvering och centraliserar hanteringen av olika felscenarier, vilket gör hela felfunktionshanteringsprocessen mer organiserad.
• Kärnlogiken i koden, villkoren för att tillåta åtkomst, blir mer framträdande. Denna struktur gör kodens huvudsakliga syfte omedelbart uppenbart, vilket förbättrar kodens uttrycksförmåga och begriplighet avsevärt.

2. Uppslagstabellmetod#

Vi stöter ofta på scenarier där olika resultat behöver returneras baserat på olika indata. Om dessa logiker inte hanteras ordentligt kan de lätt utvecklas till långa if-else-kedjor eller massiva switch-satser. Till exempel, på en e-handelsplattform, behöver vi returnera motsvarande statusbeskrivningar baserat på olika orderstatusar:

Detta är ett typiskt scenario för att returnera olika resultat baserat på olika fall. När antalet fall ökar blir switch-satsen eller if-else-bedömningarna långa. Dessutom, i detta scenario, om användare behöver översätta dessa statusinnehåll till andra språk, skulle det kräva att ändra funktionskroppen eller lägga till nya funktioner, vilket skulle innebära betydande underhållskostnader.

I detta fall kan vi använda uppslagstabellmetoden för att optimera koden:

Genom att använda ett Map-objekt för att lagra kartläggningsrelationen mellan statusar och beskrivningar, blir koden mer kortfattad. Vi har också gjort det enkelt att flytta statusbeskrivningar till konfigurationsfiler, vilket ger fördelar för internationalisering och dynamiska uppdateringar. När nya statusar läggs till behöver vi inte ändra kodens kärnlogik; vi behöver bara lägga till motsvarande nyckel-värde-par i konfigurationen.

3. Funktionsorienterad programmering#

När vi utvecklar stora mjukvarusystem behöver vi ofta stödja flera tjänsteleverantörer eller funktionsmoduler. Vi kan överväga att använda funktionsorienterad programmering i mjukvarudesignsteget för att underlätta för framtida expansioner, vilket eliminerar komplexiteten i flera villkorsbedömningar som orsakas av hårdkodning i komplexa system.

Anta att vi utvecklar ett flerspråkigt översättningssystem som behöver stödja olika översättningstjänsteleverantörer. Om vi inte överväger funktionsorienterad programmering från designsteget kommer framtida expansioner att bli mycket svåra:

Denna implementation använder en enkel och grov if-else-struktur för att välja översättningsleverantörer, vilket gör koden svår att underhålla och expandera. När man lägger till nya översättningsleverantörer i framtiden behöver befintlig kod ändras, och när fler översättningsleverantörer behöver stödjas, blir koden uppsvälld och svår att underhålla. Samtidigt är denna komplexa metod också svår att enhetstesta eftersom det inte är lätt att simulera olika översättningsleverantörer.

För att lösa dessa problem kan vi använda funktionsorienterad programmering för att optimera koden. Funktionsorienterad programmering är ett viktigt sätt att implementera polymorfism, vilket möjliggör för olika objekt att svara olika på samma meddelande.

Implementeringsprocess:

1. Definiera översättningsstrategigränssnitt:

2. Implementera detta gränssnitt för varje översättningsleverantör:

3. Omstrukturera klassen TranslationService, genom att skicka strategin som en parameter:

4. Använd den optimerade koden:

Genom att definiera gränssnittet TranslationStrategy och införa funktionsorienterad programmering, har vi uppnått följande fördelar:

• TranslationService kan använda olika översättningsstrategier för varje anrop.
• Att lägga till nya översättningsleverantörer blir enkelt, skapa bara en ny strategiklass och implementera gränssnittet.
• Kundkoden kan flexibelt välja strategin som ska användas för varje översättning utan att ändra kärnlogiken i TranslationService.
• Varje översättningsstrategi kan testas oberoende, vilket förbättrar kodens testbarhet.
• Att undvika att upprätthålla tillstånd i TranslationService gör tjänsten mer stateless och trådsäker.

Slutsats#

Att optimera strukturerade villkorssatser är ett viktigt sätt att förbättra kodkvaliteten. De tre metoderna som introduceras i denna artikel - defensiv programmering, uppslagstabellmetoden och funktionsorienterad programmering (kombinerad med polymorfism) - har var och en sina tillämpbara scenarier:

1. Defensiv programmering är lämplig för att hantera flera oberoende kontrollvillkor och kan effektivt minska kodinbäddning.
2. Uppslagstabellmetoden är lämplig för att hantera krav som reagerar olika på olika fall, vilket gör koden mer koncis och lättare att underhålla.
3. Funktionsorienterad programmering kombinerad med polymorfism är lämplig för att bygga komplexa men flexibla system, vilket förbättrar kodens flexibilitet och skalbarhet.

Vid faktisk utveckling behöver vi ofta välja lämpliga metoder baserat på specifika situationer, och ibland även behöva tillämpa flera tekniker omfattande. Det viktiga är att balansera kodens enkelhet, läsbarhet och underhållsbarhet, och välja den lösning som bäst passar det aktuella problemet.

Kom ihåg att överoptimering kan leda till alltför komplex kod. Att hålla koden enkel och läsbar är alltid den främsta principen. När du tillämpar dessa tekniker bör kloka val göras baserat på projektets specifika behov och teamets tekniska nivå.