Swift jest językiem bezpiecznym dla typów, co oznacza, że język pomaga jasno określić typy wartości, które może zawierać Twój kod pracuj z. Jeśli część kodu spodziewa się ciągu znaków, Typ safety uniemożliwia podanie przez pomyłkę Int.

W Swift, każdy typ może być opcjonalny . Wartość opcjonalna może przyjąć dowolną wartość z oryginalnego typu, lub wartość specjalna nil.

Opcje są zdefiniowane za pomocą przyrostka ? na typ:

var anInt: Int = 42
var anOptionalInt: Int? = 42
var anotherOptionalInt: Int?    // `nil` is the default when no value is provided

Brak wartości w opcji jest oznaczany przez nil:

anOptionalInt = nil

^{(zauważ, że to {[26] } nie jest tym samym co nil W Objective-C. w Objective-C, nil oznacza brak ważnego wskaźnika obiektu; W Swift opcje nie są ograniczone do obiektów/typów referencyjnych. Opcjonalne zachowuje się podobnie do Haskella Maybe .)}

Dlaczego otrzymałem " fatal error: nieoczekiwanie znaleziono zero podczas rozpakowywania opcjonalnej wartości"?

W celu uzyskania dostępu do opcjonalnego wartość (jeśli w ogóle ma taką wartość), musisz ją rozpakować . Wartość opcjonalną można rozpakować bezpiecznie lub siłą. Jeśli wymusisz rozpakowanie opcji, a nie ma wartości, Twój program zawiesi się z powyższym Komunikatem.

Xcode pokaże Ci awarię, podświetlając linię kodu. Problem występuje na tej linii.

Ten wypadek może wystąpić z dwoma różnymi rodzajami siły-rozpakowania:

1. Explicit Siła Rozpakowywania

Odbywa się to za pomocą operatora ! na opcjonalnym. Na przykład:

let anOptionalString: String?
print(anOptionalString!) // <- CRASH

Ponieważ anOptionalString jest nil tutaj, dostaniesz awarię na linii, gdzie wymusisz jej rozpakowanie.

2. Bezwarunkowo Rozpakowane Opcje

Są one definiowane przez !, a nie ? po typie.

var optionalDouble: Double!   // this value is implicitly unwrapped wherever it's used

Zakłada się, że te opcje zawierają wartość. Dlatego za każdym razem, gdy uzyskasz dostęp do niejawnie rozpakowanej opcji, Automatycznie być siłą rozpakowany dla Ciebie. Jeśli nie zawiera wartości, ulegnie awarii.

print(optionalDouble) // <- CRASH

Aby ustalić, która zmienna spowodowała awarię, możesz przytrzymać ⌥ podczas klikania, aby wyświetlić definicję, gdzie można znaleźć opcjonalny Typ.

Iboutlety, w szczególności, są zwykle domyślnie rozpakowanymi opcjami. Dzieje się tak dlatego, że Twój xib lub storyboard połączy gniazda w czasie wykonywania, po inicjalizacji. W związku z tym należy upewnij się, że nie masz dostępu do gniazdek przed ich załadowaniem. Należy również sprawdzić, czy połączenia są poprawne w pliku storyboard / xib, w przeciwnym razie wartości będą nil w czasie wykonywania, a zatem ulegną awarii, gdy zostaną domyślnie rozpakowane.

Kiedy mam wymusić rozpakowanie opcji?

Explicit Force Unwrapping

Ogólnie rzecz biorąc, nigdy nie należy wymusić rozpakowywania opcji za pomocą operatora !. Mogą wystąpić przypadki gdzie użycie ! jest dopuszczalne – ale powinieneś używać go tylko wtedy, gdy masz 100% pewności, że opcja zawiera wartość.

Chociaż istnieje może być okazja, gdzie można użyć siły rozpakowywania, jak wiesz dla fakt , że opcjonalny zawiera wartość – nie ma pojedynczego miejsca, w którym nie można bezpiecznie rozpakować tego opcjonalnego zamiast.

Implicite Unwrapped Optionals

