重构旧版 Objective-C 代码
运用高级重构技术，改善现有 Objective-C 代码的设计、可读性和可维护性。
重构旧版 Objective-C 代码 是 CoddyKit 上的免费 Objective-C iOS Development for Legacy & Enterprise Apps 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 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.,
camelCasefor variables, `CapitalizedCamelCase` for classes,- (void)doSomethingWith:(id)parameterfor 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 代码」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 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，全天候 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 反馈 — 无需本地设置。