Objective-C iOS Development for Legacy & Enterprise Apps · 课时

高级调试技术

掌握 Xcode 调试器、断点和日志记录策略，以排查 Objective-C 代码库中的复杂问题。

高级调试技术 是 CoddyKit 上的免费 Objective-C iOS Development for Legacy & Enterprise Apps 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Objective-C iOS Development for Legacy & Enterprise Apps 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Objective-C iOS Development for Legacy & Enterprise Apps 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Deeper Debugging with Xcode

Welcome to advanced debugging! While basic breakpoints are great, complex issues in legacy apps often need more sophisticated tools.

We'll explore powerful Xcode debugger features and LLDB commands to pinpoint elusive bugs, understand program flow, and manage complex states effectively.

Break on Condition

Conditional breakpoints pause execution only when a specified condition is true. This is perfect for loops or methods called frequently, where you only care about a specific state.

To set one, right-click a breakpoint, select "Edit Breakpoint," and enter an Objective-C expression like i == 5.

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    for (int i = 0; i < 10; i++) {
      // Set a conditional breakpoint on this line:
      // Condition: i == 5
      NSLog(@"Loop iteration: %d", i);
    }
  }
  return 0;
}

Breakpoint Actions for Logging

Beyond pausing, breakpoints can perform actions. You can log messages, play sounds, or even execute debugger commands without stopping the program.

This is useful for tracing values or observing program flow non-intrusively, helping you understand execution without constant manual stepping.

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    for (int i = 0; i < 3; i++) { 
      NSString *message = [NSString stringWithFormat:@"Current i: %d", i];
      // Set breakpoint here with "Log Message" action:
      // Message: Current value of i is @i@
      NSLog(@"%@", message);
    }
  }
  return 0;
}

Break on Any Method Call

A symbolic breakpoint lets you pause execution whenever a specific function or method is called, regardless of where it's defined in your code.

This is powerful for debugging system calls, framework methods, or when you don't have source access. Just specify the method name, e.g., -[UIViewController viewDidLoad].

#import <Foundation/Foundation.h>

@interface MyLogger : NSObject
+ (void)logMessage:(NSString *)message;
@end

@implementation MyLogger
+ (void)logMessage:(NSString *)message {
  NSLog(@"Custom Log: %@", message);
} // Set symbolic breakpoint: +[MyLogger logMessage:]
@end

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    [MyLogger logMessage:@"Application started."];
    // ... other code ...
    [MyLogger logMessage:@"Application finished."];
  }
  return 0;
}

Catching Exceptions Early

Exception breakpoints automatically pause your program whenever an exception (like an NSRangeException or NSInvalidArgumentException) is thrown.

This helps you catch issues at their origin, even if they're later caught by a @try/@catch block, making it easier to identify the root cause of crashes.

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    NSArray *myArray = @[@"one", @"two"];
    @try {
      // Access an out-of-bounds index
      NSString *item = myArray[2]; // This will throw an NSRangeException
      NSLog(@"Item: %@", item);
    } @catch (NSException *exception) {
      NSLog(@"Caught exception: %@", exception.reason);
    }
    NSLog(@"Program continues after catch.");
  }
  return 0;
}

Detecting Data Corruption

Watchpoints (or data breakpoints) are an incredibly powerful, advanced debugging tool. They pause execution whenever a specific memory address's content changes.

This is invaluable for tracking down mysterious data corruption issues, especially in multi-threaded or C-interoperable code where a variable's value changes unexpectedly.

#import <Foundation/Foundation.h>

@interface MyData : NSObject {
  int _value; // In Xcode, set a watchpoint on &_value after pausing
}
- (void)changeValue:(int)newValue;
@property (nonatomic, assign) int publicValue;
@end

