Enumerations (枚举)

Anenumerationdefines 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.

枚举为一组相关的值定义了一个共同的类型，使你可以在你的代码中以类型安全的方式来使用这些值。

If you are familiar with C, you will know that C enumerations assign related names to a set of integer values. Enumerations in Swift are much more flexible, and do not have to provide a value for each case of the enumeration. If a value (known as a “raw” value)isprovided for each enumeration case, the value can be a string, a character, or a value of any integer or floating-point type.

如果你熟悉 C 语言，你会知道在 C 语言中，枚举会为一组整型值分配相关联的名称。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。

Alternatively, enumeration cases can specify associated values ofanytype 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.

此外，枚举成员可以指定任意类型的关联值存储到枚举成员中，就像其他语言中的联合体（unions）和变体（variants）。你可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。

Enumerations in Swift are first-class types in their own right. They adopt many features traditionally supported only by classes, such as computed properties to provide additional information about the enumeration’s current value, and instance methods to provide functionality related to the values the enumeration represents. Enumerations can also define initializers to provide an initial case value; can be extended to expand their functionality beyond their original implementation; and can conform to protocols to provide standard functionality.

在 Swift中，枚举类型是一等（first-class）类型。它们采用了很多在传统上只被类（class）所支持的特性，例如计算属性（computedproperties），用于提供枚举值的附加信息，实例方法（instancemethods），用于提供和枚举值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始实现的基础上扩展它们的功能；还可以遵循协议（protocols）来提供标准的功能。

For more on these capabilities, seeProperties,Methods,Initialization,Extensions, andProtocols.

想了解更多相关信息，请参见属性，方法，构造过程，扩展和协议。

Enumeration Syntax (枚举语法)

You introduce enumerations with theenumkeyword and place their entire definition within a pair of braces:

使用enum关键词来创建枚举并且把它们的整个定义放在一对大括号内：

enum SomeEnumeration{

    // enumeration definition goes here

}

Here’s an example for the four main points of a compass:

下面是用枚举表示指南针四个方向的例子：

enum CompassPoint{

    case north

    case south

    case east

    case west

}

The values defined in an enumeration (such asnorth,south,east, andwest) are itsenumeration cases. You use thecasekeyword to introduce new enumeration cases.

枚举中定义的值（如north，south，east和west）是这个枚举的成员值（或成员）。你可以使用case关键字来定义一个新的枚举成员值。

Note

Unlike C and Objective-C, Swift enumeration cases are not assigned a default integer value when they are created. In theCompassPointexample above,north,south,eastandwestdo not implicitly equal0,1,2and3. Instead, the different enumeration cases are fully-fledged values in their own right, with an explicitly-defined type ofCompassPoint.

与 C 和 Objective-C 不同，Swift 的枚举成员在被创建时不会被赋予一个默认的整型值。在上面的CompassPoint例子中，north，south，east和west不会被隐式地赋值为0，1，2和3。相反，这些枚举成员本身就是完备的值，这些值的类型是已经明确定义好的CompassPoint类型。

Multiple cases can appear on a single line, separated by commas:

多个成员值可以出现在同一行上，用逗号隔开：

enum Planet{

    case mercury,venus,earth,mars,jupiter,saturn,uranus,neptune

}

Each enumeration definition defines a brand new type. Like other types in Swift, their names (such asCompassPointandPlanet) should start with a capital letter. Give enumeration types singular rather than plural names, so that they read as self-evident:

每个枚举定义了一个全新的类型。像 Swift 中其他类型一样，它们的名字（例如CompassPoint和Planet）应该以一个大写字母开头。给枚举类型起一个单数名字而不是复数名字，以便于读起来更加容易理解：

var directionToHead = CompassPoint.west

The type ofdirectionToHeadis inferred when it is initialized with one of the possible values ofCompassPoint. OncedirectionToHeadis declared as aCompassPoint, you can set it to a differentCompassPointvalue using a shorter dot syntax:

directionToHead的类型可以在它被CompassPoint的某个值初始化时推断出来。一旦directionToHead被声明为CompassPoint类型，你可以使用更简短的点语法将其设置为另一个CompassPoint的值：

directionToHead = .east

The type ofdirectionToHeadis already known, and so you can drop the type when setting its value. This makes for highly readable code when working with explicitly-typed enumeration values.

