首先，让我们看一些使用示例，然后如何使这些示例工作(定义)。

使用

do {
    throw MyError.Failure
} catch {
    print(error.localizedDescription)
}

或更具体的风格:

do {
    try somethingThatThrows()
} catch MyError.Failure {
    // Handle special case here.
} catch MyError.Rejected {
    // Another special case...
} catch {
    print(error.localizedDescription)
}

此外，分类也是可能的:

do {
    // ...
} catch is MyOtherErrorEnum {
    // If you handle entire category equally.
} catch let error as MyError {
    // Or handle few cases equally (without string-compare).
    switch error {
    case .Failure:
        fallthrough;
    case .Rejected:
        myShowErrorDialog(error);
    default:
        break
    }
}

定义

public enum MyError: String, LocalizedError {
    case Failure = "Connection fail - double check internet access."
    case Rejected = "Invalid credentials, try again."
    case Unknown = "Unexpected REST-API error."

    public var errorDescription: String? { self.rawValue }
}

利与弊

Swift自动定义错误变量，处理程序只需要读取localizedDescription属性。

但这是模糊的，我们应该使用“catch MyError”。Failure{}”的样式代替(以明确我们处理的情况)，尽管，分类是可能的，如使用示例所示。

Teodor-Ciuraru's answer (which's almost equal) still needs a long manual cast (like "catch let error as User.UserValidationError { ... }"). The accepted categorization-enum approach's disadvantages: Is too vague as he comments himself, so that catchers may need to compare String message!? (just to know exact error). For throwing same more than once, needs copy/pasting message!! Also, needs a long phrase as well, like "catch MyError.runtimeError(let errorMessage) { ... }". The NSException approach has same disadvantages of categorization-enum approach (except maybe shorter catching paragraph), also, even if put in a factory method to create and throw, is quite complicated.

结论

通过简单地使用LocalizedError而不是Error，这完成了其他现有的解决方案，并希望将像我这样的人从阅读所有其他帖子中拯救出来。

(我的懒惰有时会给我带来很多工作。)

测试

import Foundation
import XCTest
@testable import MyApp

class MyErrorTest: XCTestCase {
    func testErrorDescription_beSameAfterThrow() {
        let obj = MyError.Rejected;
        let msg = "Invalid credentials, try again."
        XCTAssertEqual(obj.rawValue, msg);
        XCTAssertEqual(obj.localizedDescription, msg);
        do {
            throw obj;
        } catch {
            XCTAssertEqual(error.localizedDescription, msg);
        }
    }

    func testThrow_triggersCorrectCatch() {
        // Specific.
        var caught = "None"
        do {
            throw MyError.Rejected;
        } catch MyError.Failure {
            caught = "Failure"
        } catch MyError.Rejected {
            caught = "Successful reject"
        } catch {
            caught = "Default"
        }
        XCTAssertEqual(caught, "Successful reject");
    }
}

其他工具:

如果为每个枚举实现errorDescription很痛苦，那么就一次性实现它，比如:

extension RawRepresentable where RawValue == String, Self: LocalizedError {
    public var errorDescription: String? {
        return self.rawValue;
    }
}

上面只是为已经扩展了LocalizedError的枚举添加了逻辑(但是可以删除“Self: LocalizedError”部分，使其应用于任何string-enum)。

#2如果我们需要额外的上下文，如FileNotFound与文件路径相关联?请看我的另一篇文章:

https://stackoverflow.com/a/70448052/8740349

基本上，将LocalizedErrorEnum从上面的链接复制并添加到您的项目中，并根据需要使用关联枚举多次重用。

最简单的方法是使String符合Error:

extension String: Error {}

然后你可以抛出一个字符串:

throw "Some Error"

为了让字符串本身成为错误的localizedString，你可以扩展LocalizedError:

extension String: LocalizedError {
    public var errorDescription: String? { return self }
}

最简单的方法可能是定义一个自定义enum，只有一个case，并附加一个String:

enum MyError: ErrorType {
    case runtimeError(String)
}

