Как написать шаблонную функцию, которая обрабатывает поймать

Question

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

func handleMethod(methodNeedToHandle) -> result: notSureType{
    var result
    do {
        let response = try handleMethod
        result = response
        return result
    } catch let error as someObjectError{
        result = error
        return result
    }  
}

Тогда вы можете использовать это как

let catchResult = handleMethod(method(x: something, y: something))

Спасибо, ребята, мне очень помогают, я получаю рабочий код ниже

func handleDoTryCatch<T>(closure:() throws -> T) -> Any {
    do {
        let result = try closure()
        return result
    } catch let error {
        return error
    }
}

Answer 1

Мне удалось придумать эту функцию:

// Your error cases
enum Errors: Error {
    case someErrorCase
}


// Function to test another function
func doTryCatch<T>(for function: () throws -> T) {
    do {
        let returnValue = try function()
        print("Success! The return value is \(returnValue)")
    } catch {
        print("Error! The error reason was \"\(String(describing: error))\"")
    }
}


// Function to test
func failingFunction() throws -> Int {
    throw Errors.someErrorCase // <-- Comment this to not recieve an error (for testing)
    return 5 // Will return 5 if the error is not thrown

    // Failure: Error! The error reason was "someErrorCase"
    // Success: Success! The return value is 5
}


// Perform the test
doTryCatch(for: failingFunction) // <-- Very easy to test, no closures to write!

Надеюсь, это поможет в вашей отладке!:)

Answer 2

Вы можете использовать универсальную функцию, которая принимает замыкание и возвращает кортеж.

Что-то вроде:

func handle<T>(closure:() throws -> T) -> (T?, Error?) {
    do {
        let result = try closure()
        return (result, nil)
    } catch let error {
        return (nil, error)
    }
}

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

Вы могли бы использовать это так:

let result: (Void?, Error?) = handle { try someFunc() }
let result2: (Int?, Error?) = handle { try someOtherFunc(2) }

someFunc и someOtherFunc - только примеры и их подписибудет:

func someFunc() throws {}
func someOtherFunc(_ param: Int) throws -> Int {}

Answer 3

Самое близкое, что я мог бы получить к тому, что вы, вероятно, хотите, это следующее: (Swift Playground code:)

func handleMethod(_ f: @autoclosure () throws -> Void) -> Error? {
    do {
        try f()
    } catch let err {
        return err
    }
    return nil
}

enum HelloError: Error {
    case tooShort
}

func hello(_ what: String) throws {
    guard what.count > 0 else { throw HelloError.tooShort }
    print ("Hello \(what)!")
}

// use like this:
// let err = handleMethod(try hello("World")) // err == nil
// let err = handleMethod(try hello(""))      // err == HelloError.tooShort
// 

print ("* hello(\"World\") -> \(String(describing: handleMethod(try hello("World"))))")
print ("* hello(\"\") -> \(String(describing: handleMethod(try hello(""))))")

Это даст следующий вывод:

Hello World!
* hello("World") -> nil
* hello("") -> Optional(__lldb_expr_3.HelloError.tooShort)

Рассмотрим толькоиспользуя do / catch, как рекомендует George_E.Это хороший совет.Но если вам нужна эта функция, мы надеемся, что эта оторванная точка даст вам отправную точку.