当directionToHead的类型已知时，再次为其赋值可以省略枚举类型名。在使用具有显式类型的枚举值时，这种写法让代码具有更好的可读性。

Matching Enumeration Values with a Switch Statement (使用 Switch 语句匹配枚举值)

You can match individual enumeration values with aswitchstatement:

你可以使用switch语句匹配单个枚举值：

directionToHead = .south

switch directionToHead {

    case .north:

        print("Lots of planets have a north")

    case .south:

        print("Watch out for penguins")

    case .east:

        print("Where the sun rises")

    case .west:

        print("Where the skies are blue")

}

// Prints "Watch out for penguins"

You can read this code as:

你可以这样理解这段代码：

“Consider the value ofdirectionToHead. In the case where it equals.north, print"Lots of planets have a north". In the case where it equals.south, print"Watch out for penguins".”

“判断directionToHead的值。当它等于.north，打印“Lots of planets have a north”。当它等于.south，打印“Watch out for penguins”。”

…and so on.

……以此类推。

As described inControl Flow, aswitchstatement must be exhaustive when considering an enumeration’s cases. If thecasefor.westis omitted, this code does not compile, because it does not consider the complete list ofCompassPointcases. Requiring exhaustiveness ensures that enumeration cases are not accidentally omitted.

正如在控制流中介绍的那样，在判断一个枚举类型的值时，switch语句必须穷举所有情况。如果忽略了.west这种情况，上面那段代码将无法通过编译，因为它没有考虑到CompassPoint的全部成员。强制穷举确保了枚举成员不会被意外遗漏。

When it is not appropriate to provide acasefor every enumeration case, you can provide adefaultcase to cover any cases that are not addressed explicitly:

当不需要匹配每个枚举成员的时候，你可以提供一个default分支来涵盖所有未明确处理的枚举成员：

let somePlanet=Planet.earth

switch somePlanet {

    case .earth:

        print("Mostly harmless")

    default:

        print("Not a safe place for humans")

}

// Prints "Mostly harmless"

Associated Values (关联值)

The examples in the previous section show how the cases of an enumeration are a defined (and typed) value in their own right. You can set a constant or variable toPlanet.earth, and check for this value later. However, it is sometimes useful to be able to storeassociated valuesof other types alongside these case values. This enables you to store additional custom information along with the case value, and permits this information to vary each time you use that case in your code.

上一小节的例子演示了如何定义和分类枚举的成员。你可以为Planet.earth设置一个常量或者变量，并在赋值之后查看这个值。然而，有时候能够把其他类型的关联值和成员值一起存储起来会很有用。这能让你连同成员值一起存储额外的自定义信息，并且你每次在代码中使用该枚举成员时，还可以修改这个关联值。

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. Enumerations similar to these are known asdiscriminated unions,tagged unions, orvariantsin other programming languages.

你可以定义 Swift枚举来存储任意类型的关联值，如果需要的话，每个枚举成员的关联值类型可以各不相同。枚举的这种特性跟其他语言中的可识别联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。

For example, suppose an inventory tracking system needs to track products by two different types of barcode. Some products are labeled with 1D barcodes in UPC format, which uses the numbers0to9. Each barcode has a “number system” digit, followed by five “manufacturer code” digits and five “product code” digits. These are followed by a “check” digit to verify that the code has been scanned correctly:

例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品。有些商品上标有使用0到9的数字的 UPC 格式的一维条形码。每一个条形码都有一个代表“数字系统”的数字，该数字后接五位代表“厂商代码”的数字，接下来是五位代表“产品代码”的数字。最后一个数字是“检查”位，用来验证代码是否被正确扫描：

Other products are labeled with 2D barcodes in QR code format, which can use any ISO 8859-1 character and can encode a string up to 2,953 characters long:

其他商品上标有 QR 码格式的二维码，它可以使用任何 ISO 8859-1 字符，并且可以编码一个最多拥有 2,953 个字符的字符串：

It would be convenient for an inventory tracking system to be able to store UPC barcodes as a tuple of four integers, and QR code barcodes as a string of any length.

这便于库存跟踪系统用包含四个整型值的元组存储 UPC 码，以及用任意长度的字符串储存 QR 码。

In Swift, an enumeration to define product barcodes of either type might look like this:

在 Swift 中，使用如下方式定义表示两种商品条形码的枚举：

enum Barcode{

    case upc(Int,Int,Int,Int)