或者，在Swift 4中:

enum MyError: Error {
    case runtimeError(String)
}

示例用法如下:

func someFunction() throws {
    throw MyError.runtimeError("some message")
}
do {
    try someFunction()
} catch MyError.runtimeError(let errorMessage) {
    print(errorMessage)
}

如果您希望使用现有的错误类型，最常用的错误类型是NSError，您可以创建一个工厂方法来创建并抛出一个带有自定义消息的错误类型。

首先，让我们看看LocalizedErrorEnum的使用示例，然后看看如何使这些示例工作(在源代码部分)。

使用

do {
    let path = "/my/path/to/file.txt";
    throw MyErrorCategory.FileNotFound(
        atPath: path
    );
} catch {
    print(error.localizedDescription);
}

输出:

Failed to find file. {
  atPath: /my/path/to/file.txt
}

定义:

public enum MyErrorCategory: LocalizedErrorEnum {
    case FileNotFound(String = "Failed to find file.", atPath: String)
    case Connection(String = "Connection fail - double check internet access.")
}

第一个参数被视为消息(在LocalizedErrorEnum enum中)。

所需功能(背景)

#1首先，我想要没有复制/粘贴的消息，并且能够捕捉一组不同的错误情况，而不列出每个情况(解决方案，enum是非常独特的，没有复制/粘贴需要，每个enum可以被认为是另一组)。

其次，一些像“FileNotFound”这样的错误需要有变量上下文/细节，比如file-path(但Raw-Value enum不支持实例变量，与#1不同的是，内置enum不是解决方案)。

#3最后，我希望能够单独捕获每个情况，而不是捕获整个结构和/或类，然后在捕获内做切换，并希望避免忘记我们不处理的情况的重新抛出。

源代码(满足需求的解决方案)

只需从下面复制LocalizedErrorEnum并将其添加到您的项目中一次，并根据需要多次使用关联枚举。

public protocol LocalizedErrorEnum: LocalizedError {
    var errorDescription: String? { get }
}

extension LocalizedErrorEnum {
    public var errorDescription: String? {
        if let current = Mirror(reflecting: self).children.first {
            let mirror = Mirror(reflecting: current.value);
            // Initial error description.
            let message = mirror.children.first?.value as? String
                ?? current.label ?? "Unknown-case";
            var context = "";
            // Iterate additional context.
            var i = 0;
            for associated in mirror.children {
                if i >= 1 {
                    if let text = associated.value as? String {
                        context += "\n  ";
                        if let label: String = associated.label {
                            context += "\(label): "
                        }
                        context += text;
                    }
                }
                i += 1;
            }
            return context.isEmpty ? message : (
                message + " {" + context + "\n}"
            );
        }
        return "\(self)";
    }
}

请注意，正如我的个人资料中提到的，在Apache 2.0许可下使用上述代码也是允许的(不需要归属)。 如果您不需要附加上下文变量的错误(或与其他方法进行比较)，请参阅我的其他答案。

@nick-keets的解决方案是最优雅的，但它确实打破了我的测试目标与以下编译时错误:

'String'与协议'Error'的冗余一致性

这是另一种方法:

struct RuntimeError: Error {
    let message: String

    init(_ message: String) {
        self.message = message
    }

    public var localizedDescription: String {
        return message
    }
}

并使用:

throw RuntimeError("Error message.")

我想对所提议的一些解决办法提出一些变通建议:

public enum MyError: Error {
    var localizedDescription: String {
        get {
            switch(self) {
                case .network(let message, let code):
                    return "\(message) (\(code))"
                case .invalidInput(message: let message):
                    return message
            }
        }
    }
    case network(message: String, code: Int)
    case invalidInput(message: String)
}

它需要更多的工作来创建，但它提供了所有世界中最好的:

它是一个枚举，所以可以在switch语句中使用。 所有错误都必须创建一个消息，即使对于相同类型的错误也可以是不同的消息(与扩展String的枚举不同) 它在localizedDescription下提供了每个开发人员都期望的消息。