Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps · Les

Geavanceerde debuggingtechnieken

Beheers de debugger, breakpoints en loggingstrategieën van Xcode om complexe problemen in Objective-C-codebases op te lossen.

Les 3 van 411 stappen

Geavanceerde debuggingtechnieken is een gratis Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat in totaal 4 lessen.

Diepgaander debuggen met Xcode

Welkom bij geavanceerd debuggen! Hoewel eenvoudige onderbrekingspunten uitstekend zijn, vereisen complexe problemen in verouderde apps vaak geavanceerdere hulpmiddelen.

We verkennen krachtige functies van de Xcode-debugger en LLDB-opdrachten om moeilijk vindbare bugs op te sporen, de programmastroom te begrijpen en complexe toestanden effectief te beheren.

Onderbreken bij een voorwaarde

Voorwaardelijke onderbrekingspunten pauzeren de uitvoering alleen wanneer aan een opgegeven voorwaarde is voldaan. Dit is ideaal voor lussen of methoden die vaak worden aangeroepen, wanneer u alleen geïnteresseerd bent in een specifieke toestand.

U stelt er een in door met de rechtermuisknop op een onderbrekingspunt te klikken, "Edit Breakpoint" te selecteren en een Objective-C-expressie zoals i == 5 in te voeren.

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

Acties voor logboekregistratie bij onderbrekingspunten

Onderbrekingspunten kunnen meer doen dan alleen pauzeren: ze kunnen acties uitvoeren. U kunt berichten registreren, geluiden afspelen of zelfs debuggeropdrachten uitvoeren zonder het programma te stoppen.

Dit is nuttig om waarden te traceren of de programmastroom niet-intrusief te observeren. Zo begrijpt u de uitvoering zonder voortdurend handmatig stap voor stap te gaan.

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

Onderbreken bij elke methode-aanroep

Met een symbolisch onderbrekingspunt kunt u de uitvoering pauzeren telkens wanneer een specifieke functie of methode wordt aangeroepen, ongeacht waar deze in uw code is gedefinieerd.

Dit is krachtig voor het debuggen van systeemaanroepen en frameworkmethoden, of wanneer u geen toegang tot de broncode hebt. Geef gewoon de methodenaam op, bijvoorbeeld -[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;
}

Uitzonderingen vroeg onderscheppen

Uitzonderingsonderbrekingspunten pauzeren uw programma automatisch wanneer een uitzondering (zoals een NSRangeException of NSInvalidArgumentException) wordt gegenereerd.

Zo onderschept u problemen bij hun oorsprong, zelfs als ze later worden opgevangen door een blok @try/@catch. Daardoor wordt het eenvoudiger om de onderliggende oorzaak van crashes vast te stellen.

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

Gegevensbeschadiging opsporen

Watchpoints (of gegevensonderbrekingspunten) zijn een bijzonder krachtig geavanceerd hulpmiddel voor debuggen. Ze pauzeren de uitvoering telkens wanneer de inhoud op een specifiek geheugenadres verandert.

Dit is onmisbaar bij het opsporen van mysterieuze problemen met gegevensbeschadiging, vooral in code met meerdere threads of code die met C interoperabel is, waarin de waarde van een variabele onverwacht verandert.

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

Debuggen via de opdrachtregel (LLDB)

Hoewel de grafische interface van Xcode uitstekend is, is de onderliggende debugger LLDB (Low-Level Debugger). Als u LLDB-opdrachten leert, krijgt u fijnmazigere controle en diepere inzichten, vooral bij complexe situaties.

U kunt LLDB-opdrachten rechtstreeks in de debuggerconsole van Xcode typen. Het is alsof u een superkracht hebt om de toestand van uw programma direct te inspecteren en aan te passen!

Belangrijke LLDB-opdrachten

Hier volgen enkele veelgebruikte LLDB-opdrachten om u op weg te helpen:

po <expression>: Print Object (toont een beschrijving van een Objective-C-object).
p <expression>: Print (toont de waarde van een primitief type of een C-struct).
bt: Backtrace (toont de aanroeplijst, wat nuttig is om te begrijpen hoe u hier bent gekomen).
v of frame variable: toont de lokale variabelen van het huidige frame.
continue: hervat de uitvoering van het programma.
next / n: gaat over één coderegel heen.
step / s: stapt een functie of methode binnen.

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

Gestructureerde logboekregistratie met `os_log`

Voor productie-apps en complexe systemen kan NSLog inefficiënt zijn. Apple introduceerde Unified Logging met os_log, voor gestructureerde, performante en privacybewuste logboekregistratie.

Dit is essentieel voor bedrijfsapps, omdat het beter debuggen in releasebuilds en systeembrede loganalyse mogelijk maakt en meer context en controle over uw logboeken biedt.

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

Debuguitdaging

U volgt een bug waarbij een gehele getallenvariabele counter soms onverwacht verandert. Het is een complexe, verouderde codebase met veel threads.

Beantwoord dit in de interactieve les

Samenvatting: geavanceerd debuggen

Goed gedaan! U beheerst nu geavanceerde debugtechnieken voor Objective-C.

Voorwaardelijke onderbrekingspunten en actieonderbrekingspunten bieden nauwkeurige controle over wanneer en hoe uw programma pauzeert of logboekregistraties maakt.
Symbolische onderbrekingspunten en uitzonderingsonderbrekingspunten onderscheppen specifieke gebeurtenissen, zoals methode-aanroepen of gegenereerde fouten.
Watchpoints zijn onmisbaar bij het opsporen van mysterieuze problemen met gegevensbeschadiging.
LLDB-opdrachten bieden krachtige controle via de console om de programmatoestand te inspecteren.
os_log biedt gestructureerde, performante logboekregistratie voor complexe apps en productie-apps.

Deze hulpmiddelen vergroten uw vermogen om complexe problemen in elke Objective-C-codebase op te lossen aanzienlijk.

Gratis beginnen

Leer Objective-C met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Geavanceerde debuggingtechnieken” gratis?

Ja — de volledige tekst van “Geavanceerde debuggingtechnieken” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat in totaal 4 lessen.

Wat leer ik in “Geavanceerde debuggingtechnieken”?

Beheers de debugger, breakpoints en loggingstrategieën van Xcode om complexe problemen in Objective-C-codebases op te lossen. Je oefent met Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps te beginnen?

Ervaring vooraf is niet nodig. Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Geavanceerde debuggingtechnieken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps?

Ja. Elke les over Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Geheugenlekken detecteren met Instruments
UI-rendering en responsiviteit optimaliseren
Geavanceerde debuggingtechnieken
Profileren en de opstarttijd van apps verkorten

← Terug naar Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps