Быстрая обработка ошибок

Обработка ошибок в Swift — это механизм обработки ошибок или исключительных ситуаций, которые могут возникнуть в вашем коде. Это позволяет вам выявлять и реагировать на потенциальные проблемы контролируемым и предсказуемым образом, а не позволять им вызывать сбой вашей программы.

В Swift ошибки представлены значениями типов, соответствующих протоколу Error. Когда функция сталкивается с ошибкой, она может выдать ошибку, используя оператор throw. Затем ошибка может быть перехвачена и обработана окружающим оператором do-catch.

Свифт До-улов

В кратком руководстве/учебнике мы узнаем, как обрабатывать ошибки в Swift на простом примере.

Когда вы разрабатываете приложение для iOS, и ваш код сталкивается с ошибкой, он не может ее обработать, приложение просто вылетит, и пользователю придется начинать все сначала — этого никто не хочет.

Оператор do-catch в Swift используется для обработки ошибок в вашем коде. Блок do содержит код, который может вызвать ошибку, а блок catch содержит код, который должен быть выполнен в случае возникновения ошибки.

Обычно, когда вы получаете данные из API и выполняете синтаксический анализ из JSON в объект Swift, вы хотите использовать do-catch. В следующем примере мы создадим функцию, которая анализирует JSON в объект:

func getData(dataToParse: Data) {
            do {
                let parsedToObject = try JSONDecoder().decode(SomeObject.self, from: dataToParse)
                success(profiles)
            }catch {
                print("Error")
            }
        }
    }

Как видите, синтаксис прост:

do {
   //Code that might fail example parse json to object
}catch{
  //The error is catched and the app can continue
}

Теперь это отличный пример того, где вы всегда хотите создать do-catch.

Но иногда вы создаете функцию, которая может дать сбой, и поэтому вы хотите выдать ошибку.

Swift throw error — обработка ошибок с помощью enum

В Swift вы можете использовать перечисления для определения пользовательских типов ошибок и сделать обработку ошибок более структурированной и выразительной. Перечисление можно использовать для определения набора случаев ошибок, которые может выдать функция.

Допустим, вы создаете функцию и хотите сгенерировать ошибку, вы можете сделать это за 3 простых шага — создать перечисление Error, создать функцию, которая выдает ошибку, и функцию, которая ее перехватывает.

Мы определим пользовательскую ошибку для сетевых запросов.

1. Создайте пользовательскую ошибку, соответствующую ошибке

Первое, что нам нужно сделать, это определить наш NetworkErrorenum:

enum NetworkError: Error {
    case serverError(errorCode: Int)
    case invalidURL(url: String)
}

serverError: указывает, что сервер вернул ошибку, и включает код ошибки, возвращенный сервером.

2. Функция выдает ошибку

Теперь нам нужно использовать наш NetworkError, и мы будем делать вид, что создаем запрос API.

func executeRequest(url: String) throws -> Data {
    guard let url = URL(string: url) else {
        throw NetworkError.invalidURL(url: url)
    }

    let response = try getResponse(from: url)

    if response.errorCode < 200 && response > 299 {
        throw NetworkError.serverError(errorCode: response.errorCode)
    }

    return response
}

Приведенный выше код выдает NetworkError.invalidURL, если URL-адрес, переданный функции, не соответствует URL-адресу, и NetworkError.serverError, если код состояния ответа не был успешным — ниже 200 и выше 299.

3. Функция, которая ловит NetworkError

Теперь пришло время создать функцию, которая использует executeRequest и перехватывает ошибки:

do {
    let data = try executeRequest()
    // handle the received data
} catch let error as NetworkError {
    // handle the specific NetworkError cases
    switch error {
    case .invalidURL(let invalidUrl):
        print("Not a valid URL: \(invalidUrl)")
    case .serverError(let errorCode):
        print("Server said no: \(errorCode)")
    }
} catch {
    print("Any other error: \(error)")
}

Заключение

В заключение можно сказать, что обработка ошибок является критически важной практикой в программировании на Swift, которая может улучшить качество и надежность кода.

Эффективно обрабатывая ошибки, разработчики могут предотвратить неожиданные и потенциально катастрофические сбои или ошибки, которые могут негативно повлиять на работу пользователей.

Использование обработки ошибок в Swift может помочь обнаруживать ошибки и реагировать на них более контролируемым и предсказуемым образом, обеспечивая более надежный код и лучшую стабильность приложения.

Кроме того, включив в Swift обработку ошибок, разработчики могут предоставить пользователям более качественную обратную связь, позволяя им понять, что пошло не так, и предпринять корректирующие действия. Это может улучшить общее взаимодействие с пользователем и уменьшить количество запросов в службу поддержки или отрицательных отзывов.

Что такое обработка ошибок в Swift?

Обработка ошибок — это механизм в Swift, который позволяет вам обрабатывать непредвиденные или нежелательные ситуации в вашем коде, такие как сетевые ошибки, ошибки файлового ввода-вывода или отсутствующие данные. Обработка ошибок помогает писать устойчивый и надежный код, позволяя предвидеть ошибки и реагировать на них.

В Swift обработка ошибок основана на концепции генерации и перехвата ошибок. Когда функция сталкивается с ошибкой, она выдает ошибку, и вызывающая функция может перехватить эту ошибку и отреагировать соответствующим образом.

Как вы выдаете ошибку в Swift?

Вы можете выдать ошибку в Swift, используя оператор throw. Оператор throw используется для указания того, что произошла ошибка, и для передачи ошибки вызывающей стороне функции.

Первоначально опубликовано на https://softwareanders.com 13 марта 2023 г.

Быстрая обработка ошибок — с примерами