    case qrCode(String)

}

This can be read as:

以上代码可以这么理解：

“Define an enumeration type calledBarcode, which can take either a value ofupcwith an associated value of type (Int,Int,Int,Int), or a value ofqrCodewith an associated value of typeString.”

“定义一个名为Barcode的枚举类型，它的一个成员值是具有(Int，Int，Int，Int)类型关联值的upc，另一个成员值是具有String类型关联值的qrCode。”

This definition does not provide any actualIntorStringvalues—it just defines thetypeof associated values thatBarcodeconstants and variables can store when they are equal toBarcode.upcorBarcode.qrCode.

这个定义不提供任何Int或String类型的关联值，它只是定义了，当Barcode常量和变量等于Barcode.upc或Barcode.qrCode时，可以存储的关联值的类型。

New barcodes can then be created using either type:

然后可以使用任意一种条形码类型创建新的条形码，例如：

var productBarcode = Barcode.upc(8,85909,51226,3)

This example creates a new variable calledproductBarcodeand assigns it a value ofBarcode.upcwith an associated tuple value of(8, 85909, 51226, 3).

上面的例子创建了一个名为productBarcode的变量，并将Barcode.upc赋值给它，关联的元组值为(8, 85909, 51226, 3)。

The same product can be assigned a different type of barcode:

同一个商品可以被分配一个不同类型的条形码，例如：

productBarcode = .qrCode("ABCDEFGHIJKLMNOP")

At this point, the originalBarcode.upcand its integer values are replaced by the newBarcode.qrCodeand its string value. Constants and variables of typeBarcodecan store either a.upcor a.qrCode(together with their associated values), but they can only store one of them at any given time.

这时，原始的Barcode.upc和其整数关联值被新的Barcode.qrCode和其字符串关联值所替代。Barcode类型的常量和变量可以存储一个.upc或者一个.qrCode（连同它们的关联值），但是在同一时间只能存储这两个值中的一个。

The different barcode types can be checked using a switch statement, as before. This time, however, the associated values can be extracted as part of the switch statement. You extract each associated value as a constant (with theletprefix) or a variable (with thevarprefix) for use within theswitchcase’s body:

像先前那样，可以使用一个 switch 语句来检查不同的条形码类型。然而，这一次，关联值可以被提取出来作为 switch 语句的一部分。你可以在switch的 case 分支代码中提取每个关联值作为一个常量（用let前缀）或者作为一个变量（用var前缀）来使用：

switch productBarcode {

    case .upc(letnumberSystem,letmanufacturer,letproduct,letcheck):

        print("UPC:\(numberSystem),\(manufacturer),\(product),\(check).")

    case .qrCode(letproductCode):

        print("QR code:\(productCode).")

}

// Prints "QR code: ABCDEFGHIJKLMNOP."

If all of the associated values for an enumeration case are extracted as constants, or if all are extracted as variables, you can place a singlevarorletannotation before the case name, for brevity:

如果一个枚举成员的所有关联值都被提取为常量，或者都被提取为变量，为了简洁，你可以只在成员名称前标注一个let或者var：

switch productBarcode {

    case let .upc(numberSystem,manufacturer,product,check):

        print("UPC :\(numberSystem),\(manufacturer),\(product),\(check).")

    case let .qrCode(productCode):

        print("QR code:\(productCode).")

}

// Prints "QR code: ABCDEFGHIJKLMNOP."

Raw Values (原始值)

The barcode example inAssociated Valuesshows how cases of an enumeration can declare that they store associated values of different types. As an alternative to associated values, enumeration cases can come prepopulated with default values (calledraw values), which are all of the same type.

在关联值小节的条形码例子中，演示了如何声明存储不同类型关联值的枚举成员。作为关联值的替代选择，枚举成员可以被默认值（称为原始值）预填充，这些原始值的类型必须相同。

Here’s an example that stores raw ASCII values alongside named enumeration cases:

这是一个使用 ASCII 码作为原始值的枚举：

enum ASCIIControlCharacter:Character {

    case tab="\t"

    case lineFeed="\n"

    case carriageReturn="\r"

}

Here, the raw values for an enumeration calledASCIIControlCharacterare defined to be of typeCharacter, and are set to some of the more common ASCII control characters.Charactervalues are described inStrings and Characters.

枚举类型ASCIIControlCharacter的原始值类型被定义为Character，并设置了一些比较常见的 ASCII 控制字符。Character的描述详见字符串和字符部分。

