Swift5.3 语言指南(十) 枚举

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9728366.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

一个枚举定义了一个通用型的一组相关的值，使您能够工作在你的代码中的类型安全方式的值。

如果您熟悉C，您将知道C枚举将相关名称分配给一组整数值。Swift中的枚举更加灵活，不必为每种枚举都提供值。如果为每种枚举情况提供了一个值（称为原始值），则该值可以是字符串，字符或任何整数或浮点类型的值。

另外，枚举案例可以指定要存储的任何类型的关联值以及每个不同的案例值，这与其他语言中的并集或变体很相似。您可以将一组常见的相关案例定义为一个枚举的一部分，每个枚举都有一组与之相关的适当类型的不同值。

Swift中的枚举本身就是一流的类型。它们采用了传统上仅由类支持的许多功能，例如提供枚举当前值的附加信息的计算属性，以及提供与枚举所表示的值相关的功能的实例方法。枚举还可以定义初始值设定项以提供初始大小写值。可以扩展以扩展其功能，使其超出其最初的实现；并可以遵循协议以提供标准功能。

有关这些功能的更多信息，请参见属性，方法，初始化，扩展和协议。

枚举语法

您用enum关键字引入枚举，并将它们的整个定义放在一对大括号内：

  1. enum SomeEnumeration {
  2. // enumeration definition goes here
  3. }

这是指南针的四个要点的示例：

  1. enum CompassPoint {
  2. case north
  3. case south
  4. case east
  5. case west
  6. }

在枚举定义的值（例如north，south，east，和west）是其枚举的情况下。您可以使用case关键字引入新的枚举案例。

注意

与C和Objective-C之类的语言不同，Swift枚举案例默认情况下未设置整数值。在CompassPoint上面的，例如north，south，east和west不等于隐式0，1，2和3。取而代之的是，不同的枚举情况本身就是具有明确定义的类型的值CompassPoint。

多个案例可以单行显示，并以逗号分隔：

  1. enum Planet {
  2. case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
  3. }

每个枚举定义都定义一个新类型。与Swift中的其他类型一样，它们的名称（例如CompassPoint和Planet）以大写字母开头。给枚举类型使用单数而不是复数名称，以使它们读为不言而喻：

  1. var directionToHead = CompassPoint.west

directionToHead当使用可能的值之一进行初始化时，会推断出类型CompassPoint。一旦directionToHead声明为CompassPoint，您可以CompassPoint使用较短的点语法将其设置为其他值：

  1. directionToHead = .east

的类型directionToHead是已知的，因此您可以在设置其值时删除该类型。当使用显式类型的枚举值时，这使代码更具可读性。

将枚举值与switch语句匹配

您可以使用以下switch语句来匹配单个枚举值：

  1. directionToHead = .south
  2. switch directionToHead {
  3. case .north:
  4. print("Lots of planets have a north")
  5. case .south:
  6. print("Watch out for penguins")
  7. case .east:
  8. print("Where the sun rises")
  9. case .west:
  10. print("Where the skies are blue")
  11. }
  12. // Prints "Watch out for penguins"

您可以将代码读取为：

“考虑的价值directionToHead。如果相等.north，请打印。如果相等，请打印。”"Lots of planets have a north".south"Watch out for penguins"

…等等。

如控制流中所述，switch在考虑枚举的情况时，声明必须是详尽的。如果省略casefor .west，则该代码不会编译，因为它不会考虑所有CompassPoint情况。要求详尽无遗，以确保不会意外省略枚举案例。

如果不适合case为每个枚举案例提供，则可以提供一个default案例以涵盖未明确解决的所有案例：

  1. let somePlanet = Planet.earth
  2. switch somePlanet {
  3. case .earth:
  4. print("Mostly harmless")
  5. default:
  6. print("Not a safe place for humans")
  7. }
  8. // Prints "Mostly harmless"

遍历枚举案例

对于某些枚举，收集所有该枚举的案例很有用。您可以通过在枚举名称后写来启用此功能。Swift将所有案例的集合公开为枚举类型的属性。这是一个例子：: CaseIterableallCases

  1. enum Beverage: CaseIterable {
  2. case coffee, tea, juice
  3. }
  4. let numberOfChoices = Beverage.allCases.count
  5. print("(numberOfChoices) beverages available")
  6. // Prints "3 beverages available"

在上面的示例中，您编写Beverage.allCases了访问包含所有Beverage枚举案例的集合的权限。您可以allCases像使用任何其他集合一样使用该集合的元素是枚举类型的实例，因此在这种情况下它们是Beverage值。上面的示例计算了有多少个案例，下面的示例使用for循环遍历所有案例。

  1. for beverage in Beverage.allCases {
  2. print(beverage)
  3. }
  4. // coffee
  5. // tea
  6. // juice

