0Pricing
Objective-C iOS Development for Legacy & Enterprise Apps · レッスン

レガシーObjective-Cのリファクタリング

高度なリファクタリング手法を適用し、既存のObjective-Cコードの設計、可読性、保守性を向上させます。

「レガシーObjective-Cのリファクタリング」はCoddyKit上の無料Objective-C iOS Development for Legacy & Enterprise Appsレッスンです。 これはレッスン1/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはObjective-C iOS Development for Legacy & Enterprise Apps学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Objective-C iOS Development for Legacy & Enterprise Appsコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Why Refactor Legacy Objective-C?

Welcome! In this lesson, we'll dive into refactoring legacy Objective-C codebases. Refactoring means improving the internal structure of code without changing its external behavior.

For older Objective-C apps, refactoring is crucial. It helps reduce bugs, makes the code easier to understand, and paves the way for new features and modernization.

Spotting Code Smells

Before we refactor, we need to identify areas that need improvement. These are often called 'code smells' – indicators that something might be wrong with the code's design.

  • Long Methods: Methods that do too many things.
  • God Objects: Classes that have too many responsibilities.
  • Duplicated Code: The same logic appearing in multiple places.
  • Poor Naming: Unclear variable, method, or class names.

Recognizing these helps you target your refactoring efforts.

Refactor: Extract Method

The Extract Method technique involves turning a code fragment from a larger method into its own new method. This makes the original method shorter and clearer, and the new method can be reused.

Consider this example where a single method handles multiple report generation steps:

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

Refactor: Explaining Variable

Sometimes, complex expressions can be hard to understand at a glance. The Introduce Explaining Variable refactoring creates a temporary variable to hold the result of a complex expression, giving it a clear, descriptive name.

This improves readability without changing the logic. Look at this conditional:

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

Refactor: Symbolic Constants

Replace Magic Number with Symbolic Constant helps make code more understandable. A 'magic number' is a hard-coded numerical value that appears directly in the code without explanation.

Replacing these with named constants (e.g., #define or const) improves readability and makes future changes easier.

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

Refactor: Consolidate Conditionals

When several conditional expressions lead to the same result, you can Consolidate Conditional Expression. This means combining them into a single, more concise logical expression.

It simplifies the code and reduces redundancy, making it easier to read and maintain.

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

Refactor: Move Method/Field

The Move Method and Move Field refactorings are about improving class cohesion and reducing coupling. If a method or a field in one class primarily interacts with another class, it might belong in that other class instead.

  • Move Method: Relocates a method to the class where it makes most sense.
  • Move Field: Moves an instance variable to the class that uses it most.

This ensures that related data and behavior are kept together.

Refactor: Extract Class

When a single class grows too large and takes on too many responsibilities, it becomes a 'God Object'. The Extract Class refactoring helps break down such a class into smaller, more focused classes, each with a single responsibility.

This improves modularity, testability, and makes the code easier to manage.

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

Readability: Naming & Style

Beyond structural changes, improving readability is a critical part of refactoring legacy code. This includes:

  • Descriptive Naming: Use clear, concise names for classes, methods, and variables that reflect their purpose.
  • Objective-C Conventions: Adhere to standard Objective-C naming conventions (e.g., camelCase for variables, `CapitalizedCamelCase` for classes, - (void)doSomethingWith:(id)parameter for methods).
  • Consistent Formatting: Maintain consistent indentation and code style throughout the codebase.

These practices make the code much easier for you and others to understand.

Refactoring Challenge

Refactoring helps us maintain and evolve complex applications.

Which refactoring technique best addresses a method that has grown too large and performs multiple unrelated tasks?

Lesson Recap

In this lesson, we explored key refactoring techniques for legacy Objective-C codebases:

  • Identifying 'code smells' like long methods and God objects.
  • Applying techniques such as Extract Method, Introduce Explaining Variable, and Replace Magic Number with Symbolic Constant.
  • Improving structure with Consolidate Conditional Expression, Move Method/Field, and Extract Class.
  • The importance of clear naming and consistent style.

Continuous refactoring is essential for keeping legacy apps maintainable and ready for future development!

よくある質問

「レガシーObjective-Cのリファクタリング」レッスンは無料ですか？

はい。「レガシーObjective-Cのリファクタリング」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Objective-C iOS Development for Legacy & Enterprise Appsコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Objective-C iOS Development for Legacy & Enterprise Appsコースには全4レッスンが含まれています。

「レガシーObjective-Cのリファクタリング」で何を学びますか？

高度なリファクタリング手法を適用し、既存のObjective-Cコードの設計、可読性、保守性を向上させます。 ブラウザで直接実行するハンズオンコードでObjective-C iOS Development for Legacy & Enterprise Appsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Objective-C iOS Development for Legacy & Enterprise Appsを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのObjective-C iOS Development for Legacy & Enterprise Appsは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン1/4です。

「レガシーObjective-Cのリファクタリング」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このObjective-C iOS Development for Legacy & Enterprise Appsレッスンでコードを書いて実行できますか？

はい。すべてのObjective-C iOS Development for Legacy & Enterprise Appsレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. レガシーObjective-Cのリファクタリング
  2. 技術的負債の管理
  3. 長期保守の戦略
  4. リファクタリング前の特性テスト作成
← Objective-C iOS Development for Legacy & Enterprise Appsに戻る