Difference between associated and raw values in swift enumerations

问题

Swift enumerations have both associated and raw values. But the use cases of these values is not clear to me. So I would really appreciate if anyone can explain the difference between the associated and raw values, an example would be very helpful.

回答1:

Raw values are for when every case in the enumeration is represented by a compile-time-set value. The are akin to constants, i.e.

let A = 0
let B = 1

is similar to:

enum E: Int {
    case A  // if you don't specify, IntegerLiteralConvertible-based enums start at 0
    case B
}

So, A has a fixed raw value of 0, B of 1 etc set at compile time. They all have to be the same type (the type of the raw value is for the whole enum, not each individual case). They can only be literal-convertible strings, characters or numbers. And they all have to be distinct (no two enums can have the same raw value).

Associated values are more like variables, associated with one of the enumeration cases:

enum E {
    case A(Int)
    case B
    case C(String)
}

Here, A now has an associated Int that can hold any integer value. B on the other hand, has no associated value. And C has an associated String. Associated types can be of any type, not just strings or numbers.

Any given value of type E will only ever hold one of the associated types, i.e. either an Int if the enum is an A, or a String if the enum is a C. It only needs enough space for the bigger of the two. Types like this are sometimes referred to as "discriminated unions" – a union being a variable that can hold multiple different types, but you know (from the enum case) which one it is holding.

They can even be generic. The most common example of which is Optional, which is defined like this:

enum Optional<T> {
    case .Some(T)
    case .None
}

回答2:

Answers by @Airspeed Velocity and @yoAlex5 explain the difference well, but they state than

enums can have either associated either raw values.

This is not so for Swift 4 and 5. Here is a good illustration on for having them both in one enum. You'll need default values for raw value initialiser, of course.

回答3:

In Swift, an enum cannot have both raw values and associated values at the same time.

Raw Values

enum Color: String {
    case white = "#ffffff"
    case black = "#000000"
}

A "raw value" is an unique identifier of a type. It means that you are able to construct your type by ID. For example:

XCTAssertEqual(Color.white, Color(rawValue: "#ffffff"))

Associated Values

enum Color {
    case white
    case black

    case custom(hex: String)
}

Swift's "associated values" allows you to add additional information into enum that can be defined dynamically. Please note when we introduce "associated values", we omit the "raw values" and add a type annotation. This makes it impossible to use the "raw value" to reconstruct your type, because it is now set up dynamically.

You can read the "associated value" as follows:

let myColor = Color.custom(hex: "#ff00ff")

switch myColor {
case .custom(let hex):
    print("custom color hex:\(hex)") //#ff00ff
case .white:
    print("white color")
case .black:
    print("black color")
}

More information can be found in this Medium article, by Mischa Hildebrand.

来源：https://stackoverflow.com/questions/30462770/difference-between-associated-and-raw-values-in-swift-enumerations

标签

swift

enums

enumeration