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

Avancerede debuggingteknikker

Bliv fortrolig med Xcodes debugger, breakpoints og strategier for logging, så De kan fejlfinde komplekse problemer i Objective-C-kodebaser.

Lektion 3 af 411 trin

Avancerede debuggingteknikker er en gratis Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer-lektion på CoddyKit. Dette er lektion 3 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.

Dybere fejlfinding med Xcode

Velkommen til avanceret fejlfinding! Selvom grundlæggende breakpoints er gode, kræver komplekse problemer i ældre apps ofte mere avancerede værktøjer.

Vi undersøger effektive funktioner i Xcode-fejlfinderen og LLDB-kommandoer for præcist at finde svære fejl, forstå programmets forløb og håndtere komplekse tilstande effektivt.

Stop ved en betingelse

Betingede breakpoints sætter kun udførelsen på pause, når en angivet betingelse er sand. Det er perfekt til løkker eller metoder, der kaldes ofte, når du kun er interesseret i en bestemt tilstand.

Hvis du vil oprette et, skal du højreklikke på et breakpoint, vælge "Edit Breakpoint" og indtaste et Objective-C-udtryk som 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-handlinger til logging

Ud over at sætte udførelsen på pause kan breakpoints udføre handlinger. Du kan logge meddelelser, afspille lyde eller endda udføre fejlfinderkommandoer uden at stoppe programmet.

Det er nyttigt til at følge værdier eller observere programmets forløb uden at forstyrre det, så du kan forstå udførelsen uden hele tiden at gå trinvist gennem koden manuelt.

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

Stop ved alle metodekald

Et symbolsk breakpoint lader dig sætte udførelsen på pause, hver gang en bestemt funktion eller metode kaldes, uanset hvor den er defineret i din kode.

Det er effektivt til fejlfinding af systemkald og framework-metoder eller når du ikke har adgang til kildekoden. Angiv blot metodens navn, f.eks. -[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;
}

Fang undtagelser tidligt

Undtagelses-breakpoints sætter automatisk dit program på pause, hver gang der kastes en undtagelse (f.eks. en NSRangeException eller NSInvalidArgumentException).

Det hjælper dig med at fange problemer ved deres oprindelse, selv hvis de senere fanges af en @try/@catch-blok, hvilket gør det lettere at identificere den grundlæggende årsag til nedbrud.

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

Find datakorruption

Watchpoints (eller data-breakpoints) er et utroligt effektivt, avanceret værktøj til fejlfinding. De sætter udførelsen på pause, hver gang indholdet på en bestemt hukommelsesadresse ændres.

Det er uvurderligt til at finde mystiske problemer med datakorruption, især i kode med flere tråde eller C-interoperabilitet, hvor en variabels værdi ændres uventet.

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

Fejlfinding fra kommandolinjen (LLDB)

Selvom Xcodes grafiske brugergrænseflade er god, er den underliggende fejlfinder LLDB (Low-Level Debugger). Når du lærer LLDB-kommandoer, får du finere kontrol og dybere indsigt, især i komplekse situationer.

Du kan skrive LLDB-kommandoer direkte i Xcodes fejlfinderkonsol. Det er som at have en superkraft, der lader dig undersøge og ændre programmets tilstand undervejs!

Vigtige LLDB-kommandoer

Her er nogle ofte anvendte LLDB-kommandoer, som kan hjælpe dig i gang:

po <expression>: Print Object (viser beskrivelsen af et Objective-C-objekt).
p <expression>: Print (viser værdien af en primitiv type eller en C-struktur).
bt: Backtrace (viser kaldstakken og er nyttig til at forstå, hvordan du nåede hertil).
v eller frame variable: Vis den aktuelle frames lokale variabler.
continue: Genoptag programmets udførelse.
next / n: Gå hen over en kodelinje.
step / s: Gå ind i en funktion/metode.

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

Struktureret logging med `os_log`

I produktionsapps og komplekse systemer kan NSLog være ineffektiv. Apple introducerede Unified Logging med os_log, som giver struktureret, effektiv og privatlivsbevidst logging.

Det er afgørende i virksomhedsapps, fordi det giver bedre fejlfinding i release-builds og systemdækkende loganalyse samt mere kontekst og kontrol over dine 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;
}

Fejlfindingsudfordring

Du følger en fejl, hvor en heltalsvariabel counter nogle gange ændrer sig uventet. Det er en kompleks ældre kodebase med mange tråde.

Besvar den i den interaktive lektion

Opsummering af avanceret fejlfinding

Godt arbejde! Du har fået styr på avancerede fejlfindingsteknikker til Objective-C.

Betingede breakpoints og handlings-breakpoints giver præcis kontrol over, hvornår og hvordan programmet sætter på pause eller logger.
Symbolske breakpoints og undtagelses-breakpoints fanger bestemte hændelser som metodekald eller kastede fejl.
Watchpoints er uvurderlige til at finde mystiske problemer med datakorruption.
LLDB-kommandoer giver effektiv kontrol fra konsollen, så du kan undersøge programmets tilstand.
os_log giver struktureret og effektiv logging til komplekse apps og produktionsapps.

Disse værktøjer vil i høj grad forbedre din evne til at fejlfinde komplekse problemer i enhver Objective-C-kodebase.

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

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Avancerede debuggingteknikker” gratis?

Ja — hele teksten til “Avancerede debuggingteknikker” 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 “Avancerede debuggingteknikker”?

Bliv fortrolig med Xcodes debugger, breakpoints og strategier for logging, så De kan fejlfinde komplekse problemer i Objective-C-kodebaser. 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 3 af 4.

Hvor lang tid tager lektionen “Avancerede debuggingteknikker”?

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

Registrering af memory leaks med Instruments
Optimering af UI-rendering og reaktionsevne
Avancerede debuggingteknikker
Profilering og reduktion af appens opstartstid

← Tilbage til Objective-C-udvikling til iOS med ældre og virksomhedsapplikationer