swift - swift 中枚举成员值的表示？

Question

enum CompassPoint {
case north, east, south, west
}

var compassHeading = CompassPoint.west

我读到“枚举的大小写值是实际值，而不仅仅是另一种编写原始值的方式。”我对这个说法感到困惑。如果案例本身是新类型，那么它不应该被初始化为:

var compassHeading = CompassPoint.west()

根据 apple 的说法，枚举不包括隐式初始值设定项……这让我更加困惑。

Answer 1

TLDR;

如果键入enum 的case，其中case 具有关联值，则 case 的 >type 将是一个高阶函数，其参数与关联值匹配，返回类型与 enum 本身匹配。由于允许不同的 case 具有不同类型(和数量)的关联值，自然地，键入的 enum case 的 type 可以不同。这里的重要性在于区分 enum instance(总是有一个给定的 case 作为 value)和个案本身的显式 类型(当不是值时)。

---

一个enum instance总是与一个case相关联，并且总是有的type>枚举

我不知道你引用的来源，但是the Language Guide将每个 case 描述为值非常简单:

An enumeration defines a common type for a group of related values and enables you to work with those values in a type-safe way within your code.

enum:s 的typed cases 与不同关联值的 case 将定义不同类型的高阶函数类型，所有返回 enum 的类型

但是除了 case instance 的 enum 的值 View 之外，可能会注意到每个 case(输入出来!)本身有一个类型(尽管不是struct Foo {} 意义上的"new"类型)，不同的类型可能不同相同 enum 的情况。如果 case 没有关联值，则此类型简单地等于 enum 本身，但如果 case 使用关联值，则 typecase 的 > 将是高阶函数类型，参数类型为关联值，返回类型为 enum 类型本身。不同的case可以有不同的关联值，自然不同的case可以对应不同的类型。

Alternatively, enumeration cases can specify associated values of any type to be stored along with each different case value, much as unions or variants do in other languages. You can define a common set of related cases as part of one enumeration, each of which has a different set of values of appropriate types associated with it.

...

You can define Swift enumerations to store associated values of any given type, and the value types can be different for each case of the enumeration if needed.

enum Foo {
    case bar
    case baz(Int) // Int associated value
    case bax()    // Void associated value
}

print(type(of: Foo.bar)) // Foo
print(type(of: Foo.baz)) // (Int) -> Foo
print(type(of: Foo.bax)) // () -> Foo

func foo(_ closure: (Int) -> Foo) -> Foo {
    return closure(42)
}

let foobaz = foo(Foo.baz) // 'foobar' is 'Foo.baz' (ass. value 42)

let foobar = foo(Foo.bar) // wont compile, type mismatch
let foobax = foo(Foo.bax) // wont compile, type mismatch

现在，由于不同的 case 有不同的类型(当输入时，不是 Foo 实例的一部分)，给定 case 的“初始化”到给定的 enum 实例看起来会有所不同，具体取决于 case 是否具有任何关联值。

enum Foo {
    case bar
    case baz(Int) // Int associated value
    case bax()    // Void associated value
}

var foo = Foo.bar // no associated values
foo = Foo.baz(42) // expects Int associated value: needs to be _invoked_(/called)
foo = Foo.bax()   // expects empty tuple '()' associated value: needs to be _invoked_(/called)

如您所见，一个没有关联值的 case instance 只需键入 enum 类型和 case(因为这种情况的类型将是 enum 本身:与 Foo.bar 比较)，而具有关联值(甚至 ())的情况将需要在实例化时调用。这种调用，特别是对于上面的 bax() 情况，可能看起来很像一些隐式初始化，但它只是调用闭包类型来接收 instance返回类型 Foo。

let aVoidFooClosure = Foo.bax
let aFooInstance = aVoidFooClosure()
  // invoke! This now have value 'Foo.bax' (empty tuple '()' associated value)