Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer · Lektion

Refaktorering af ældre Objective-C-kode

Anvend avancerede refaktoreringsteknikker til at forbedre designet, læsbarheden og vedligeholdelsen af eksisterende Objective-C-kode.

Lektion 1 af 411 trin

Refaktorering af ældre Objective-C-kode er en gratis Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-kurset indeholder 4 lektioner i alt.

Hvorfor refaktorere ældre Objective-C-kode?

Velkommen! I denne lektion dykker vi ned i refaktorering af ældre Objective-C-kodebaser. Refaktorering betyder, at kodens interne struktur forbedres, uden at dens eksterne funktionalitet ændres.

For ældre Objective-C-apps er refaktorering afgørende. Det hjælper med at reducere fejl, gør koden lettere at forstå og baner vejen for nye funktioner og modernisering.

Sådan opdager du kodelugte

Før vi refaktorerer, skal vi identificere områder, der har brug for forbedring. De kaldes ofte 'kodelugte' – tegn på, at der kan være noget galt med kodens design.

  • Lange metoder: Metoder, der gør for mange ting.
  • Gudeklasseobjekter: Klasser, der har for mange ansvarsområder.
  • Duplikeret kode: Den samme logik, der optræder flere steder.
  • Dårlig navngivning: Uklare navne på variable, metoder eller klasser.

Når du genkender disse tegn, kan du målrette din refaktorering.

Refaktorering: Udtræk metode

Teknikken Udtræk metode går ud på at omdanne et kodestykke fra en større metode til en ny, selvstændig metode. Det gør den oprindelige metode kortere og tydeligere, og den nye metode kan genbruges.

Se på dette eksempel, hvor én metode håndterer flere trin i genereringen af en rapport:

#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: Forklarende variabel

Nogle gange kan komplekse udtryk være svære at forstå med det samme. Refaktoreringen Indfør forklarende variabel opretter en midlertidig variabel, der indeholder resultatet af et komplekst udtryk, og giver den et klart, beskrivende navn.

Det forbedrer læsbarheden uden at ændre logikken. Se på denne betingelse:

#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

Erstat magisk tal med symbolsk konstant gør koden lettere at forstå. Et 'magisk tal' er en fast kodet numerisk værdi, der står direkte i koden uden forklaring.

Hvis du erstatter disse tal med navngivne konstanter (f.eks. #define eller const), bliver koden lettere at læse, og fremtidige ændringer bliver nemmere.

#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: Saml betingelser

Når flere betingede udtryk fører til det samme resultat, kan du samle betingede udtryk. Det betyder, at du kombinerer dem til ét mere kompakt logisk udtryk.

Det forenkler koden og reducerer gentagelser, så den bliver lettere at læse og vedligeholde.

#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: Flyt metode eller felt

Refaktoreringerne Flyt metode og Flyt felt handler om at forbedre klassesammenhængen og reducere koblingen. Hvis en metode eller et felt i én klasse primært interagerer med en anden klasse, hører det måske i stedet hjemme i den anden klasse.

  • Flyt metode: Flytter en metode til den klasse, hvor den giver mest mening.
  • Flyt felt: Flytter en instansvariabel til den klasse, der bruger den mest.

Det sikrer, at relaterede data og funktionalitet holdes samlet.

Refaktorering: Udtræk klasse

Når en enkelt klasse bliver for stor og påtager sig for mange ansvarsområder, bliver den et 'gudeklasseobjekt'. Refaktoreringen Udtræk klasse hjælper med at opdele sådan en klasse i mindre, mere fokuserede klasser, der hver har ét ansvarsområde.

Det forbedrer modulariteten og testbarheden og gør koden lettere at 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;
}

Læsbarhed: Navngivning og stil

Ud over strukturelle ændringer er forbedring af læsbarheden en vigtig del af refaktorering af ældre kode. Det omfatter:

  • Beskrivende navngivning: Brug klare, korte navne på klasser, metoder og variable, der afspejler deres formål.
  • Objective-C-konventioner: Følg standardkonventionerne for navngivning i Objective-C (f.eks. camelCase for variable, `CapitalizedCamelCase` for klasser og - (void)doSomethingWith:(id)parameter for metoder).
  • Ensartet formatering: Brug ensartet indrykning og kodestil i hele kodebasen.

Disse metoder gør det meget lettere for dig og andre at forstå koden.

Refaktoringsudfordring

Refaktorering hjælper os med at vedligeholde og videreudvikle komplekse applikationer.

Hvilken refaktoreringsteknik løser bedst problemet med en metode, der er blevet for stor og udfører flere urelaterede opgaver?

Opsummering af lektionen

I denne lektion gennemgik vi vigtige refaktoreringsteknikker til ældre Objective-C-kodebaser:

  • Identifikation af 'kodelugte' som lange metoder og gudeklasseobjekter.
  • Anvendelse af teknikker som Udtræk metode, Indfør forklarende variabel og Erstat magisk tal med symbolsk konstant.
  • Forbedring af strukturen med Saml betingede udtryk, Flyt metode eller felt og Udtræk klasse.
  • Vigtigheden af tydelig navngivning og en ensartet stil.

Kontinuerlig refaktorering er afgørende for at holde ældre apps vedligeholdelsesvenlige og klar til fremtidig udvikling!

Gratis at komme i gang

Lær Objective-C med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
12
Lektioner
48

Ofte stillede spørgsmål

Er lektionen “Refaktorering af ældre Objective-C-kode” gratis?

Ja — hele teksten til “Refaktorering af ældre Objective-C-kode” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-kurset, skal du opgradere til CoddyKit PRO. Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Refaktorering af ældre Objective-C-kode”?

Anvend avancerede refaktoreringsteknikker til at forbedre designet, læsbarheden og vedligeholdelsen af eksisterende Objective-C-kode. Du øver dig i Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer?

Der kræves ingen tidligere erfaring. Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Refaktorering af ældre Objective-C-kode”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-lektion?

Ja. Alle Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Refaktorering af ældre Objective-C-kode
  2. Håndtering af teknisk gæld
  3. Strategier for langsigtet vedligeholdelse
  4. Skriv characterization-tests før refaktorering
← Tilbage til Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer