Objective-C iOS-kehitys vanhoille ja yrityssovelluksille · Oppitunti

Vanhan Objective-C-koodin refaktorointi

Sovellatte edistyneitä refaktorointitekniikoita olemassa olevan Objective-C-koodin rakenteen, luettavuuden ja ylläpidettävyyden parantamiseen.

Oppitunti 1/411 vaihetta

Vanhan Objective-C-koodin refaktorointi on ilmainen Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-kurssilla on yhteensä 4 oppituntia.

Miksi vanhaa Objective-C-koodia kannattaa uudistaa?

Tervetuloa! Tässä oppitunnissa perehdymme vanhojen Objective-C-koodikantojen refaktorointiin. Refaktorointi tarkoittaa koodin sisäisen rakenteen parantamista muuttamatta sen ulkoista toimintaa.

Vanhoissa Objective-C-sovelluksissa refaktorointi on erittäin tärkeää. Se auttaa vähentämään virheitä, tekee koodista helpommin ymmärrettävää ja luo pohjan uusille ominaisuuksille ja nykyaikaistamiselle.

Koodihajujen tunnistaminen

Ennen refaktorointia on tunnistettava alueet, joita pitää parantaa. Näitä kutsutaan usein koodihajuiksi (code smells): ne ovat merkkejä siitä, että koodin suunnittelussa saattaa olla ongelmia.

  • Pitkät metodit: Metodit, jotka tekevät liian monia asioita.
  • Jumalaoliot: Luokat, joilla on liian paljon vastuita.
  • Monistettu koodi: Sama logiikka esiintyy useassa paikassa.
  • Huono nimeäminen: Epäselvät muuttujien, metodien tai luokkien nimet.

Kun tunnistat nämä ongelmat, voit kohdistaa refaktorointityösi oikein.

Refaktorointi: Extract Method

Extract Method -tekniikassa suuremman metodin koodikatkelma muutetaan omaksi uudeksi metodikseen. Näin alkuperäisestä metodista tulee lyhyempi ja selkeämpi, ja uutta metodia voidaan käyttää uudelleen.

Tarkastellaan esimerkkiä, jossa yksi metodi käsittelee raportin luomisen useita vaiheita:

#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;
}

Refaktorointi: Explaining Variable

Monimutkaisia lausekkeita voi joskus olla vaikea ymmärtää yhdellä silmäyksellä. Introduce Explaining Variable -refaktoroinnissa luodaan väliaikainen muuttuja, johon monimutkaisen lausekkeen tulos tallennetaan, ja annetaan muuttujalle selkeä, kuvaava nimi.

Tämä parantaa luettavuutta muuttamatta logiikkaa. Tarkastele seuraavaa ehtoa:

#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;
}

Refaktorointi: symboliset vakiot

Replace Magic Number with Symbolic Constant auttaa tekemään koodista ymmärrettävämpää. ”Taikaluku” (magic number) on koodiin suoraan kirjoitettu numeerinen arvo, jonka merkitystä ei selitetä.

Kun tällaiset arvot korvataan nimetyillä vakioilla (esimerkiksi #define tai const), koodin luettavuus paranee ja tulevien muutosten tekeminen helpottuu.

#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;
}

Refaktorointi: ehtojen yhdistäminen

Kun useat ehtolausekkeet johtavat samaan tulokseen, voit käyttää Consolidate Conditional Expression -tekniikkaa. Siinä ehdot yhdistetään yhdeksi tiiviimmäksi loogiseksi lausekkeeksi.

Tämä yksinkertaistaa koodia ja vähentää toisteisuutta, mikä helpottaa sen lukemista ja ylläpitämistä.

#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;
}

Refaktorointi: metodin tai kentän siirtäminen

Move Method- ja Move Field -refaktoroinneilla parannetaan luokkien koheesiota ja vähennetään kytkentää. Jos yhden luokan metodi tai kenttä käsittelee pääasiassa toista luokkaa, sen paikka saattaa olla kyseisessä toisessa luokassa.

  • Move Method: Siirtää metodin luokkaan, johon se parhaiten kuuluu.
  • Move Field: Siirtää instanssimuuttujan luokkaan, joka käyttää sitä eniten.

