Swift Academy · Lekcja

Odwołania weak i unowned

Wybór między weak (Optional) a unowned (nie-Optional) w celu przerwania cykli.

Odwołania weak i unowned to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Aby przerwać cykle retencji, należy używać referencji, które nie zwiększają licznika ARC. Swift udostępnia dwa takie rodzaje: `weak` (opcjonalny, automatycznie zerowany) oraz `unowned` (nieopcjonalny, niebezpieczny, jeśli obiekt ma wartość nil).

Referencje weak

```swift class Owner { var pet: Pet? } class Pet { weak var owner: Owner? } // does not retain var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p p?.owner = o o = nil // Owner deinit — p.owner becomes nil automatically ```

weak zawsze jest opcjonalne

```swift class View { weak var delegate: ViewDelegate? } ``` `weak` musi być zadeklarowane jako `var` i mieć typ opcjonalny — Swift automatycznie zeruje tę referencję, gdy wskazywany obiekt zostaje dealokowany.

Referencje unowned

```swift class Customer { var card: CreditCard? } class CreditCard { unowned let customer: Customer // card always has a customer init(customer: Customer) { self.customer = customer } } ``` `unowned` nie zwiększa licznika referencji i nie jest opcjonalne — gwarantują Państwo, że wskazywany obiekt będzie istniał dłużej niż ten obiekt.

Wybór między weak a unowned

| Sytuacja | Należy użyć | |---|---| | Wskazywany obiekt może przyjąć wartość nil | `weak` | | Wskazywany obiekt zawsze istnieje dłużej niż bieżący | `unowned` | | Brak pewności | `weak` (bezpieczniejsze) |

Dostęp do unowned po dealokacji

```swift var customer: Customer? = Customer() var card = CreditCard(customer: customer!) customer = nil print(card.customer.name) // 💥 crash — unowned is dangling ``` Nigdy nie należy uzyskiwać dostępu do `unowned` po dealokacji wskazywanego obiektu.

[weak self] w domknięciach

```swift class VC { func load() { api.fetch { [weak self] data in guard let self else { return } self.render(data) } } } ``` `[weak self]` to najczęściej stosowany sposób naprawiania cykli retencji w Swift.

[unowned self] w domknięciach

```swift class Session { var onComplete: (() -> Void)? init() { onComplete = { [unowned self] in // self always outlives closure self.finish() } } } ``` `[unowned self]` należy stosować wyłącznie wtedy, gdy mają Państwo pewność, że `self` nie będzie mieć wartości nil w momencie wykonania domknięcia.

Automatyczne zerowanie obserwowanej referencji

```swift class Timer { weak var delegate: TimerDelegate? } var d: TimerDelegate? = ConcreteDelegate() let t = Timer() t.delegate = d d = nil print(t.delegate) // nil — automatically zeroed ```

Najlepsza praktyka dla wzorca delegata

Właściwości delegatów należy zawsze deklarować jako `weak`: ```swift protocol MyDelegate: AnyObject { func didUpdate() } class MyView { weak var delegate: MyDelegate? } ``` Ograniczenie `AnyObject` jest wymagane, aby używać `weak` z protokołami.

Szybkie sprawdzenie

Który rodzaj referencji jest automatycznie ustawiany na `nil`, gdy wskazywany obiekt zostaje dealokowany?

Podsumowanie

Najważniejsze informacje: • `weak` — opcjonalne, automatycznie zerowane, bezpieczne • `unowned` — nieopcjonalne, zakłada, że obiekt wskazywany istnieje dłużej, a w razie błędu powoduje awarię • Wzorzec delegata: zawsze `weak var delegate: Protocol?` z ograniczeniem `AnyObject` • Domknięcia: `[weak self]` to standardowy wzorzec; wewnątrz należy używać `guard let self` • W razie wątpliwości należy wybrać `weak` zamiast `unowned` Następny temat: listy przechwytywania domknięć.

Często zadawane pytania

Czy lekcja „Odwołania weak i unowned” jest bezpłatna?

Tak — pełny tekst „Odwołania weak i unowned” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Odwołania weak i unowned”?

Wybór między weak (Optional) a unowned (nie-Optional) w celu przerwania cykli. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Odwołania weak i unowned”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Jak ARC zlicza odwołania
Cykle retain: przyczyny i wykrywanie
Odwołania weak i unowned
Listy przechwytywania domknięć i [weak self]

← Powrót do Swift Academy