web-dev-qa-db-fra.com

essayer essayer! et essayer? Quelle est la différence et quand les utiliser?

Dans Swift 2. , Apple a introduit un nouveau moyen de gérer les erreurs (do-try-catch). Et il y a quelques jours de la Bêta 6, un mot-clé encore plus récent a été introduit (try?). Aussi, je savais que je pouvais utiliser try!. Quelle est la différence entre les 3 mots-clés et quand les utiliser?

swifterror-handlingswift3swift2
159
Abdurrahman

Mise à jour pour Swift 5.1

Supposons la fonction de projection suivante:

enum ThrowableError: Error {

    case badError(howBad: Int)
}

func doSomething(everythingIsFine: Bool = false) throws -> String {

  if everythingIsFine {
      return "Everything is ok"
  } else {
      throw ThrowableError.badError(howBad: 4)
  }
}

essayer

Vous avez 2 options lorsque vous essayez d'appeler une fonction qui peut lancer.

Vous pouvez prendre la responsabilité de erreurs de traitement en entourant votre appel dans un bloc à intercepter:

do {
    let result = try doSomething()
}
catch ThrowableError.badError(let howBad) {
    // Here you know about the error
    // Feel free to handle or to re-throw

    // 1. Handle
    print("Bad Error (How Bad Level: \(howBad)")

    // 2. Re-throw
    throw ThrowableError.badError(howBad: howBad)
}

Ou essayez simplement d'appeler la fonction, et transmettez l'erreur à l'appelant suivant dans la chaîne d'appels:

func doSomeOtherThing() throws -> Void {    
    // Not within a do-catch block.
    // Any errors will be re-thrown to callers.
    let result = try doSomething()
}

essayer!

Que se passe-t-il lorsque vous essayez d'accéder à une option implicitement non enveloppée avec un nil à l'intérieur? Oui, c'est vrai, l'application va CRASH! Même chose avec essayer! il ignore fondamentalement la chaîne d'erreur et déclare une situation de "faire ou mourir". Si la fonction appelée ne génère aucune erreur, tout se passe bien. Mais si cela échouait et renvoyait une erreur, votre application se plantera tout simplement.

let result = try! doSomething() // if an error was thrown, CRASH!

essayer?

Un nouveau mot clé qui a été introduit dans Xcode 7 beta 6. Il retourne un optionnel qui décompresse les valeurs qui ont réussi, et attrape l’erreur en renvoyant nil.

if let result = try? doSomething() {
    // doSomething succeeded, and result is unwrapped.
} else {
    // Ouch, doSomething() threw an error.
}

Ou nous pouvons utiliser la garde:

guard let result = try? doSomething() else {
    // Ouch, doSomething() threw an error.
}
// doSomething succeeded, and result is unwrapped.

Une dernière note ici, en utilisant try? notez que vous ignorez l’erreur qui s’est produite, car elle est traduite en néant. Utilisez essayez? lorsque vous vous concentrez davantage sur les succès et les échecs, et non sur les raisons qui ont conduit à l'échec.

Utilisation d'un opérateur de coalescence?

Vous pouvez utiliser l'opérateur de coalescence? avec essayer? pour fournir une valeur par défaut en cas d'échec:

let result = (try? doSomething()) ?? "Default Value"
print(result) // Default Value
297
Abdurrahman