Näin toisiinsa liittyvät tiedot ja toiminnot pysyvät yhdessä.

Refaktorointi: luokan erottaminen

Kun yksittäinen luokka kasvaa liian suureksi ja saa liian monia vastuita, siitä tulee ”jumalaolio”. Extract Class -refaktorointi auttaa jakamaan tällaisen luokan pienemmiksi ja tarkemmin kohdistetuiksi luokiksi, joilla kullakin on yksi vastuu.

Tämä parantaa modulaarisuutta ja testattavuutta sekä helpottaa koodin hallintaa.

#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;
}

Luettavuus: nimeäminen ja tyyli

Rakenteellisten muutosten lisäksi luettavuuden parantaminen on tärkeä osa vanhan koodin refaktorointia. Tähän kuuluu:

  • Kuvaavat nimet: Käytä luokille, metodeille ja muuttujille selkeitä ja ytimekkäitä nimiä, jotka kuvaavat niiden tarkoitusta.
  • Objective-C:n käytännöt: Noudata Objective-C:n vakiintuneita nimeämiskäytäntöjä (esimerkiksi camelCase muuttujille, `CapitalizedCamelCase` luokille ja - (void)doSomethingWith:(id)parameter metodeille).
  • Yhdenmukainen muotoilu: Säilytä sisennys ja koodityyli yhdenmukaisina koko koodikannassa.

Näiden käytäntöjen ansiosta sinun ja muiden on paljon helpompi ymmärtää koodia.

Refaktorointihaaste

Refaktorointi auttaa ylläpitämään ja kehittämään monimutkaisia sovelluksia.

Mikä refaktorointitekniikka soveltuu parhaiten metodiin, joka on kasvanut liian suureksi ja suorittaa useita toisiinsa liittymättömiä tehtäviä?

Oppitunnin kertaus

Tässä oppitunnissa tutustuimme vanhojen Objective-C-koodikantojen keskeisiin refaktorointitekniikoihin:

  • Tunnistimme koodihajuja, kuten pitkiä metodeja ja jumalaolioita.
  • Sovelsimme tekniikoita, kuten Extract Method, Introduce Explaining Variable ja Replace Magic Number with Symbolic Constant.
  • Paransimme rakennetta tekniikoilla Consolidate Conditional Expression, Move Method/Field ja Extract Class.
  • Tarkastelimme selkeän nimeämisen ja yhdenmukaisen tyylin merkitystä.

Jatkuva refaktorointi on olennaista, jotta vanhat sovellukset pysyvät ylläpidettävinä ja valmiina tulevaan kehitykseen!

Aloita maksutta

Opi Objective-C tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit
12
Oppitunnit
48

Usein kysytyt kysymykset

Onko oppitunti ”Vanhan Objective-C-koodin refaktorointi” ilmainen?

Kyllä – oppitunnin ”Vanhan Objective-C-koodin refaktorointi” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-kurssin, päivitä CoddyKit PROhon. Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Vanhan Objective-C-koodin refaktorointi”?

Sovellatte edistyneitä refaktorointitekniikoita olemassa olevan Objective-C-koodin rakenteen, luettavuuden ja ylläpidettävyyden parantamiseen. Harjoittelet Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.

Kuinka kauan ”Vanhan Objective-C-koodin refaktorointi”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-oppitunnilla?

Kyllä. Jokainen Objective-C iOS-kehitys vanhoille ja yrityssovelluksille-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

  1. Vanhan Objective-C-koodin refaktorointi
  2. Teknisen velan hallinta
  3. Pitkän aikavälin ylläpitostrategiat
  4. Karakterisointitestien kirjoittaminen ennen refaktorointia
← Takaisin: Objective-C iOS-kehitys vanhoille ja yrityssovelluksille