如何在 Swift 中声明特定类类型的枚举？

Question

我正在尝试创建一个类并将该类用作我的新枚举的类型，如下所示。

class Abc{
    var age  = 25
    var name = "Abhi"
}

enum TestEnum : Abc {
    case firstCase
    case secondCase
}

我在操场上遇到以下错误。

error: raw type 'Abc' is not expressible by any literal

所以我尝试像这样遵循 RawRepresentable 协议。

extension TestEnum : RawRepresentable{
    typealias RawValue = Abc

    init?(rawValue:RawValue ) {
        switch rawValue {
        case Abc.age :
            self = .firstCase

        case Abc.name :
            self = .secondCase
        }
    }

    var rawValue : RawValue {
        switch self{

        case .firstCase :
            return Abc.age

        case .secondCase :
            return Abc.name
        }
    }
}

在此之后我收到以下错误：

error: raw type 'Abc' is not expressible by any literal
error: instance member 'age' cannot be used on type 'Abc'
error: instance member 'name' cannot be used on type 'Abc'

声明某种类类型的枚举的正确方法是什么，对此并不清楚。有人帮忙吗？

Answer 1

我不太确定您想要实现什么，但请看一下我在项目中使用的实现和方法：

class Abc {
    var age: Int
    var name: String

    init(age: Int, name: String) {
        self.age = age
        self.name = name
    }
}


enum TestEnum {
    case firstCase
    case secondCase

    var instance: Abc {
        switch self {
        case .firstCase: return Abc(age: 25, name: "John")
        case .secondCase: return Abc(age: 20, name: "Marry")
        }
    }
}

//Usage:

let abc = TestEnum.secondCase.instance
print(abc.age) //prints '20'

Answer 2

来自文档

特别是，原始值类型必须符合 Equatable 协议和以下协议之一： ExpressibleByIntegerLiteral 用于整数文字， ExpressibleByFloatLiteral 用于浮点文字， ExpressibleByStringLiteral 用于包含任意数字的字符串文字 字符数，以及 ExpressibleByUnicodeScalarLiteral 或 ExpressibleByExtendedGraphemeClusterLiteral 用于字符串文字 只包含一个字符。

因此，让您的类 Abc 符合 Equatable 和上述协议之一。这是一个例子

public class Abc : Equatable,ExpressibleByStringLiteral{
    var age  = 25
    var name = "Abhi"
    public static func == (lhs: Abc, rhs: Abc) -> Bool {
        return (lhs.age == rhs.age && lhs.name == rhs.name)
    }
    public required init(stringLiteral value: String) {
        let components = value.components(separatedBy: ",")
        if components.count == 2 {
            self.name = components[0]
            if let age = Int(components[1]) {
                self.age = age
            }
        }
    }
    public required convenience init(unicodeScalarLiteral value: String) {
        self.init(stringLiteral: value)
    }
    public required convenience init(extendedGraphemeClusterLiteral value: String) {
        self.init(stringLiteral: value)
    }
}

enum TestEnum : Abc {
    case firstCase = "Jack,29"
    case secondCase = "Jill,26"
}

现在你可以像

一样初始化你的枚举了

let exEnum = TestEnum.firstCase
print(exEnum.rawValue.name) // prints Jack

有关详细讨论和示例，您可以参考 https://swiftwithsadiq.wordpress.com/2017/08/21/custom-types-as-raw-value-for-enum-in-swift/

Answer 3

看看Associated Values。 以您为例：

class Abc {
    var age  = 25
    var name = "Abhi"
}

enum TestEnum {
    case age(Int)
    case name(String)
}

那么你可以这样使用它：

var person = Abc()
...
var value = TestEnum.age(person.age)

switch value {
    case .age(let age):
        print("Age: \(age).")
    case .name(let name):
        print("Name: \(name).")
}

为方便起见，您可以为枚举编写扩展名，这将获取您的 Abc 对象并将其转换为枚举值：

static func fromAbc(_ object: Abc) -> TestEnum? {
    if object.age {
        return TestEnum.age(object.age)
    }

    if object.name {
        return TestEnum.name(object.name)
    }

    return nil
}

注意：在func fromAbc(object: Abc) -> TestEnum? 中，您应该将 if 中的条件替换为可以表示为 Bool（age > 0 等）的内容。

至于行值 - 在doc 中声明

原始值可以是字符串、字符或任何整数或浮点数类型。每个原始值在其枚举声明中必须是唯一的。

我不确定你是否适合在那里上课。