Raw values can be strings, characters, or any of the integer or floating-point number types. Each raw value must be unique within its enumeration declaration.

原始值可以是字符串，字符，或者任意整型值或浮点型值。每个原始值在枚举声明中必须是唯一的。

Note

Raw values arenotthe same as associated values. Raw values are set to prepopulated values when you first define the enumeration in your code, like the three ASCII codes above. The raw value for a particular enumeration case is always the same. Associated values are set when you create a new constant or variable based on one of the enumeration’s cases, and can be different each time you do so.

原始值和关联值是不同的。原始值是在定义枚举时被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终不变。关联值是创建一个基于枚举成员的常量或变量时才设置的值，枚举成员的关联值可以变化。

Implicitly Assigned Raw Values (原始值的隐式赋值)

When you’re working with enumerations that store integer or string raw values, you don’t have to explicitly assign a raw value for each case.When you don’t, Swift will automatically assign the values for you.

在使用原始值为整数或者字符串类型的枚举时，不需要显式地为每一个枚举成员设置原始值，Swift 将会自动为你赋值。

For instance, when integers are used for raw values, the implicit value for each case is one more than the previous case. If the first case doesn’t have a value set, its value is0.

例如，当使用整数作为原始值时，隐式赋值的值依次递增1。如果第一个枚举成员没有设置原始值，其原始值将为0。

The enumeration below is a refinement of the earlierPlanetenumeration, with integer raw values to represent each planet’s order from the sun:

下面的枚举是对之前Planet这个枚举的一个细化，利用整型的原始值来表示每个行星在太阳系中的顺序：

enum Planet:Int {

    case mercury=1,venus,earth,mars,jupiter,saturn,uranus,neptune

}

In the example above,Planet.mercuryhas an explicit raw value of1,Planet.venushas an implicit raw value of2, and so on.

在上面的例子中，Plant.mercury的显式原始值为1，Planet.venus的隐式原始值为2，依次类推。

When strings are used for raw values, the implicit value for each case is the text of that case’s name.

当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称。

The enumeration below is a refinement of the earlierCompassPointenumeration, with string raw values to represent each direction’s name:

下面的例子是CompassPoint枚举的细化，使用字符串类型的原始值来表示各个方向的名称：

enum CompassPoint:String {

    case north,south,east,west

}

In the example above,CompassPoint.southhas an implicit raw value of"south", and so on.

上面例子中，CompassPoint.south拥有隐式原始值south，依次类推。

You access the raw value of an enumeration case with itsrawValueproperty:

使用枚举成员的rawValue属性可以访问该枚举成员的原始值：

let earthsOrder=Planet.earth.rawValue

// earthsOrder is 3

let sunsetDirection=CompassPoint.west.rawValue

// sunsetDirection is "west"

Initializing from a Raw Value (使用原始值初始化枚举实例)

If you define an enumeration with a raw-value type, the enumeration automatically receives an initializer that takes a value of the raw value’s type (as a parameter calledrawValue) and returns either an enumeration case ornil. You can use this initializer to try to create a new instance of the enumeration.

如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法接收一个叫做rawValue的参数，参数类型即为原始值类型，返回值则是枚举成员或nil。你可以使用这个初始化方法来创建一个新的枚举实例。

This example identifies Uranus from its raw value of7:

这个例子利用原始值7创建了枚举成员uranus：

let possiblePlanet = Planet(rawValue:7)

// possiblePlanet is of type Planet? and equals Planet.uranus

Not all possibleIntvalues will find a matching planet, however. Because of this, the raw value initializer always returns anoptionalenumeration case. In the example above,possiblePlanetis of typePlanet?, or “optionalPlanet.”

然而，并非所有Int值都可以找到一个匹配的行星。因此，原始值构造器总是返回一个可选的枚举成员。在上面的例子中，possiblePlanet是Planet?类型，或者说“可选的Planet”。

Note

The raw value initializer is a failable initializer, because not every raw value will return an enumeration case. For more information, seeFailable Initializers.

原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见可失败构造器

If you try to find a planet with a position of11, the optionalPlanetvalue returned by the raw value initializer will be nil:

如果你试图寻找一个位置为11的行星，通过原始值构造器返回的可选Planet值将是nil：

let positionToFind=11