上面示例中使用的语法将枚举标记为符合CaseIterable协议。有关协议的信息，请参见协议。

关联价值

上一节中的示例说明了枚举的情况如何本身就是已定义（和键入）的值。您可以将常量或变量设置为Planet.earth，然后稍后检查该值。但是，有时可以将其他类型的值与这些case值一起存储。此附加信息称为关联值，每次将这种情况用作代码中的值时，它都会有所不同。

您可以定义Swift枚举来存储任何给定类型的关联值，并且如果需要，每种枚举的值类型可以不同。类似于这些的枚举在其他编程语言中称为“ 区分联合”，“ 标记联合 ”或“ 变体”。

例如，假设库存跟踪系统需要通过两种不同类型的条形码来跟踪产品。有些产品标注与UPC格式，它采用数字一个维条码0来9。每个条形码都有一个数字系统数字，后跟五个制造商代码数字和五个产品代码数字。这些后面是校验位，以验证代码是否已正确扫描：

../_images/barcode_UPC_2x.png

其他产品带有QR码格式的2D条形码标签，可以使用任何ISO 8859-1字符，并且可以编码最长为2953个字符的字符串：

../_images/barcode_QR_2x.png

对于库存跟踪系统而言，将UPC条形码存储为四个整数的元组和将QR码条形码存储为任意长度的字符串非常方便。

在Swift中，定义两种类型的产品条形码的枚举可能看起来像这样：

  1. enum Barcode {
  2. case upc(Int, Int, Int, Int)
  3. case qrCode(String)
  4. }

可以理解为：

“定义称为枚举类型Barcode，这可能需要或者是的值upc与类型相关联的值（Int，Int，Int，Int），或的值qrCode与类型相关联的值String。”

该定义不提供任何实际值Int或String值-只是定义了常量和变量等于或时可以存储的关联值的类型。BarcodeBarcode.upcBarcode.qrCode

然后，您可以使用以下任一类型创建新条形码：

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

本示例创建一个名为的新变量，productBarcode并为其分配一个值为的Barcode.upc元组值。(8, 85909, 51226, 3)

您可以为同一产品分配不同类型的条形码：

  1. productBarcode = .qrCode("ABCDEFGHIJKLMNOP")

此时，原始Barcode.upc值及其整数值将被新Barcode.qrCode值及其字符串值替换。类型的常量和变量Barcode可以存储a .upc或a .qrCode（以及它们的关联值），但是在任何给定时间只能存储其中之一。

您可以使用switch语句检查不同的条形码类型，类似于将枚举值与Switch语句匹配中的示例。但是，这次，关联值被提取为switch语句的一部分。您可以将每个关联值提取为常量（带有let前缀）或变量（带有var前缀），以在switch案例的正文中使用：

  1. switch productBarcode {
  2. case .upc(let numberSystem, let manufacturer, let product, let check):
  3. print("UPC: (numberSystem), (manufacturer), (product), (check).")
  4. case .qrCode(let productCode):
  5. print("QR code: (productCode).")
  6. }
  7. // Prints "QR code: ABCDEFGHIJKLMNOP."

为了简单起见，如果枚举案例的所有关联值都提取为常量，或者所有提取的变量都为变量，则可以在案例名称之前放置一个var或let注解：

  1. switch productBarcode {
  2. case let .upc(numberSystem, manufacturer, product, check):
  3. print("UPC : (numberSystem), (manufacturer), (product), (check).")
  4. case let .qrCode(productCode):
  5. print("QR code: (productCode).")
  6. }
  7. // Prints "QR code: ABCDEFGHIJKLMNOP."

原始值

关联值中的条形码示例显示了枚举的情况如何声明它们存储了不同类型的关联值。作为关联值的替代方法，枚举案例可以预先填充默认值（称为原始值），这些默认值都是相同的类型。

这是一个将原始ASCII值与命名枚举大小写一起存储的示例：

  1. enum ASCIIControlCharacter: Character {
  2. case tab = " "
  3. case lineFeed = " "
  4. case carriageReturn = " "
  5. }

在这里，被称为的枚举的原始值ASCIIControlCharacter被定义为type Character，并被设置为一些更常见的ASCII控制字符。Character值在“ 字符串和字符”中描述。

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

注意

原始值是不一样的关联值。首次在代码中定义枚举时，原始值将设置为预填充的值，例如上面的三个ASCII代码。特定枚举情况的原始值始终相同。当您根据枚举的一种情况创建新的常量或变量时，将设置关联值，并且每次都可以不同。

隐式分配的原始值

当使用存储整数或字符串原始值的枚举时，不必为每种情况显式分配原始值。如果您不这样做，Swift会自动为您分配值。

