Swift Academy · Lekcja

Inicjalizatory składowe i niestandardowe inicjalizatory

Poznanie automatycznie generowanych inicjalizatorów składowych oraz tworzenie własnych inicjalizatorów.

Inicjalizatory składowe i niestandardowe inicjalizatory 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.

Witamy

Struktury języka Swift otrzymują bezpłatny *inicjalizator składowy*, który przyjmuje wszystkie przechowywane właściwości. Można jednak dostosować go lub rozszerzyć za pomocą własnej logiki inicjalizatora.

Automatycznie generowany inicjalizator składowy

```swift struct Point { var x: Double var y: Double } let p = Point(x: 3.0, y: 4.0) // auto-generated init ``` Nie trzeba samodzielnie pisać `init` — kompilator udostępnia taki inicjalizator.

Dodawanie własnego inicjalizatora

```swift struct Circle { var radius: Double var area: Double init(radius: Double) { self.radius = radius self.area = .pi * radius * radius } } let c = Circle(radius: 5.0) ```

Zachowanie inicjalizatora składowego

Zdefiniowanie własnego inicjalizatora wyłącza automatycznie generowany inicjalizator składowy. Aby zachować oba, należy umieścić własny inicjalizator w rozszerzeniu: ```swift struct Rect { var width: Double; var height: Double } extension Rect { init(square side: Double) { self.init(width: side, height: side) } } // Both Rect(width:height:) and Rect(square:) available ```

Domyślne wartości właściwości

```swift struct Config { var debug = false var maxRetries = 3 var timeout: TimeInterval = 30 } let c1 = Config() // all defaults let c2 = Config(debug: true) // memberwise with overrides ```

Delegowanie inicjalizacji za pomocą self.init

```swift struct Temperature { var celsius: Double init(celsius: Double) { self.celsius = celsius } init(fahrenheit: Double) { self.init(celsius: (fahrenheit - 32) / 1.8) } init(kelvin: Double) { self.init(celsius: kelvin - 273.15) } } ```

Inicjalizatory failable

```swift struct Percentage { let value: Double init?(_ value: Double) { guard (0...100).contains(value) else { return nil } self.value = value } } let p = Percentage(105) // nil ```

Inicjalizacja z walidacją

```swift struct Username { let value: String init?(_ raw: String) { let trimmed = raw.trimmingCharacters(in: .whitespaces) guard trimmed.count >= 3 else { return nil } self.value = trimmed } } ```

Inicjalizacja struktury a inicjalizacja klasy

Najważniejsze różnice w porównaniu z inicjalizatorami klas: • Struktury mogą delegować inicjalizację za pomocą `self.init()` • Struktury nie dziedziczą inicjalizatorów (brak `super.init()`) • Wszystkie przechowywane właściwości muszą zostać zainicjalizowane przed użyciem • Brak słów kluczowych `required` oraz `designated` / `convenience`

Podgląd init(from decoder:)

Struktury zgodne z `Decodable` otrzymują automatyczny inicjalizator: ```swift struct User: Decodable { let name: String let age: Int } // Auto-synthesised init(from:) for JSON decoding let user = try JSONDecoder().decode(User.self, from: json) ```

Szybkie sprawdzenie

Gdzie należy umieścić własny inicjalizator, aby zachować automatycznie generowany inicjalizator składowy?

Podsumowanie

Najważniejsze informacje: • Struktury otrzymują od kompilatora bezpłatny inicjalizator składowy • Własne inicjalizatory w treści struktury wyłączają inicjalizator składowy • Umieszczaj własne inicjalizatory w rozszerzeniach, aby zachować oba • Używaj `self.init()`, aby delegować inicjalizację między inicjalizatorami • Inicjalizatory failable zwracają `nil` dla nieprawidłowych danych wejściowych Dalej: przechowywane właściwości i obserwatory właściwości.

Często zadawane pytania

Czy lekcja „Inicjalizatory składowe i niestandardowe inicjalizatory” jest bezpłatna?

Tak — pełny tekst „Inicjalizatory składowe i niestandardowe inicjalizatory” 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 „Inicjalizatory składowe i niestandardowe inicjalizatory”?

Poznanie automatycznie generowanych inicjalizatorów składowych oraz tworzenie własnych inicjalizatorów. Ć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 „Inicjalizatory składowe i niestandardowe inicjalizatory”?

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

Inicjalizatory składowe i niestandardowe inicjalizatory
Przechowywane właściwości i obserwatory właściwości
Właściwości obliczane w strukturach
Metody mutujące i semantyka Copy-on-Write

← Powrót do Swift Academy