Avancerade felsökningstekniker
Bemästra Xcodes debugger, breakpoints och strategier för loggning för att felsöka komplexa problem i Objective-C-kodbaser.
Avancerade felsökningstekniker är en gratis lektion i Objective-C för iOS-utveckling av äldre appar och företagsappar på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Objective-C för iOS-utveckling av äldre appar och företagsappar, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Objective-C för iOS-utveckling av äldre appar och företagsappar innehåller totalt 4 lektioner.
Djupare felsökning med Xcode
Välkomna till avancerad felsökning! Grundläggande brytpunkter är användbara, men komplexa problem i äldre appar kräver ofta mer avancerade verktyg.
Vi utforskar kraftfulla funktioner i Xcodes debugger och LLDB-kommandon för att hitta svårupptäckta buggar, förstå programmets flöde och hantera komplexa tillstånd effektivt.
Pausa vid ett villkor
Villkorsstyrda brytpunkter pausar körningen endast när ett angivet villkor är sant. Det passar perfekt för loopar eller metoder som anropas ofta, när Ni bara är intresserad av ett specifikt tillstånd.
Högerklicka på en brytpunkt, välj "Edit Breakpoint" och ange ett Objective-C-uttryck 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;
}Brytpunktsåtgärder för loggning
Utöver att pausa kan brytpunkter utföra åtgärder. Ni kan logga meddelanden, spela upp ljud eller till och med köra debugger-kommandon utan att stoppa programmet.
Detta är användbart för att spåra värden eller observera programmets flöde utan att störa körningen, så att Ni kan förstå exekveringen utan att ständigt stega manuellt.
#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;
}Pausa vid valfritt metodanrop
En symbolisk brytpunkt låter Er pausa körningen när en specifik funktion eller metod anropas, oavsett var den är definierad i koden.
Detta är kraftfullt vid felsökning av systemanrop och ramverksmetoder, eller när Ni inte har tillgång till källkoden. Ange bara metodnamnet, till exempel -[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;
}Fånga undantag tidigt
Undantagsbrytpunkter pausar automatiskt programmet när ett undantag (som NSRangeException eller NSInvalidArgumentException) kastas.
Det hjälper Er att fånga problem där de uppstår, även om de senare fångas av ett @try/@catch-block, vilket gör det enklare att identifiera grundorsaken till krascher.
#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;
}Upptäcka datakorruption
Watchpoints (eller databrytpunkter) är ett mycket kraftfullt och avancerat felsökningsverktyg. De pausar körningen när innehållet på en specifik minnesadress ändras.
Detta är ovärderligt för att spåra mystisk datakorruption, särskilt i flertrådad kod eller kod som kan samverka med C, där värdet på en variabel ändras oväntat.
#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;
}Felsökning via kommandoraden (LLDB)
Även om Xcodes grafiska gränssnitt är bra är den underliggande debuggern LLDB (Low-Level Debugger). Genom att lära Er LLDB-kommandon får Ni mer detaljerad kontroll och djupare insikter, särskilt i komplexa situationer.
Ni kan skriva LLDB-kommandon direkt i Xcodes debuggerkonsol. Det är som att ha en superkraft för att undersöka och ändra programmets tillstånd i realtid!
Viktiga LLDB-kommandon
Här är några ofta använda LLDB-kommandon som hjälper Er att komma igång:
po <expression>: Print Object (visar en beskrivning av ett Objective-C-objekt).p <expression>: Print (visar värdet för en primitiv typ eller en C-struktur).bt: Backtrace (visar anropsstacken och är användbart för att förstå hur Ni hamnade här).vellerframe variable: Visar lokala variabler i den aktuella stackramen.continue: Återupptar programmets körning.next/n: Stegar över en kodrad.step/s: Stegar in i en funktion eller metod.
#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;
}Strukturerad loggning med `os_log`
För produktionsappar och komplexa system kan NSLog vara ineffektivt. Apple introducerade Unified Logging med os_log, som erbjuder strukturerad, effektiv och integritetsmedveten loggning.
Det är avgörande för företagsappar eftersom det ger bättre felsökning i releasebyggen och systemomfattande logganalys, med mer sammanhang och kontroll över loggarna.
#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;
}Felsökningsutmaning
Ni spårar ett fel där heltalsvariabeln counter ibland ändras oväntat. Det är en komplex äldre kodbas med många trådar.
Sammanfattning av avancerad felsökning
Bra jobbat! Ni har bemästrat avancerade felsökningstekniker för Objective-C.
- Villkorsstyrda brytpunkter och åtgärdsbrytpunkter ger exakt kontroll över när och hur programmet pausar eller loggar.
- Symboliska brytpunkter och undantagsbrytpunkter fångar specifika händelser, som metodanrop eller kastade fel.
- Watchpoints är ovärderliga för att spåra mystisk datakorruption.
- LLDB-kommandon ger kraftfull kontroll via konsolen för att undersöka programmets tillstånd.
os_logerbjuder strukturerad och effektiv loggning för komplexa appar och produktionsappar.
Dessa verktyg kommer avsevärt att förbättra Er förmåga att felsöka komplexa problem i alla Objective-C-kodbaser.
Lär dig Objective-C med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Avancerade felsökningstekniker” gratis?
Ja – hela texten till ”Avancerade felsökningstekniker” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Objective-C för iOS-utveckling av äldre appar och företagsappar, kan Ni uppgradera till CoddyKit PRO. Kursen i Objective-C för iOS-utveckling av äldre appar och företagsappar innehåller totalt 4 lektioner.
Vad lär jag mig i ”Avancerade felsökningstekniker”?
Bemästra Xcodes debugger, breakpoints och strategier för loggning för att felsöka komplexa problem i Objective-C-kodbaser. Ni övar på Objective-C för iOS-utveckling av äldre appar och företagsappar med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Objective-C för iOS-utveckling av äldre appar och företagsappar?
Du behöver inga förkunskaper. Utbildningen i Objective-C för iOS-utveckling av äldre appar och företagsappar på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Avancerade felsökningstekniker”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Objective-C för iOS-utveckling av äldre appar och företagsappar-lektionen?
Ja. Varje Objective-C för iOS-utveckling av äldre appar och företagsappar-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Identifiera minnesläckor med Instruments
- Optimera rendering och responsivitet i användargränssnitt
- Avancerade felsökningstekniker
- Profilera och minska appens starttid