---
title: 05. Manexo de erros
description: "É esencial asegurarse de que o código dunha aplicación manexe calquera erro que poida ocorrer. O manexo de erros dentro de Swift ten dúas caras. - Activar (ou lanzar) un erro cando non se logran dentro do método os resultados…"
url: "https://www.drodicio.com/docs/swift/tema-2-swift-avanzado/manexo-de-erros/"
updated: "2024-12-15"
category: Tema 2. Swift avanzado
---

# 05. Manexo de erros

É esencial asegurarse de que o código dunha aplicación manexe calquera erro que poida ocorrer.

O manexo de erros dentro de Swift ten dúas caras.

- Activar (ou lanzar) un erro cando non se logran dentro do método os resultados desexados
- Detectar e manexar o erro despois de que sexa lanzado por un método.

Ademais de implementar métodos para lanzar erros , é importante ter en conta que unha serie de métodos de API no SDK de iOS (especialmente os relacionados co manexo de arquivos) lanzarán erros que deberán manexarse dentro do código da aplicación.

Velaquí tedes o código fonte desta sección:

[https://swiftfiddle.com/oorfcndbm5e45ltvpk6wk3tp7a/embedded/](https://swiftfiddle.com/oorfcndbm5e45ltvpk6wk3tp7a/embedded/)

## 1 de 3 - Declarar tipos de erros

Consideremos un método que transfira un arquivo a un servidor remoto. Tal método podería non transferir o arquivo por unha variedade de razóns:

- Non hai conexión de rede
- A conexión sexa demasiado lenta
- Non se atope o arquivo que se vai a transferir.

Todos estes posibles erros poderían representarse dentro dunha enumeración da seguinte maneira:

```swift
enum ErroTransferenciaArquivo:Error {
    case nonConexion
    case baixoAnchoBanda
    case arquivoNonAtopado
}
```

## 2 de 3- guard e throw: Lanzando un erro

Un método ou función declara que pode lanzar un erro usando a palabra `throws`. Por exemplo:

```swift
func enviarArquivo() throws {
}
```

No caso de que a función ou o método devolva un resultado, a palabra chave `throws` colócase antes do tipo de retorno da seguinte maneira:

```swift
func enviarArquivo() throws -> Bool{
}
```

Unha vez que se declara que un método é capaz de lanzar erros, pódese lanzar os erros cando se atopen. Isto lógrase empregando as seguintes palabras chave:

- `throw`
- `guard`

No seguinte código declaramos unhas constantes para empregar como valores de estado e implementamos o comportamento do `guard` (garda) e `throw` (lanzamento):

```
let conexionOK = true
let velocidadeConexion = 30.0
let arquivoAtopado = false

enum ErroTransferenciaArquivo:Error {
    case nonConexion
    case baixoAnchoBanda
    case arquivoNonAtopado
}

func enviarArquivo() throws {
    guard conexionOK else {
        throw ErroTransferenciaArquivo.nonConexion
    }
    guard velocidadeConexion > 30 else {
        throw ErroTransferenciaArquivo.baixoAnchoBanda
    }
    guard arquivoAtopado else {
        throw ErroTransferenciaArquivo.arquivoNonAtopado
    }
}
```

Dentro do corpo do método, cada `guard` comproba unha condición. No caso dun resultado `false`:

- Execútase o código contido dentro do corpo `else` (`liñas 13,16 e 19`).
- A instrución `throw` utilízase para lanzar un dos valores de erro contidos na enumeración `ErroTransferenciaArquivo` (`liñas 13,16 e 19`).

## 3 de 3 - try e catch: Chamando as funcións de lanzamento

Unha vez que se declara un método ou función como erro de lanzamento (`throw`), xa non se pode chamar da maneira habitual.

As chamadas aos devanditos métodos agora deben estar precedidas pola instrución `try` da seguinte maneira:

```swift
try enviarArquivo()
```

Ademais de usar a instrución `try`, a chamada tamén debe facerse desde unha instrución `do-catch` para detectar e manexar calquera erro que se poida lanzar.

No seguinte exemplo, chamaremos ao método `enviarArquivo()` desde un método chamado `iniciarTransferenciaArquivo`:

```
let conexionOK = true
let velocidadeConexion = 30.0
let arquivoAtopado = false

enum ErroTransferenciaArquivo:Error {
    case nonConexion
    case baixoAnchoBanda
    case arquivoNonAtopado
}

func enviarArquivo() throws {
    guard conexionOK else {
        throw ErroTransferenciaArquivo.nonConexion
    }
    guard velocidadeConexion > 30 else {
        throw ErroTransferenciaArquivo.baixoAnchoBanda
    }
    guard arquivoAtopado else {
        throw ErroTransferenciaArquivo.arquivoNonAtopado
    }
}

func iniciarTransferenciaArquivo() -> String {
    do{
        try enviarArquivo()
    }
    catch ErroTransferenciaArquivo.nonConexion, ErroTransferenciaArquivo.baixoAnchoBanda {
        return "Problema de conexión"
    }
    catch ErroTransferenciaArquivo.arquivoNonAtopado {
        return "Arquivo non atopado"
    }
    catch {
        return "Erro descoñocido"
    }
    return "Conexión OK!"
}
```