Te zmienne są zaprojektowane tak, aby można było odroczyć ich przypisanie na później w kodzie. To jest Twój odpowiedzialność, aby upewnić się, że mają wartość, zanim uzyskasz do nich dostęp. Jednakże, ponieważ wiążą się one z siłą rozpakowywania, nadal są z natury niebezpieczne – ponieważ {126]}zakładają {127]}, że twoja wartość nie jest zerowa, nawet jeśli przypisanie nil jest ważne.

Powinieneś używać tylko domyślnie rozpakowanych opcji jako w ostateczności . Jeśli możesz użyć lazy zmienna , lub podać wartość domyślną dla zmiennej – powinieneś to zrobić zamiast używać domyślnie rozpakowanego opcjonalnego.

Jednak istnieje kilka scenariuszy, w których domyślnie rozpakowane opcje są korzystne, i nadal możesz używać różnych sposobów bezpiecznego rozpakowywania ich, jak wymieniono poniżej – ale powinieneś {126]}zawsze {127]} używać ich z należytą ostrożnością.

Jak mogę bezpiecznie poradzić sobie z opcjami?

Najprostszy można sprawdzić, czy opcja zawiera wartość, porównując ją z nil.

if anOptionalInt != nil {
    print("Contains a value!")
} else {
    print("Doesn’t contain a value.")
}

Jednak w 99,9% przypadków podczas pracy z opcjami, będziesz chciał uzyskać dostęp do wartości, które zawiera, jeśli w ogóle ją zawiera. Aby to zrobić, możesz użyć opcjonalnego wiązania.

Oprawa Opcjonalna

Opcjonalne Wiązanie pozwala sprawdzić, czy opcja zawiera wartość – i pozwala przypisać rozpakowaną wartość do nowej zmiennej lub stałej. Wykorzystuje składnia if let x = anOptional {...} lub if var x = anOptional {...}, w zależności od tego, czy trzeba zmodyfikować wartość nowej zmiennej po jej powiązaniu.

Na przykład:

if let number = anOptionalInt {
    print("Contains a value! It is \(number)!")
} else {
    print("Doesn’t contain a number")
}

Najpierw sprawdza, czy opcja zawiera wartość. Jeśli robi , to wartość' unwrapped ' jest przypisana do nowej zmiennej (number) – którą możesz swobodnie używać, jakby nie była opcjonalna. Jeśli opcjonalne nie zawiera wartości, to zostanie wywołana klauzula else, tak jak spodziewaj się.

Co jest fajne w opcjonalnym wiązaniu, to można rozpakować wiele opcji w tym samym czasie. Możesz po prostu oddzielić wypowiedzi przecinkiem. Oświadczenie powiedzie się, jeśli wszystkie opcje zostaną rozpakowane.

var anOptionalInt : Int?
var anOptionalString : String?

if let number = anOptionalInt, let text = anOptionalString {
    print("anOptionalInt contains a value: \(number). And so does anOptionalString, it’s: \(text)")
} else {
    print("One or more of the optionals don’t contain a value")
}

Kolejna fajna sztuczka polega na tym, że można również użyć przecinków, aby sprawdzić określony warunek na wartości, po rozpakowaniu go.

if let number = anOptionalInt, number > 0 {
    print("anOptionalInt contains a value: \(number), and it’s greater than zero!")
}

Jedynym haczykiem z użyciem opcjonalnego wiązania wewnątrz instrukcji if jest to, że możesz uzyskać dostęp tylko do unwrapped value from within the scope of the statement. Jeśli potrzebujesz dostępu do wartości spoza zakresu instrukcji, możesz użyć instrukcji guard .

A Instrukcja guard pozwala zdefiniować warunek sukcesu – a bieżący zakres będzie nadal wykonywany tylko wtedy, gdy warunek ten jest spełniony. Są one zdefiniowane za pomocą składni guard condition else {...}.

guard let number = anOptionalInt else {
    return
}

^{(Uwaga że wewnątrz Korpusu Strażników, musisz użyć jednej z instrukcji transferu kontrolnego , aby wyjść z zakresu aktualnie wykonywanego kodu).}

