swift - 是否有一个快速数据结构可以包含一个可以是任何类型并且可以切换的rawValue

Question

我需要某种可以接受任何 StringLiteralType 的枚举，我不需要在其中创建大量样板代码。

这是我拥有的样板代码示例。

enum Sample: RawRepresentable {
    case foo
    case bar
    case unknown(String)

    init?(rawValue: String) {
        if let correspondingValue = Key(rawValue: rawValue)?.correspondingValue {
            self = correspondingValue
        } else {
            self = .unknown(rawValue)
        }
    }

    private enum Key: String {
        case foo
        case bar

        var correspondingValue: Sample {
            switch self {
            case .foo: return .foo
            case .bar: return .bar
            }
        }

        init?(withSample sample: Sample) {
            switch sample {
            case .foo: self = .foo
            case .bar: self = .bar
            case .unknown: return nil
            }
        }
    }

    var rawValue: String {
        switch self {
        case let .unknown(value): return value
        default: return Key(withSample: self)?.rawValue ?? ""
        }
    }
}

我想要定义具有默认值的案例(foo、bar 等)，我可以使用这些默认值进行切换，然后我想要一个可以包含任何内容的 unkown(String)值(value)。

这可以通过使用 String 和某种 Constants 来轻松完成，例如像这样。

enum Constants {
    static let foo = "foo"
    static let bar = "bar"
}

// sample usage

let someString = "aaaa"

let sample = Sample(rawValue: someString)! // don't mind the implicit unwrapping
switch sample {
case Constants.foo:
    // do something
case Constants.bar:
    // do something
default:
    // do something with unknown someString
}

这里的想法是能够像这样使用示例。

let someString = "aaaa"

let sample = Sample(rawValue: someString)! // don't mind the implicit unwrapping
switch sample {
case .foo:
    // do something
case .bar:
    // do something
case .unknown(let value):
    // do something
}

编辑:

为什么它需要是一个枚举- 使用枚举在 XCode 中自动完成- 使用 switch

添加新案例时添加功能会很容易

为什么需要 RawRepresentable- 这通过它的 RawValue 存储到持久性。- 通过这样做，我还可以使用 ExpressibleByXXXXXXLiteral 下的协议(protocol)。

Answer 1

它需要是RawRepresentable吗？下面的代码根据您的要求工作......

enum Sample {
    case foo, bar, unknown(StringLiteralType)

    init(_ string: StringLiteralType) {
        switch string {
        case "foo": self = .foo
        case "bar": self = .bar
        default: self = .unknown(string)
        }
    }
}


let sample = Sample("aaa")
switch sample {
case .foo:
    print("foo")
case .bar:
    print("bar")
case .unknown(let value):
    print(value)
}
// aaa

---

编辑

enum Sample: RawRepresentable {
    case foo, bar, unknown(StringLiteralType)
    enum Keys: String {
        case foo, bar
        var sample: Sample {
            switch self {
            case .foo: return .foo
            case .bar: return .bar
            }
        }
    }

    init(rawValue: StringLiteralType) {
        self = Keys(rawValue: rawValue)?.sample ?? .unknown(rawValue)
    }

    var rawValue: String {
        switch self {
        case .foo: return Keys.foo.rawValue
        case .bar: return Keys.bar.rawValue
        case .unknown(let value): return value
        }
    }
}

print(Sample(rawValue: "aaa").rawValue) // aaa
print(Sample(rawValue: "foo").rawValue) // foo
print(Sample.foo.rawValue) // foo
print(Sample.bar.rawValue) // bar