¿Cómo detectar errores en Swift?

En Swift, los errores se capturan mediante un sistema de manejo de errores basado en el uso de las palabras clave throw, throws, try y el bloque do-catch.

1. Declaración de funciones que pueden lanzar errores: Se usa la palabra clave throws después de los parámetros de la función.

   enum DataError: Error {
       case emptyData
       case invalidFormat
   }
   
   func processData(input: String) throws -> String {
       guard !input.isEmpty else {
           throw DataError.emptyData // Lanzamos un error
       }
       // ...lógica de procesamiento de datos...
       if input == "invalid" {
            throw DataError.invalidFormat
       }
       return "Processed: \(input)"
   }
   

2. Llamada a funciones que pueden lanzar errores: Se usa la palabra clave try.

   do { // Bloque para manejar errores
       let result = try processData(input: "valid data")
       print(result) // "Processed: valid data"
   } catch { // Bloque para capturar errores
       print("Ocurrió un error: \(error)")
   }
   

3. Captura de tipos específicos de errores: En el bloque catch se puede indicar un tipo de error específico para capturar.

   do {
       let result = try processData(input: "")
       print(result)
   } catch DataError.emptyData {
       print("Los datos están vacíos, por favor proporcione entrada.")
   } catch DataError.invalidFormat {
       print("El formato de los datos no es válido.")
   } catch { // Captura cualquier otro error
       print("Ocurrió un error inesperado: \(error)")
   }
   

4. Bloque defer: Se ejecuta justo antes de salir del ámbito actual, independientemente de si ocurrió una excepción o no. Se usa a menudo para limpiar recursos.

   func openFile(_ filename: String) throws -> String {
       // Supongamos que esto abre un archivo y devuelve su contenido
       print("Abriendo archivo \(filename)")
       // ... lógica de apertura ...
   
       defer {
           // Este código se ejecutará antes de salir de la función,
           // incluso si ocurre un error
           print("Cerrando archivo \(filename)")
       }
   
       // ... procesamiento del archivo ...
       if filename == "error.txt" {
          throw DataError.invalidFormat // Lanzamos un error
       }
   
       return "Contenido del archivo"
   }
   
   do {
       let content = try openFile("data.txt")
       print(content)
   } catch {
       print("Error al manejar el archivo: \(error)")
   }
   

5. try? opcional: Devuelve un valor opcional. Si la función lanza un error, try? devuelve nil.

   let processedResult = try? processData(input: "") // processedResult será nil
   let validResult = try? processData(input: "abc") // validResult será un String opcional con el valor "Processed: abc"
   

6. try! forzado: Se usa cuando estás seguro de que no ocurrirá un error. Si ocurre un error, la aplicación terminará abruptamente. Usa con precaución.

   // Solo úsalo si estás 100% seguro de que la función no lanzará error
   let result = try! processData(input: "siempre entrada válida")
   

El sistema basado en do-catch es una forma más explícita y segura de manejar errores en comparación con las excepciones tradicionales en otros lenguajes, ya que requiere declarar explícitamente las funciones que pueden lanzar errores (throws) y manejar estos errores de manera explícita al llamarlas (try, do-catch).