Jeśli anOptionalInt zawiera wartość, zostanie ona rozpakowana i przypisana do nowej stałej number. Kod po strażnik będzie kontynuował wykonywanie. Jeśli nie zawiera wartości – strażnik wykona kod w nawiasach, co doprowadzi do przeniesienia kontroli, tak aby Kod natychmiast po nie zostanie wykonana.

Prawdziwą zaletą instrukcji guard jest to, że wartość unwrapped jest teraz dostępna do użycia w kodzie, który podąża za instrukcją (ponieważ wiemy, że przyszły kod może tylko wykonać, jeśli opcja ma wartość). Jest to świetne rozwiązanie do wyeliminowania 'pyramids of doom' stworzonego przez zagnieżdżenie wielu poleceń if.

Na przykład:

guard let number = anOptionalInt else {
    return
}

print("anOptionalInt contains a value, and it’s: \(number)!")

Strażnicy również wspierają te same sprytne sztuczki, które twierdzenie if obsługiwane, takie jak rozpakowanie wielu opcji jednocześnie i użycie klauzuli where.

To, czy użyjesz instrukcji if czy guard, zależy całkowicie od tego, czy jakikolwiek przyszły kod wymaga opcjonalnego, aby zawierał wartość.

Operator Zerowy

Zerowy Operator koalescencyjny jest sprytną skróconą wersją trójdzielnego operatora warunkowego , zaprojektowanego głównie do konwersji opcji na opcje nieobsługiwane. Posiada składnia a ?? b, gdzie a jest typem opcjonalnym, a {[53] } jest tym samym typem co a (chociaż zwykle nie jest opcjonalny).

Zasadniczo pozwala powiedzieć " jeśli a zawiera wartość, rozpakuj ją. If it doesn 't then return b instead". Na przykład możesz go użyć w następujący sposób:

let number = anOptionalInt ?? 0

To zdefiniuje number stałą typu Int, która będzie zawierać wartość anOptionalInt, jeśli zawiera wartość, lub 0 W przeciwnym razie.

To tylko skrót za:

let number = anOptionalInt != nil ? anOptionalInt! : 0

Opcjonalne Łańcuchowanie

Możesz użyć opcjonalnego łańcucha w celu wywołania metody lub uzyskania dostępu do właściwości na opcjonalnym. Jest to po prostu zrobione przez dodanie nazwy zmiennej ? podczas jej używania.

Na przykład, powiedzmy, że mamy zmienną foo, o typie opcjonalnej instancji Foo.

var foo : Foo?

Jeśli chcemy wywołać metodę na foo, która niczego nie zwraca, możemy po prostu zrobić: {116]}

foo?.doSomethingInteresting()

Jeśli foo zawiera value, ta metoda zostanie na niej wywołana. Jeśli tak się nie stanie, nic złego się nie stanie – kod będzie po prostu kontynuowany.

^{(jest to podobne zachowanie do wysyłania wiadomości do nil W Objective-C)}

Może to być również używane do ustawiania właściwości oraz metod wywołania. Na przykład:

foo?.bar = Bar()

Ponownie, nic złego się tu nie stanie, jeśli foo jest nil. Twój kod będzie po prostu kontynuowany.

Kolejna fajna sztuczka, która chaining pozwala sprawdzić, czy ustawienie właściwości lub wywołanie metody zakończyło się sukcesem. Można to zrobić porównując wartość zwracaną do nil.

^{(to dlatego, że opcjonalna wartość zwróci Void? zamiast Void w metodzie, która niczego nie zwraca)}

Na przykład:

if (foo?.bar = Bar()) != nil {
    print("bar was set successfully")
} else {
    print("bar wasn’t set successfully")
}

Jednak sytuacja staje się nieco trudniejsza, gdy próbuje uzyskać dostęp do Właściwości lub metod wywołania, które zwracają wartość. Ponieważ {[62] } jest opcjonalne, wszystko, co z niego zostanie zwrócone, będzie również opcjonalne. Aby sobie z tym poradzić, możesz albo rozpakować opcje zwracane przy użyciu jednej z powyższych metod – albo rozpakować {62]} przed uzyskaniem dostępu do metod lub wywołaniem metod zwracających wartości.