例如，当整数用于原始值时，每种情况的隐式值都比前一种情况大一。如果第一种情况未设置值，则其值为0。

下面的枚举是对先前Planet枚举的改进，使用整数原始值来表示每个行星从太阳起的阶数：

  1. enum Planet: Int {
  2. case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
  3. }

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

如果将字符串用于原始值，则每种情况的隐式值都是该情况名称的文本。

下面的枚举是对先前CompassPoint枚举的改进，使用字符串原始值来表示每个方向的名称：

  1. enum CompassPoint: String {
  2. case north, south, east, west
  3. }

在上面的示例中，CompassPoint.south其隐式原始值为"south"，依此类推。

您可以使用其rawValue属性访问枚举案例的原始值：

  1. let earthsOrder = Planet.earth.rawValue
  2. // earthsOrder is 3
  4. let sunsetDirection = CompassPoint.west.rawValue
  5. // sunsetDirection is "west"

从原始值初始化

如果您使用原始值类型定义枚举，则枚举将自动接收一个初始化器，该初始化器采用原始值类型的值（称为rawValue）作为参数，并返回枚举用例或nil。您可以使用此初始化程序尝试创建枚举的新实例。

本示例从其原始值识别天王星7：

  1. let possiblePlanet = Planet(rawValue: 7)
  2. // possiblePlanet is of type Planet? and equals Planet.uranus

但是，并非所有可能的Int值都会找到匹配的行星。因此，原始值初始化程序始终返回可选的枚举情况。在上面的示例中，possiblePlanet类型为Planet?或“可选” Planet。

注意

原始值初始化程序是一个失败的初始化程序，因为并非每个原始值都将返回枚举情况。有关更多信息，请参见Failable Initializers。

如果您尝试寻找位置为的行星，则原始值初始值设定项返回11的可选Planet值将是nil：

  1. let positionToFind = 11
  2. if let somePlanet = Planet(rawValue: positionToFind) {
  3. switch somePlanet {
  4. case .earth:
  5. print("Mostly harmless")
  6. default:
  7. print("Not a safe place for humans")
  8. }
  9. } else {
  10. print("There isn't a planet at position (positionToFind)")
  11. }
  12. // Prints "There isn't a planet at position 11"

本示例使用可选绑定尝试访问原始值为的行星11。该语句创建一个可选的，并设置为该可选的值（如果可以检索的话）。在这种情况下，无法检索位置为的行星，因此将执行分支。if let somePlanet = Planet(rawValue: 11)PlanetsomePlanetPlanet11else

递归枚举

甲递归枚举是具有枚举作为一个或一个以上的枚举案件相关联的值的另一个实例的枚举。您可以通过在枚举案例indirect之前编写来表明它是递归的，这告诉编译器插入必要的间接层。

例如，这是一个存储简单算术表达式的枚举：

  1. enum ArithmeticExpression {
  2. case number(Int)
  3. indirect case addition(ArithmeticExpression, ArithmeticExpression)
  4. indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
  5. }

您也可以indirect在枚举开始之前编写代码，以为具有关联值的所有枚举用例启用间接寻址：

  1. indirect enum ArithmeticExpression {
  2. case number(Int)
  3. case addition(ArithmeticExpression, ArithmeticExpression)
  4. case multiplication(ArithmeticExpression, ArithmeticExpression)
  5. }

该枚举可以存储三种算术表达式：素数，两个表达式的加法以及两个表达式的乘法。将addition与multiplication案件有同样的算术表达式，这些相关的值有可能嵌套表达式相关的值。例如，该表达式在乘法的右侧具有一个数字，而在乘法的左侧具有另一个表达式。因为数据是嵌套的，所以用于存储数据的枚举也需要支持嵌套-这意味着该枚举需要递归。下面的代码显示了为创建的递归枚举：(5 + 4) * 2ArithmeticExpression(5 + 4) * 2

  1. let five = ArithmeticExpression.number(5)
  2. let four = ArithmeticExpression.number(4)
  3. let sum = ArithmeticExpression.addition(five, four)
  4. let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))

递归函数是使用具有递归结构的数据的直接方法。例如，下面是一个计算算术表达式的函数：

  1. func evaluate(_ expression: ArithmeticExpression) -> Int {
  2. switch expression {
  3. case let .number(value):
  4. return value
  5. case let .addition(left, right):
  6. return evaluate(left) + evaluate(right)
  7. case let .multiplication(left, right):
  8. return evaluate(left) * evaluate(right)
  9. }
  10. }
  12. print(evaluate(product))
  13. // Prints "18"

该函数通过简单地返回相关值来评估纯数字。它通过在左侧评估表达式，在右侧评估表达式，然后将它们相加或相乘来评估加法或乘法。

 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/strengthen/p/9728366.html