if let somePlanet = Planet(rawValue:positionToFind) {

switch somePlanet{

    case .earth:

        print("Mostly harmless")

    default:

        print("Not a safe place for humans")

    }

} else {

        print("There isn't a planet at position\(positionToFind)")

}

// Prints "There isn't a planet at position 11"

This example uses optional binding to try to access a planet with a raw value of11. The statementif let somePlanet = Planet(rawValue: 11)creates an optionalPlanet, and setssomePlanetto the value of that optionalPlanetif it can be retrieved. In this case, it is not possible to retrieve a planet with a position of11, and so theelsebranch is executed instead.

这个例子使用了可选绑定（optional binding），试图通过原始值11来访问一个行星。if let somePlanet = Planet(rawValue: 11)语句创建了一个可选Planet，如果可选Planet的值存在，就会赋值给somePlanet。在这个例子中，无法检索到位置为11的行星，所以else分支被执行。

Recursive Enumerations (递归枚举)

Arecursive enumerationis an enumeration that has another instance of the enumeration as the associated value for one or more of the enumeration cases. You indicate that an enumeration case is recursive by writingindirectbefore it, which tells the compiler to insert the necessary layer of indirection.

递归枚举是一种枚举类型，它有一个或多个枚举成员使用该枚举类型的实例作为关联值。使用递归枚举时，编译器会插入一个间接层。你可以在枚举成员前加上indirect来表示该成员可递归。

For example, here is an enumeration that stores simple arithmetic expressions:

例如，下面的例子中，枚举类型存储了简单的算术表达式：

enum ArithmeticExpression {

    case number(Int)

        indirect case addition(ArithmeticExpression,ArithmeticExpression)

         indirect case multiplication(ArithmeticExpression,ArithmeticExpression)

}

You can also writeindirectbefore the beginning of the enumeration, to enable indirection for all of the enumeration’s cases that need it:

你也可以在枚举类型开头加上indirect关键字来表明它的所有成员都是可递归的：

indirect enum ArithmeticExpression{

    case number(Int)

    case addition(ArithmeticExpression,ArithmeticExpression)

    case multiplication(ArithmeticExpression,ArithmeticExpression)

}

This enumeration can store three kinds of arithmetic expressions: a plain number, the addition of two expressions, and the multiplication of two expressions. Theadditionandmultiplicationcases have associated values that are also arithmetic expressions—these associated values make it possible to nest expressions. For example, the expression(5 + 4) * 2has a number on the right hand side of the multiplication and another expression on the left hand side of the multiplication. Because the data is nested, the enumeration used to store the data also needs to support nesting—this means the enumeration needs to be recursive. The code below shows theArithmeticExpressionrecursive enumeration being created for(5 + 4) * 2:

上面定义的枚举类型可以存储三种算术表达式：纯数字、两个表达式相加、两个表达式相乘。枚举成员addition和multiplication的关联值也是算术表达式——这些关联值使得嵌套表达式成为可能。例如，表达式(5 + 4) * 2，乘号右边是一个数字，左边则是另一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也需要支持这种嵌套——这意味着枚举类型需要支持递归。下面的代码展示了使用ArithmeticExpression这个递归枚举创建表达式(5 + 4) * 2

let five=ArithmeticExpression.number(5)

let four=ArithmeticExpression.number(4)

let sum=ArithmeticExpression.addition(five,four)

let product=ArithmeticExpression.multiplication(sum,ArithmeticExpression.number(2))

A recursive function is a straightforward way to work with data that has a recursive structure. For example, here’s a function that evaluates an arithmetic expression:

要操作具有递归性质的数据结构，使用递归函数是一种直截了当的方式。例如，下面是一个对算术表达式求值的函数：

func evaluate(_expression:ArithmeticExpression) ->Int{

switch expression{

    case let .number(value):

         return value

    case let .addition(left,right):

        return evaluate(left) +evaluate(right)

    case let .multiplication(left,right):

        return evaluate(left) *evaluate(right)

      }

}

print(evaluate(product))

// Prints "18"

This function evaluates a plain number by simply returning the associated value. It evaluates an addition or multiplication by evaluating the expression on the left hand side, evaluating the expression on the right hand side, and then adding them or multiplying them.

该函数如果遇到纯数字，就直接返回该数字的值。如果遇到的是加法或乘法运算，则分别计算左边表达式和右边表达式的值，然后相加或相乘。