0Pricing
Swift Academy · Lekcja

Tworzenie niestandardowego wrappera właściwości

Implementowanie @propertyWrapper z wrappedValue w celu hermetyzacji logiki.

Tworzenie niestandardowego wrappera właściwości to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 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

Wrappery właściwości enkapsulują logikę przechowywania właściwości, umożliwiając ponowne użycie powtarzalnego kodu, takiego jak walidacja, transformacja czy utrwalanie danych.

Podstawowa składnia

```swift @propertyWrapper struct Clamped { var wrappedValue: Int { didSet { wrappedValue = min(max(0,wrappedValue),100) } } init(wrappedValue: Int) { self.wrappedValue = min(max(0,wrappedValue),100) } } struct Gauge { @Clamped var level = 50 } var g = Gauge() g.level = 150 // clamped to 100 ```

Wymóg wrappedValue

Każdy wrapper właściwości musi definiować `wrappedValue`. To właśnie tę wartość użytkownik wrappera odczytuje i zapisuje.

Generyczne wrappery właściwości

```swift @propertyWrapper struct Logged { private var value: T var wrappedValue: T { get { print("get"); return value } set { print("set to \(newValue)"); value = newValue } } init(wrappedValue: T) { value = wrappedValue } } ```

Używanie wrappera

```swift struct Model { @Logged var name: String = "Default" } var m = Model() let n = m.name // prints "get" m.name = "Alice" // prints "set to Alice" ```

Niestandardowe argumenty inicjalizatora

```swift @propertyWrapper struct Default { var wrappedValue: T init(wrappedValue: T) { self.wrappedValue = wrappedValue } init(_ default: T) { wrappedValue = default } } @Default(42) var count: Int ```

Wrapper dla właściwości przechowywanej a obliczanej

Wrappery właściwości dodają ukryte przechowywanie (`_wrappedValue`). Opatrzona adnotacją właściwość jest cukrem składniowym: ```swift @Clamped var level = 50 // Desugars to: var _level = Clamped(wrappedValue: 50) var level: Int { get { _level.wrappedValue } set { _level.wrappedValue = newValue } } ```

Wrapper UserDefaults

```swift @propertyWrapper struct UserDefault { let key: String; let defaultValue: T var wrappedValue: T { get { UserDefaults.standard.object(forKey: key) as? T ?? defaultValue } set { UserDefaults.standard.set(newValue, forKey: key) } } } @UserDefault(key:"theme",defaultValue:"light") var theme: String ```

Wrapper bezpieczny dla wątków

```swift @propertyWrapper final class Atomic { private var value: T; private let lock = NSLock() var wrappedValue: T { get { lock.lock(); defer { lock.unlock() }; return value } set { lock.lock(); defer { lock.unlock() }; value = newValue } } init(wrappedValue: T) { value = wrappedValue } } ```

Łączenie wrapperów w typie

```swift struct Settings { @Clamped var volume = 50 @UserDefault(key:"username",defaultValue:"") var username: String @Logged var debugMode = false } ```

Szybkie sprawdzenie

Jaka właściwość jest wymagana w każdym typie `@propertyWrapper`?

Podsumowanie

Najważniejsze wnioski: • `@propertyWrapper` + `wrappedValue` = minimalny wrapper właściwości • Wrapper dodaje ukryte przechowywanie `_name` • Generyczne wrappery działają z dowolnym typem T • Typowe zastosowania: ograniczanie wartości, rejestrowanie, UserDefaults, bezpieczeństwo wątkowe • Niestandardowe argumenty inicjalizatora umożliwiają konfigurację Dalej: wartości projekcji.

Często zadawane pytania

Czy lekcja „Tworzenie niestandardowego wrappera właściwości” jest bezpłatna?

Tak — pełny tekst „Tworzenie niestandardowego wrappera właściwości” 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 „Tworzenie niestandardowego wrappera właściwości”?

Implementowanie @propertyWrapper z wrappedValue w celu hermetyzacji logiki. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Tworzenie niestandardowego wrappera właściwości”?

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

  1. Tworzenie niestandardowego wrappera właściwości
  2. Wartości projekcji za pomocą $binding
  3. @Published i obserwacja w Combine
  4. Kompozycja wielu wrapperów właściwości
← Powrót do Swift Academy