Difference Between try, try? and try! and When to Use Them in Swift
Zusammenfassung
Kurz
Der vollständige Artikel erklärt `try` zum Abfangen oder Weiterreichen von Fehlern, `try?` zum Umwandeln eines Fehlschlags in `nil` und `try!` als Variante, die bei einem Fehler zum Absturz führt. Der Autor empfiehlt `try` für gezielte Fehlerbehandlung, `try?` bei unwichtiger Fehlerursache und `try!` nur bei garantiert ausbleibendem Fehler oder zum Debuggen; für Produktionscode rät er generell zu sicherer Behandlung.
Mittel
Der vollständige Artikel erklärt die Unterschiede zwischen `try`, `try?` und `try!` in Swift anhand einer Funktion, die einen Fehler auslöst. Mit `try` kann der Fehler in einem `do-catch`-Block behandelt oder an eine weitere fehlerwerfende Funktion weitergereicht werden. Der Autor empfiehlt diese Form, wenn der Fehler ausgewertet oder etwa für eine Meldung genutzt werden soll.
`try?` macht das Ergebnis optional und liefert bei einem Fehler `nil`; die Fehlerursache wird dabei nicht behandelt. Laut Artikel passt das, wenn ein Fehlschlag lediglich dazu führen soll, dass der weitere Ablauf frühzeitig endet. `try!` erzwingt den Aufruf und lässt die Anwendung bei einem Fehler abstürzen. Der Beitrag hält es für Fälle mit garantiert ausbleibendem Fehler oder zum Debuggen für denkbar, rät aber allgemein davon ab, Werte in Produktionsanwendungen erzwungen auszupacken.
Die Beispiele zeigen die drei Verhaltensweisen mit einer Funktion, die einen selbst definierten Fehler wirft. Der Artikel bietet eine grundlegende Einführung; seine Einsatzempfehlungen stammen vom Autor und eine umfassende Behandlung von Randfällen ist nicht enthalten.
Ausführlich lesen
Der vollständige Bericht ist ein Tutorial von Chase über die drei Schreibweisen `try`, `try?` und `try!` in Swift. Anhand einer Beispiel-Funktion, die einen Fehler wirft, erläutert der Autor, wie sich die Varianten beim Aufruf einer fehlerwerfenden Funktion unterscheiden und wann sie laut Artikel sinnvoll sind.
Mit einfachem `try` bleibt der Fehler sichtbar: Er kann direkt in einem `do-catch`-Block abgefangen und dort etwa protokolliert oder in eine hilfreiche Meldung für Nutzende übersetzt werden. Alternativ kann die aufrufende Funktion ebenfalls als fehlerwerfend markiert werden, sodass der Fehler weitergereicht wird. Der Artikel empfiehlt diese Form, wenn der Fehler sicher behandelt werden soll, und weist darauf hin, dass er andernfalls später abgefangen werden müsse.
`try?` wandelt einen Aufruf laut Beitrag in einen optionalen Wert um: Tritt ein Fehler auf, ergibt sich `nil`; der Fehler selbst wird dabei nicht behandelt. Der Autor schlägt diese Variante vor, wenn die konkrete Fehlerursache unwichtig ist und ein Fehlschlag lediglich einen weiteren Ablauf verhindern soll. Als Beispiel zeigt er eine `guard`-Anweisung, die bei `nil` frühzeitig aus einer Funktion zurückkehrt.
`try!` wird als erzwungene Variante beschrieben. Wirft der Aufruf einen Fehler, stürzt das Programm ab. Der Beitrag nennt als mögliche Einsatzfälle Situationen, in denen garantiert sei, dass kein Fehler auftritt, sowie die Fehlersuche in komplexen Anwendungen. Für solche Fälle regt der Autor an, stattdessen gegebenenfalls die Funktion so zu ändern, dass sie gar nicht mehr fehlerwerfend ist. Für produktive Anwendungen empfiehlt er im Allgemeinen, Werte sicher statt erzwungen auszupacken.
Das Vorgehen des Tutorials besteht aus kurzen Codebeispielen: Eine Funktion gibt jeweils eine Textmarkierung aus und wirft anschließend einen selbst definierten Fehler. Die Beispiele zeigen das Abfangen oder Weiterreichen mit `try`, die optionale Behandlung mit `try?` und den Absturz mit `try!`. Der Bericht beschränkt sich auf diese grundlegende Erklärung und Beispielabläufe; er enthält keine systematische Erörterung weiterer Swift-Fehlerbehandlung oder ihrer Randfälle. Die Aussagen zu den passenden Einsatzsituationen sind Empfehlungen des Autors.
Gegengeprüft von Claude Haiku 5.5: kleine Mängel
Luna lieferte zwei Fassungen der Zusammenfassung (kurz und mittel). Beide wurden geprüft; sie enthalten keine erfundenen Angaben, lassen aber übereinstimmend die Hinweise zum unerreichbaren Catch-Block bei try! und zur Pflicht, fehlerwerfende Aufrufe abzufangen oder weiterzureichen, aus. Es wurden keine Fragen zur Einordnung angegeben, daher bleibt die Einordnung leer.
Im Bericht, aber nicht in der Zusammenfassung
- try! kann mit do-catch nicht sinnvoll kombiniert werden, der Catch-Block ist unerreichbar (Compiler-Hinweis)
- Ein try ohne Behandlung muss irgendwo abgefangen werden, sonst kompiliert der Code nicht oder die App kann abstürzen
- Bei try! kann es sich lohnen, die Funktion so zu ändern, dass sie nicht mehr wirft
Wie die Modelle den Bericht einordnen
Ansicht
Filter
Kein Modell sieht bei diesem Bericht einen Bezug zu einer der 44 Sammelfragen.