Swift #25: Errores

Arrojar errores

Se usa las palabras claves throws (en la firma del método) y throw (para arrojar el error). Los errores se definen por medio de una enumeración que conforma el protocolo Swift.Error.

enum MisErrores: Swift.Error {
  case posibleError, otroError
}
func execute1() throws {
  throw MisErrores.posibleError
}
func execute2() throws(MisErrores) {
  throw .posibleError
}

Manejar errores

Cualquier método que potencialmente arroje un error (throws) debe ser llamado con try dentro del bloque do de un do catch. Si una expresión dentro del bloque do arroja un error, se sale de ese bloque y se ejecuta el bloque catch, que captura el error en una variable llamada error.

func handleError() {
  do {
    try execute1()
  } catch MisErrores.posibleError {
    print("Ocurrió un error especifico")
  } catch is MisErrores {
    print("Ocurrio un error del tipo MisErrores")
  } catch {
    // Como no se especifica el tipo de error,
    // siempre debe haber un catch genérico
    print("Error inesperado")
  }
}

func handleTypedError() {
  do throws(MisErrores) {
  // Declaración explícita del tipo de error
    try execute2()
  } catch {
    switch error {
    case .otroError:
      print("Otro error")
    case .posibleError:
      print("Error posible")
    }
  }  
  do {
  // Inferencia del tipo de error cuando la firma del método
  // indica explícitamente el tipo de error arrojado
    try execute2()
  } catch {
    switch error {
    case .otroError:
      print("Otro error")
    case .posibleError:
      print("Error posible")
    }
  }
}

Ignorar el tipo del error

Si no importa el error y podemos ignorarlo con la sintaxis try?: Si el método arroja un error, la expresión marcada con try? retornará nil. De esta forma, podemos evitar usar do catch.

Si se sabe que un método jamás va a arrojar un error, se puede usar la sintaxis try!.

Result

Swift define la enumeración Result<Success, Failure> que define dos casos a usar si la operación fue exitosa o fallida: success() y failure(), respectivamente.

func execute(input: Int) -> Result<Int, MisErrores> {
  if input > 0 {
    return .success(input + 1)
  } else {
    return .failure(.posibleError)
  }
}
func handleExecution() {
  let result = execute(input: 1)
  switch result {
  case .success(let value):
    print("Valor recibido: \(value)")
  case .failure(let error):
    switch error {
    case .posibleError:
      print("Posible error")
    case .otroError:
      print("Otro error")
    }
  }
}

En lugar de usar una enumeración en un switch, podemos manejar el Result con un do catch por medio del método get().

let integerResult: Result<Int, Error> = .success(5)
do {
  let value = try integerResult.get()
  print("The value is \(value).")
} catch {
  print("Error retrieving the value: \(error)")
}