Refaktorering av eldre Objective-C-kode
Bruk avanserte refaktoreringsteknikker for å forbedre utformingen, lesbarheten og vedlikeholdbarheten til eksisterende Objective-C-kode.
Refaktorering av eldre Objective-C-kode er en gratis leksjon i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper inneholder totalt 4 leksjoner.
Hvorfor refaktorere eldre Objective-C-kode?
Velkommen! I denne leksjonen skal vi se nærmere på refaktorering av eldre Objective-C-kodebaser. Refaktorering betyr å forbedre den interne strukturen i koden uten å endre den eksterne virkemåten.
For eldre Objective-C-apper er refaktorering avgjørende. Det bidrar til å redusere feil, gjør koden enklere å forstå og legger til rette for nye funksjoner og modernisering.
Finne kodeindiser
Før vi refaktorerer, må vi identifisere områder som trenger forbedring. Disse kalles ofte «code smells» – tegn på at noe kan være galt med utformingen av koden.
- Lange metoder: Metoder som gjør for mange ting.
- God objects: Klasser som har for mange ansvarsområder.
- Duplisert kode: Den samme logikken forekommer flere steder.
- Dårlig navngivning: Uklare navn på variabler, metoder eller klasser.
Når De gjenkjenner disse, blir det enklere å målrette refaktoreringen.
Refaktorering: Extract Method
Teknikken Extract Method innebærer å gjøre et kodefragment fra en større metode om til en egen, ny metode. Dette gjør den opprinnelige metoden kortere og tydeligere, og den nye metoden kan gjenbrukes.
Se på dette eksempelet, der én metode håndterer flere trinn for generering av rapporter:
#import <Foundation/Foundation.h>
@interface ReportGenerator : NSObject
- (void)generateDetailedReportForData:(NSArray<NSNumber *> *)data values:(NSArray<NSNumber *> *)values;
@end
@implementation ReportGenerator
- (void)generateDetailedReportForData:(NSArray<NSNumber *> *)data values:(NSArray<NSNumber *> *)values {
// Calculate sum of data
double sumData = 0;
for (NSNumber *num in data) {
sumData += [num doubleValue];
}
NSLog(@"Data Sum: %.2f", sumData);
// Calculate average of values
double sumValues = 0;
for (NSNumber *num in values) {
sumValues += [num doubleValue];
}
double avgValues = sumValues / [values count];
NSLog(@"Values Average: %.2f", avgValues);
// Check for anomalies (simplified example)
if (sumData > 100 && avgValues < 10) {
NSLog(@"Anomaly Detected.");
} else {
NSLog(@"No anomaly detected.");
}
// Log final report generation time
NSDate *now = [NSDate date];
NSLog(@"Report generated at: %@", now);
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
ReportGenerator *generator = [[ReportGenerator alloc] init];
NSArray<NSNumber *> *sampleData = @[@20.0, @30.0, @60.0];
NSArray<NSNumber *> *sampleValues = @[@5.0, @8.0, @7.0];
[generator generateDetailedReportForData:sampleData values:sampleValues];
}
return 0;
}Refaktorering: Explaining Variable
Noen ganger kan komplekse uttrykk være vanskelige å forstå med et blikk. Refaktoreringen Introduce Explaining Variable oppretter en midlertidig variabel som inneholder resultatet av et komplekst uttrykk, og gir den et tydelig og beskrivende navn.
Dette forbedrer lesbarheten uten å endre logikken. Se på denne betingelsen:
#import <Foundation/Foundation.h>
@interface PriceCalculator : NSObject
- (CGFloat)calculatePriceForQuantity:(NSInteger)quantity isPremiumCustomer:(BOOL)isPremium hasCoupon:(BOOL)hasCoupon;
@end
@implementation PriceCalculator
- (CGFloat)calculatePriceForQuantity:(NSInteger)quantity isPremiumCustomer:(BOOL)isPremium hasCoupon:(BOOL)hasCoupon {
CGFloat basePrice = 100.0 * quantity;
// Complex condition
if (quantity > 10 && isPremium && !hasCoupon) {
basePrice *= 0.8; // 20% discount
} else if (quantity > 5 && (isPremium || hasCoupon)) {
basePrice *= 0.9; // 10% discount
}
return basePrice;
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
PriceCalculator *calculator = [[PriceCalculator alloc] init];
NSLog(@"Price 1: %.2f", [calculator calculatePriceForQuantity:15 isPremiumCustomer:YES hasCoupon:NO]);
NSLog(@"Price 2: %.2f", [calculator calculatePriceForQuantity:7 isPremiumCustomer:NO hasCoupon:YES]);
}
return 0;
}Refaktorering: Symbolske konstanter
Replace Magic Number with Symbolic Constant gjør koden enklere å forstå. Et «magic number» er en hardkodet tallverdi som står direkte i koden uten forklaring.
Ved å erstatte disse med navngitte konstanter (for eksempel #define eller const) blir koden lettere å lese, og fremtidige endringer blir enklere.
#import <Foundation/Foundation.h>
@interface ScoreEvaluator : NSObject
- (NSString *)evaluateScore:(NSInteger)score;
@end
@implementation ScoreEvaluator
- (NSString *)evaluateScore:(NSInteger)score {
// Magic numbers: 90, 75, 60
if (score >= 90) {
return @"Excellent";
} else if (score >= 75) {
return @"Good";
} else if (score >= 60) {
return @"Pass";
} else {
return @"Fail";
}
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
ScoreEvaluator *evaluator = [[ScoreEvaluator alloc] init];
NSLog(@"Score 95: %@", [evaluator evaluateScore:95]);
NSLog(@"Score 70: %@", [evaluator evaluateScore:70]);
}
return 0;
}Refaktorering: Samle betingelser
Når flere betingede uttrykk fører til samme resultat, kan De bruke Consolidate Conditional Expression. Det innebærer å slå dem sammen til ett mer konsist logisk uttrykk.
Dette forenkler koden og reduserer gjentakelser, slik at den blir enklere å lese og vedlikeholde.
#import <Foundation/Foundation.h>
@interface UserValidator : NSObject
- (BOOL)isUserEligibleForFeature:(BOOL)hasSubscription isActive:(BOOL)isActive isBetaTester:(BOOL)isBetaTester;
@end
@implementation UserValidator
- (BOOL)isUserEligibleForFeature:(BOOL)hasSubscription isActive:(BOOL)isActive isBetaTester:(BOOL)isBetaTester {
// Original logic:
if (hasSubscription) {
return YES;
}
if (isActive && isBetaTester) {
return YES;
}
return NO;
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
UserValidator *validator = [[UserValidator alloc] init];
NSLog(@"User 1 Eligible: %@", [validator isUserEligibleForFeature:YES isActive:NO isBetaTester:NO] ? @"YES" : @"NO");
NSLog(@"User 2 Eligible: %@", [validator isUserEligibleForFeature:NO isActive:YES isBetaTester:YES] ? @"YES" : @"NO");
NSLog(@"User 3 Eligible: %@", [validator isUserEligibleForFeature:NO isActive:YES isBetaTester:NO] ? @"YES" : @"NO");
}
return 0;
}Refaktorering: Flytte metode/felt
Refaktoreringene Move Method og Move Field handler om å forbedre klassesamholdet og redusere koblingen mellom klasser. Hvis en metode eller et felt i én klasse hovedsakelig samhandler med en annen klasse, hører det kanskje hjemme i den andre klassen.
- Move Method: Flytter en metode til klassen der den passer best.
- Move Field: Flytter en instansvariabel til klassen som bruker den mest.
Dette sørger for at relaterte data og relatert oppførsel holdes samlet.
Refaktorering: Extract Class
Når én klasse blir for stor og får for mange ansvarsområder, blir den et «God Object». Refaktoreringen Extract Class bidrar til å dele opp en slik klasse i mindre og mer fokuserte klasser, der hver klasse har ett ansvarsområde.
Dette forbedrer modulariteten og testbarheten, og gjør koden enklere å håndtere.
#import <Foundation/Foundation.h>
// Before (simplified God Object concept)
@interface UserProfileManager : NSObject
@property (nonatomic, strong) NSString *username;
@property (nonatomic, strong) NSString *email;
- (void)loadUserDataFromRemoteServer;
- (void)saveUserDataToLocalCache;
- (void)displayProfileOnScreen;
- (BOOL)authenticateUserWithPassword:(NSString *)password;
@end
@implementation UserProfileManager
- (void)loadUserDataFromRemoteServer { NSLog(@"Loading user data..."); }
- (void)saveUserDataToLocalCache { NSLog(@"Saving user data..."); }
- (void)displayProfileOnScreen { NSLog(@"Displaying profile..."); }
- (BOOL)authenticateUserWithPassword:(NSString *)password {
NSLog(@"Authenticating user...");
return YES;
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
UserProfileManager *manager = [[UserProfileManager alloc] init];
manager.username = @"coddykit";
[manager authenticateUserWithPassword:@"password"];
[manager loadUserDataFromRemoteServer];
[manager displayProfileOnScreen];
}
return 0;
}Lesbarhet: Navngivning og stil
I tillegg til strukturelle endringer er bedre lesbarhet en viktig del av refaktorering av eldre kode. Dette omfatter:
- Beskrivende navngivning: Bruk tydelige og konsise navn på klasser, metoder og variabler som gjenspeiler formålet deres.
- Objective-C-konvensjoner: Følg standardkonvensjonene for navngivning i Objective-C (for eksempel
camelCasefor variabler, `CapitalizedCamelCase` for klasser og- (void)doSomethingWith:(id)parameterfor metoder). - Konsekvent formatering: Bruk konsekvent innrykk og kodestil i hele kodebasen.
Disse praksisene gjør koden mye enklere for Dem og andre å forstå.
Refaktoringsutfordring
Refaktorering hjelper oss med å vedlikeholde og videreutvikle komplekse applikasjoner.
Hvilken refaktoreringsteknikk passer best for en metode som har blitt for stor og utfører flere oppgaver som ikke henger sammen?
Oppsummering av leksjonen
I denne leksjonen utforsket vi sentrale refaktoreringsteknikker for eldre Objective-C-kodebaser:
- Identifisering av «code smells», som lange metoder og God objects.
- Bruk av teknikker som Extract Method, Introduce Explaining Variable og Replace Magic Number with Symbolic Constant.
- Forbedring av strukturen med Consolidate Conditional Expression, Move Method/Field og Extract Class.
- Betydningen av tydelig navngivning og konsekvent stil.
Kontinuerlig refaktorering er avgjørende for å holde eldre apper vedlikeholdbare og klare for videre utvikling!
Lær deg Objective-C med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Refaktorering av eldre Objective-C-kode» gratis?
Ja – hele teksten i «Refaktorering av eldre Objective-C-kode» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper inneholder totalt 4 leksjoner.
Hva lærer jeg i «Refaktorering av eldre Objective-C-kode»?
Bruk avanserte refaktoreringsteknikker for å forbedre utformingen, lesbarheten og vedlikeholdbarheten til eksisterende Objective-C-kode. Du øver på Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper?
Ingen tidligere erfaring er nødvendig. Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «Refaktorering av eldre Objective-C-kode»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-leksjonen?
Ja. Alle Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Refaktorering av eldre Objective-C-kode
- Håndtering av teknisk gjeld
- Strategier for langsiktig vedlikehold
- Skrive karakteriseringstester før refaktorering