Swift Academy · Lekcja

Podstawy Result<Success, Failure>

Tworzenie wartości Result i dopasowywanie do wzorców w celu jawnej obsługi błędów.

Lekcja 1 z 412 kroki

Podstawy Result<Success, Failure> 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

`Result` to typ wyliczeniowy Swift z dwoma przypadkami — `.success` i `.failure` — zapewniający jawne obsługiwanie błędów bez składni throws/catch.

Deklarowanie Result

```swift func divide(_ a: Double, by b: Double) -> Result { guard b != 0 else { return .failure(.divisionByZero) } return .success(a / b) } enum DivisionError: Error { case divisionByZero } ```

Korzystanie z Result

```swift switch divide(10, by: 2) { case .success(let value): print("Result: \(value)") case .failure(let err): print("Error: \(err)") } ```

get() — zgłasza błąd przy niepowodzeniu

```swift let result = divide(10, by: 0) do { let value = try result.get() // throws DivisionError } catch { print(error) } ```

Przechowywanie wyników

```swift var cache: [URL: Result] = [:] cache[url] = .success(data) cache[url] = .failure(URLError(.notConnectedToInternet)) ```

Result w asynchronicznych interfejsach API

```swift func fetch(url: URL, completion: @escaping (Result) -> Void) { URLSession.shared.dataTask(with: url) { data, _, error in if let data { completion(.success(data)) } else { completion(.failure(error ?? URLError(.unknown))) } }.resume() } ```

Dopasowywanie wzorców za pomocą if case

```swift if case .success(let data) = result { process(data) } if case .failure(let err) = result { handle(err) } ```

Właściwości success i failure

```swift let r: Result = .success(42) print(r.success) // Optional(42) — non-nil on success print(r.failure) // nil ```

Inicjalizowanie z użyciem throws

```swift let result = Result { try JSONDecoder().decode(User.self, from: data) } // .success(user) or .failure(decodingError) ```

Porównywanie wyników

```swift let a: Result = .success(42) let b: Result = .success(42) // Cannot == directly unless Success/Failure are Equatable ```

Szybki test

Co robi `result.get()`, gdy Result ma wartość `.failure`?

Odpowiedz w interaktywnej lekcji

Podsumowanie

Najważniejsze informacje: • `Result` — jawne rozróżnienie sukcesu i niepowodzenia bez throws • `.success(value)` / `.failure(error)` — dwa przypadki • `.get()` zgłasza błąd przy niepowodzeniu • `Result { try ... }` łączy kod zgłaszający błędy z Result • Przydatny do przechowywania i przekazywania wyników odroczonych Następnie: map i flatMap dla Result.

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 122
Lekcje: 409

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Podstawy Result<Success, Failure>” jest bezpłatna?

Tak — pełny tekst „Podstawy Result<Success, Failure>” 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 „Podstawy Result<Success, Failure>”?

Tworzenie wartości Result i dopasowywanie do wzorców w celu jawnej obsługi błędó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 „Podstawy Result<Success, Failure>”?

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

Podstawy Result
map i flatMap dla Result
Niestandardowe typy błędów z LocalizedError
Łączenie Result z async/await

← Powrót do Swift Academy