@implementation MyData
- (instancetype)init {
  self = [super init];
  if (self) {
    _value = 0;
    _publicValue = 0;
  }
  return self;
}
- (void)changeValue:(int)newValue {
  _value = newValue; // Watchpoint on &_value would trigger here
}
@end

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    MyData *data = [[MyData alloc] init];
    data.publicValue = 10; // Changes _publicValue
    [data changeValue:20];  // Changes _value
    data.publicValue = 30;
    NSLog(@"Data values changed.");
  }
  return 0;
}

Command Line Debugging (LLDB)

While Xcode's GUI is great, the underlying debugger is LLDB (Low-Level Debugger). Learning LLDB commands gives you finer control and deeper insights, especially for complex scenarios.

You can type LLDB commands directly into Xcode's debugger console. It's like having a superpower to inspect and manipulate your program state on the fly!

Key LLDB Commands

Here are some frequently used LLDB commands to get you started:

po <expression>: Print Object (shows description of an Objective-C object).
p <expression>: Print (shows value of a primitive type or C struct).
bt: Backtrace (shows the call stack, useful for understanding how you got here).
v or frame variable: View current frame's local variables.
continue: Resume program execution.
next / n: Step over a line of code.
step / s: Step into a function/method.

#import <Foundation/Foundation.h>

@interface Greeter : NSObject
- (NSString *)greet:(NSString *)name;
@end

@implementation Greeter
- (NSString *)greet:(NSString *)name {
  NSString *greeting = [NSString stringWithFormat:@"Hello, %@", name];
  return greeting; // Set breakpoint here, then use `po greeting` in console
}
@end

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    Greeter *myGreeter = [[Greeter alloc] init];
    NSString *message = [myGreeter greet:@"Coddy"]; 
    NSLog(@"%@", message);
  }
  return 0;
}

Structured Logging with `os_log`

For production apps and complex systems, NSLog can be inefficient. Apple introduced Unified Logging with os_log, offering structured, performant, and privacy-aware logging.

It's crucial for enterprise apps for better debugging in release builds and system-wide log analysis, providing more context and control over your logs.

#import <Foundation/Foundation.h>
#import <os/log.h> // Import for os_log

os_log_t myLogger;

int main(int argc, const char * argv[]) {
  @autoreleasepool {
    myLogger = os_log_create("com.coddykit.app", "Networking");
    os_log(myLogger, "Fetching data from URL: %@", @"https://api.example.com");
    // Simulate some work
    for (int i = 0; i < 2; i++) {
      os_log_info(myLogger, "Processing item %d", i);
    }
    os_log_error(myLogger, "Network request failed with error code %d", 404);
  }
  return 0;
}

Debugging Challenge

You're tracking a bug where an integer variable counter sometimes changes unexpectedly. It's a complex legacy codebase with many threads.

Advanced Debugging Recap

Great job! You've mastered advanced debugging techniques for Objective-C.

Conditional & Action Breakpoints offer precise control over when and how your program pauses or logs.
Symbolic & Exception Breakpoints catch specific events like method calls or thrown errors.
Watchpoints are invaluable for tracking down mysterious data corruption issues.
LLDB commands provide powerful console control for inspecting program state.
os_log offers structured, performant logging for complex and production apps.

These tools will significantly boost your ability to troubleshoot complex issues in any Objective-C codebase.

常见问题解答

「高级调试技术」课时是免费的吗？

是的 — 「高级调试技术」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Objective-C iOS Development for Legacy & Enterprise Apps 课程的其余内容，请升级到 CoddyKit PRO。 Objective-C iOS Development for Legacy & Enterprise Apps 课程共包含 4 节课。

「高级调试技术」这节课中我会学到什么？

掌握 Xcode 调试器、断点和日志记录策略，以排查 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 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「高级调试技术」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Objective-C iOS Development for Legacy & Enterprise Apps 课中编写并运行代码吗？

能。每节 Objective-C iOS Development for Legacy & Enterprise Apps 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Objective-C iOS Development for Legacy & Enterprise Apps