Ponadto, jak sama nazwa wskazuje, możesz "połączyć" te stwierdzenia. Oznacza to, że jeśli foo ma opcjonalną właściwość baz, która ma właściwość {–76]} - możesz napisać co następuje:

let optionalQux = foo?.baz?.qux

Ponownie, ponieważ foo i baz są opcjonalne, wartość zwracana z qux zawsze będzie opcjonalna niezależnie od tego, czy sama qux jest opcjonalna.

map i flatMap

Często nieużywaną funkcją z opcjami jest możliwość korzystania z funkcji map i flatMap. Umożliwiają one stosowanie nieobowiązkowych przekształceń do zmiennych opcjonalnych. Jeśli opcja ma wartość, można zastosować do niej daną transformację. Jeśli nie ma wartości, pozostanie nil.

Na przykład, Załóżmy, że masz opcjonalny ciąg znaków:

let anOptionalString:String?

Poprzez zastosowanie do niego funkcji {[81–} - możemy użyć funkcji stringByAppendingString, aby połączyć ją z innym łańcuchem znaków.

Ponieważ stringByAppendingString pobiera nieobowiązkowy argument string, nie możemy bezpośrednio wprowadzić naszego opcjonalnego ciągu. Jednak, używając map, możemy użyć allow stringByAppendingString, jeśli anOptionalString ma wartość.

Na przykład:

var anOptionalString:String? = "bar"

anOptionalString = anOptionalString.map {unwrappedString in
    return "foo".stringByAppendingString(unwrappedString)
}

print(anOptionalString) // Optional("foobar")

Jeśli jednak anOptionalString nie ma wartości, map zwróci nil. Na przykład:

var anOptionalString:String?

anOptionalString = anOptionalString.map {unwrappedString in
    return "foo".stringByAppendingString(unwrappedString)
}

print(anOptionalString) // nil

flatMap działa podobnie do map, z tym, że pozwala zwrócić inny opcjonalny z wewnątrz ciała zamknięcia. Oznacza to, że możesz wprowadzić opcjonalne do procesu, który wymaga nieobowiązkowego wejścia, ale może sam wyjść opcjonalne.

try!

System obsługi błędów Swift może być bezpiecznie używany z Do-Try-Catch :

do {
    let result = try someThrowingFunc() 
} catch {
    print(error)
}

Jeśli someThrowingFunc() wyrzuci błąd, błąd zostanie bezpiecznie złapany w catch blok.

Stała error widoczna w bloku catch nie została przez nas zadeklarowana - jest automatycznie generowana przez catch.

Możesz również zadeklarować error samodzielnie, ma tę zaletę, że jest w stanie wrzucić go do użytecznego formatu, na przykład:

do {
    let result = try someThrowingFunc()    
} catch let error as NSError {
    print(error.debugDescription)
}

Używanie try w ten sposób jest właściwym sposobem na próbowanie, wychwytywanie i radzenie sobie z błędami wynikającymi z funkcji rzucania.

Istnieje również try? który pochłania błąd:

if let result = try? someThrowingFunc() {
    // cool
} else {
    // handle the failure, but there's no error information available
}

Ale System obsługi błędów Swift zapewnia również sposób na "wymuszenie próby" za pomocą try!:

let result = try! someThrowingFunc()

Pojęcia wyjaśnione w tym poście również mają zastosowanie tutaj: jeśli błąd zostanie wyrzucony, aplikacja ulegnie awarii.

powinieneś używać try! tylko wtedy, gdy możesz udowodnić, że jego wynik nigdy nie zawiedzie w Twoim kontekście - i to jest bardzo rzadkie.

Przez większość czasu będziesz używać kompletnego systemu Do-Try-Catch - i opcjonalnego, try?, W rzadkich przypadkach, gdy obsługa błędu nie jest ważna.

Zasoby

• dokumentacja Apple na temat opcji Swift
• kiedy używać i kiedy nie używać domyślnie rozpakowanych opcji
• dowiedz się, jak debugować awarię aplikacji na iOS