Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper · leksjon

Svake kontra sterke referanser

Skjelne mellom sterke og svake referanser for å unngå retain-sykluser og håndtere objekters levetid effektivt.

Leksjon 3 av 411 trinn

Svake kontra sterke referanser er en gratis leksjon i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper inneholder totalt 4 leksjoner.

Forstå objekters levetid

I Objective-C er det avgjørende å håndtere et objekts levetid. Det innebærer å avgjøre når et objekt skal eksistere i minnet, og når det trygt kan fjernes.

Referanser er måten vi forteller systemet at vi «bryr oss om» et objekt og ønsker at det skal holdes i live. Det finnes to hovedtyper: strong og weak.

Sterke referanser: standarden

En strong-referanse er standardtypen for egenskaper og variabler i Objective-C når ARC (Automatic Reference Counting) brukes.

Den angir «eierskap» til et objekt.
Når et objekt har minst én strong-referanse, kan det ikke deallokeres.
Den øker objektets retain count og sørger for at det forblir i minnet.

Tenk på det som å holde godt fast i noe: Så lenge du holder det, blir det ikke borte.

Eksempel på en sterk referanse

La oss se en strong-referanse i praksis. Variabelen person1 har en strong-referanse til Person-objektet vårt. Legg merke til at dealloc-metoden kalles når objektet ikke lenger har noen strong-referanser.

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (strong, nonatomic) NSString *name;
- (void)sayHello;
@end

@implementation Person
- (void)sayHello {
    NSLog(@"Hello, my name is %@", self.name);
}
- (void)dealloc {
    NSLog(@"Person %@ is being deallocated.", self.name);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *person1 = [[Person alloc] init];
        person1.name = @"Alice";
        NSLog(@"Person '%@' created.", person1.name);
        [person1 sayHello];
        // person1 goes out of scope at the end of @autoreleasepool
        // The Person object will be deallocated.
    }
    return 0;
}

Problemet: retain-sykluser

Selv om sterke referanser er viktige, kan de føre til et vanlig problem med minnehåndtering som kalles en retain-syklus (eller en syklus med sterke referanser).

Dette skjer når to eller flere objekter har sterke referanser til hverandre og danner en lukket sløyfe. Fordi hvert objekt har en sterk referanse fra et annet objekt i syklusen, synker retain count aldri til null, og objektene blir aldri deallokert.

Illustrasjon av en retain-syklus

Se for deg at et Parent-objekt har en sterk referanse til et Child-objekt, og at dette Child-objektet også har en sterk referanse til sitt Parent-objekt.

Parent sier: «Jeg eier Child.»
Child sier: «Jeg eier Parent.»

Ingen av dem kan frigis fordi det andre objektet fortsatt holder på det, selv om ingen andre deler av appen trenger dem lenger. Dette fører til en minnelekkasje.

Introduksjon til svake referanser

Svake referanser (deklarert med __weak eller egenskapsattributtet weak) er laget for å bryte retain-sykluser.

De øker ikke objektets retain count.
De angir ikke eierskap.
Viktigst av alt: En svak referanse blir automatisk til nil når objektet den peker på, blir deallokert.

Denne virkemåten, der referansen settes til nil, er svært sikker og hindrer hengende pekere.

Slik fungerer svake referanser

Se hvordan en svak referanse oppfører seg. Når den siste sterke referansen til et objekt frigis, blir objektet deallokert, og alle svake referanser som peker på det, blir automatisk til nil.

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (strong, nonatomic) NSString *name;
- (void)dealloc;
@end

@implementation Person
- (void)dealloc {
    NSLog(@"Person %@ is being deallocated.", self.name);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *strongPerson = [[Person alloc] init];
        strongPerson.name = @"Bob";
        
        __weak Person *weakPerson = strongPerson;
        
        NSLog(@"Before nil: strongPerson = %@, weakPerson = %@", strongPerson.name, weakPerson.name);
        
        strongPerson = nil; // Release the strong reference
        NSLog(@"Strong reference set to nil.");
        
        if (weakPerson) {
            NSLog(@"Weak Person still exists: %@", weakPerson.name);
        } else {
            NSLog(@"Weak Person is now nil.");
        }
    }
    return 0;
}

Bryte retain-syklusen

For å bryte en retain-syklus bør én av referansene i syklusen være svak. I eksempelet vårt med Parent og Child er det vanlig at «child» har en svak referanse til «parent».

På denne måten eier parent child, mens child ikke eier parent, slik at begge kan deallokeres på riktig måte.

#import <Foundation/Foundation.h>

@interface Parent : NSObject
@property (strong, nonatomic) NSString *name;
@property (strong, nonatomic) id child; // Strong ref to child
- (void)dealloc;
@end

@interface Child : NSObject
@property (strong, nonatomic) NSString *name;
@property (weak, nonatomic) Parent *parent; // Weak ref to parent
- (void)dealloc;
@end

@implementation Parent
- (void)dealloc {
    NSLog(@"Parent %@ is being deallocated.", self.name);
}
@end

@implementation Child
- (void)dealloc {
    NSLog(@"Child %@ is being deallocated.", self.name);
}
@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Parent *myParent = [[Parent alloc] init];
        myParent.name = @"Mom";
        
        Child *myChild = [[Child alloc] init];
        myChild.name = @"Alice";
        
        myParent.child = myChild; // Parent strongly references Child
        myChild.parent = myParent; // Child weakly references Parent
        
        NSLog(@"Parent and Child created. Releasing strong variables...");
        // Both objects will be deallocated as strong references from outside
        // the objects are released and the weak link doesn't prevent deallocation.
    }
    return 0;
}

`weak` kontra `unsafe_unretained`

Du kan støte på __unsafe_unretained, som er en annen type referanse uten eierskap. Du bør imidlertid alltid foretrekke __weak.

__weak: Blir automatisk til nil når objektet deallokeres, og hindrer dermed krasj.
__unsafe_unretained: Blir IKKE til nil. Hvis objektet deallokeres, blir referansen en hengende peker, noe som fører til krasj hvis du prøver å få tilgang til den.

__weak er det sikreste og vanligste valget i moderne Objective-C med ARC.

Test kunnskapene dine

Hvilket utsagn beskriver best hovedformålet med en svak referanse i Objective-C med ARC?

Besvar den i den interaktive leksjonen

Oppsummering: sterke kontra svake referanser

Vi har utforsket den viktige forskjellen mellom sterke og svake referanser:

Sterke referanser: Standard, angir eierskap, øker retain count og holder objekter i live.
Svake referanser: Angir ikke eierskap, øker ikke retain count, blir automatisk til nil og er avgjørende for å bryte retain-sykluser.

Å forstå når du skal bruke hver av dem, er viktig for å forhindre minnelekkasjer og skrive robust Objective-C-kode.

Gratis å komme i gang

Lær deg Objective-C med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Svake kontra sterke referanser» gratis?

Ja – hele teksten i «Svake kontra sterke referanser» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper inneholder totalt 4 leksjoner.

Hva lærer jeg i «Svake kontra sterke referanser»?

Skjelne mellom sterke og svake referanser for å unngå retain-sykluser og håndtere objekters levetid effektivt. Du øver på Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper?

Ingen tidligere erfaring er nødvendig. Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Svake kontra sterke referanser»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-leksjonen?

Ja. Alle Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Grunnleggende om manuell retain-release (MRR)
Automatisk referansetelling (ARC)
Svake kontra sterke referanser
Bryte retain-sykluser i blokker

← Tilbake til Objective-C iOS-utvikling for eldre kodebaser og virksomhetsapper