Syntaxe Swift do-try-catch

Je fais un essai pour comprendre la nouvelle gestion des erreurs dans swift 2. Voici ce que j'ai fait: J'ai d'abord déclaré une énumération d'erreur:

enum SandwichError: ErrorType {
    case NotMe
    case DoItYourself
}

Et puis j'ai déclaré une méthode qui lève une erreur (pas une exception les gens. C'est une erreur.). Voici cette méthode:

func makeMeSandwich(names: [String: String]) throws -> String {
    guard let sandwich = names["sandwich"] else {
        throw SandwichError.NotMe
    }

    return sandwich
}

Le problème vient du côté appelant. Voici le code qui appelle cette méthode:

let kitchen = ["sandwich": "ready", "breakfeast": "not ready"]

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
}

Après le docompilateur de ligne dit Errors thrown from here are not handled because the enclosing catch is not exhaustive. Mais à mon avis, il est exhaustif car il n'y a que deux cas SandwichErrorenum.

Pour les instructions de commutation régulières, Swift peut comprendre qu'il est exhaustif lorsque chaque cas est traité.

Le modèle de gestion des erreurs Swift 2 présente deux points importants: l'exhaustivité et la résilience. Ensemble, ils se résument à votre déclaration do/ catchdevant attraper toutes les erreurs possibles, pas seulement celles que vous savez que vous pouvez lancer.

Notez que vous ne déclarez pas les types d'erreurs qu'une fonction peut générer, mais uniquement si elle génère du tout. C'est une sorte de problème zéro-un-infini: en tant que personne définissant une fonction pour les autres (y compris votre futur moi) à utiliser, vous ne voulez pas avoir à obliger chaque client de votre fonction à s'adapter à chaque changement dans l'implémentation de votre fonction, y compris les erreurs qu'il peut générer. Vous voulez que le code qui appelle votre fonction résiste à ce changement.

Parce que votre fonction ne peut pas dire quel type d'erreurs elle génère (ou pourrait générer à l'avenir), les catchblocs qui interceptent les erreurs ne savent pas quels types d'erreurs elle pourrait générer. Ainsi, en plus de gérer les types d'erreur que vous connaissez, vous devez gérer ceux que vous ne connaissez pas avec une catchinstruction universelle - de cette façon, si votre fonction modifie l'ensemble des erreurs qu'elle génère à l'avenir, les appelants verront toujours son les erreurs.

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
} catch let error {
    print(error.localizedDescription)
}

Mais ne nous arrêtons pas là. Pensez encore à cette idée de résilience. La façon dont vous avez conçu votre sandwich, vous devez décrire les erreurs à chaque endroit où vous les utilisez. Cela signifie que chaque fois que vous modifiez l'ensemble des cas d'erreur, vous devez changer chaque endroit qui les utilise ... pas très amusant.

L'idée derrière la définition de vos propres types d'erreur est de vous permettre de centraliser des choses comme ça. Vous pouvez définir une descriptionméthode pour vos erreurs:

extension SandwichError: CustomStringConvertible {
    var description: String {
        switch self {
            case NotMe: return "Not me error"
            case DoItYourself: return "Try sudo"
        }
    }
}

Et puis votre code de gestion des erreurs peut demander à votre type d'erreur de se décrire - désormais, chaque endroit où vous gérez des erreurs peut utiliser le même code et gérer d'éventuels futurs cas d'erreur.

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch let error as SandwichError {
    print(error.description)
} catch {
    print("i dunno")
}

Cela ouvre également la voie à des types d'erreur (ou à des extensions sur eux) pour prendre en charge d'autres moyens de signaler des erreurs - par exemple, vous pourriez avoir une extension sur votre type d'erreur qui sait comment présenter une UIAlertControllerpour signaler l'erreur à un utilisateur iOS.

Je soupçonne que cela n'a pas encore été mis en œuvre correctement. Le Guide de programmation Swift semble définitivement impliquer que le compilateur peut déduire des correspondances exhaustives «comme une instruction switch». Il ne fait aucune mention du besoin d'un général catchpour être exhaustif.

Vous remarquerez également que l'erreur se trouve sur la tryligne, et non à la fin du bloc, c'est-à-dire qu'à un moment donné, le compilateur pourra identifier quelle tryinstruction du bloc a des types d'exceptions non gérés.

La documentation est cependant un peu ambiguë. J'ai parcouru la vidéo «Quoi de neuf dans Swift» et je n'ai trouvé aucun indice; Je vais continuer à essayer.

Mettre à jour:

Nous sommes maintenant à la bêta 3 sans aucun indice d'inférence ErrorType. Je crois maintenant que si cela a jamais été planifié (et je pense toujours que c'était à un moment donné), l'envoi dynamique sur les extensions de protocole l'a probablement tué.

Mise à jour bêta 4:

Xcode 7b4 a ajouté la prise en charge des commentaires doc pour Throws:, qui «devrait être utilisé pour documenter quelles erreurs peuvent être générées et pourquoi». Je suppose que cela fournit au moins un mécanisme pour communiquer les erreurs aux consommateurs d'API. Qui a besoin d'un système de typage quand on a de la documentation!

Une autre mise à jour:

Après avoir passé un certain temps en espérant automatiquement l' ErrorTypeinférence, et de travail quelles sont les limites seraient de ce modèle, j'ai changé d' avis - c'est ce que je souhaite d' Apple met en œuvre à la place. Essentiellement:

// allow us to do this:
func myFunction() throws -> Int

// or this:
func myFunction() throws CustomError -> Int

// but not this:
func myFunction() throws CustomErrorOne, CustomErrorTwo -> Int

Encore une autre mise à jour

La justification de la gestion des erreurs d'Apple est maintenant disponible ici . Il y a également eu des discussions intéressantes sur la liste de diffusion Swift-evolution . Essentiellement, John McCall est opposé aux erreurs de frappe car il pense que la plupart des bibliothèques finiront par inclure un cas d'erreur générique de toute façon, et qu'il est peu probable que les erreurs de frappe ajoutent beaucoup au code en dehors du passe-partout (il a utilisé le terme `` bluff ambitieux ''). Chris Lattner a déclaré qu'il était ouvert aux erreurs de frappe dans Swift 3 s'il pouvait fonctionner avec le modèle de résilience.

Swift craint que votre déclaration de cas ne couvre pas tous les cas, pour y remédier, vous devez créer un cas par défaut:

do {
    let sandwich = try makeMeSandwich(kitchen)
    print("i eat it \(sandwich)")
} catch SandwichError.NotMe {
    print("Not me error")
} catch SandwichError.DoItYourself {
    print("do it error")
} catch Default {
    print("Another Error")
}

J'ai également été déçu par le manque de type qu'une fonction peut lancer, mais je l'obtiens maintenant grâce à @rickster et je vais le résumer comme ceci: disons que nous pourrions spécifier le type qu'une fonction lance, nous aurions quelque chose comme ceci:

enum MyError: ErrorType { case ErrorA, ErrorB }

func myFunctionThatThrows() throws MyError { ...throw .ErrorA...throw .ErrorB... }

do {
    try myFunctionThatThrows()
}
case .ErrorA { ... }
case .ErrorB { ... }

Le problème est que même si nous ne changeons rien dans myFunctionThatThrows, si nous ajoutons simplement un cas d'erreur à MyError:

enum MyError: ErrorType { case ErrorA, ErrorB, ErrorC }

nous sommes foutus car notre do / try / catch n'est plus exhaustif, ainsi que tout autre endroit où nous avons appelé des fonctions qui lancent MyError

enum NumberError: Error {
  case NegativeNumber(number: Int)
  case ZeroNumber
  case OddNumber(number: Int)
}

extension NumberError: CustomStringConvertible {
         var description: String {
         switch self {
             case .NegativeNumber(let number):
                 return "Negative number \(number) is Passed."
             case .OddNumber(let number):
                return "Odd number \(number) is Passed."
             case .ZeroNumber:
                return "Zero is Passed."
      }
   }
}

 func validateEvenNumber(_ number: Int) throws ->Int {
     if number == 0 {
        throw NumberError.ZeroNumber
     } else if number < 0 {
        throw NumberError.NegativeNumber(number: number)
     } else if number % 2 == 1 {
         throw NumberError.OddNumber(number: number)
     }
    return number
}

Validez maintenant le numéro:

 do {
     let number = try validateEvenNumber(0)
     print("Valid Even Number: \(number)")
  } catch let error as NumberError {
     print(error.description)
  }

Créez une énumération comme ceci:

//Error Handling in swift
enum spendingError : Error{
case minus
case limit
}

Créez une méthode comme:

 func calculateSpending(morningSpending:Double,eveningSpending:Double) throws ->Double{
if morningSpending < 0 || eveningSpending < 0{
    throw spendingError.minus
}
if (morningSpending + eveningSpending) > 100{
    throw spendingError.limit
}
return morningSpending + eveningSpending
}

Maintenant, vérifiez que l'erreur est là ou non et gérez-la:

do{
try calculateSpending(morningSpending: 60, eveningSpending: 50)
} catch spendingError.minus{
print("This is not possible...")
} catch spendingError.limit{
print("Limit reached...")
}