array高级用法 swift
2018-04-25 14:29:00 weixin_33720078 阅读数 29
import UIKit  

//数组问题  

struct student {  

var name ="123"  

}  

var str ="Hello, playground"  

//将多个数组合成一个数组  

let array = [[1,2,4,],[3,5],[565,33]]  

//let arrayMap = array.map{$0}  

let arrayFlat = [[123,123],[444]].flatMap{ $0 }  

print(arrayFlat)  



//分离出条件内的数字并和成数组  

let arrayFilter = [1,2,3,4,5,6,20]  

let tempFilter = arrayFilter.filter{ $0 % 2 == 0 }  

print(tempFilter)  



//获取数组的和  

let sumArray = [2,3,5,6,7]  

let tempSum = sumArray.reduce(0){ $0 + $1}  

print(tempSum)  



//从类里面遍历出来  

var oneS = student.init()  

oneS.name = "1"  

var oneS1 = student.init()  

oneS1.name = "2"  

var oneS2 = student.init()  

oneS2.name = "3"  

let students = [oneS,oneS1,oneS2]  

let endS = students.filter { (student) -> Bool in  

return student.name == "2"  

}  

if let endA = endS.last {  

print(endS.last)  

}  



//取出空数组  

let nilArray = [[],[23,322],[4,3,4],[],[666,777],[]]  

let tempNilArray = nilArray.filter { (array) -> Bool in  

return array.count > 0  

}  

print(tempNilArray)  



//forEach遍历数据  

let testArrA = [1,4,5,6,1]  

let testArrB = [1,2,3,4,5]  

let testArrC = ["a","b","c","D"]  

(2..

    print(countT)  

}  



//遍历  

testArrC.enumerated().forEach { (oneStr) in  

print(oneStr.element)  

}  



//从某一点这个点开是,分离成两个数组,并去掉当前的元素  

testArrA.split(separator: 4)  

testArrC.split(separator: "b")  

//条件分离  

testArrA.split { (tempInt) -> Bool in  

return tempInt <= 1  

}  



//删除索引之前的对象  

testArrC.dropFirst(0)  

testArrC.dropLast(1)  



//修改数组元素内容  

print(testArrC.map{$0.lowercased()})  



//排序  

print(testArrC.sorted(by: < ))  

print(testArrB.sorted(by: < ))  



//倒序  

print(Array(testArrA.reversed()))  



//prefix,取前几位的值  

print(testArrA.prefix(3))  



//suffix,取后几位的值  

print(testArrA.suffix(1))  



// 运算符重载  

func == (stu1: student,stu2: student) -> Bool {  

if stu1.name == stu2.name {  

return true  

    }  

return false  

}  



let isEqual = oneS1 == oneS  

let threeArr = [1] + [3] + [1,0,88]  



let befor =1  

let later = ~1  

print(later)  



//枚举  

enum WeekType {  

case One  

case Two  

}  
2017-02-06 14:17:54 Arodung 阅读数 1874

开发过程中使用数组的概率非常高,这里对部分功能做一个介绍,使用playground去显示,打印出来的内容我就不一一写上去了,真的很有用!

//: Playground - noun: a place where people can play

import UIKit


//数组问题
struct student {
    var name = "123"
    
}

var str = "Hello, playground"

//将多个数组合成一个数组
let array = [[1,2,4,],[3,5],[565,33]]
//let arrayMap = array.map{$0}
let arrayFlat = [[123,123],[444]].flatMap{ $0 }
print(arrayFlat)

//分离出条件内的数字并和成数组
let arrayFilter = [1,2,3,4,5,6,20]
let tempFilter = arrayFilter.filter{ $0 % 2 == 0 }
print(tempFilter)

//获取数组的和
let sumArray = [2,3,5,6,7]
let tempSum = sumArray.reduce(0){ $0 + $1}
print(tempSum)

//从类里面遍历出来
var oneS = student.init()
oneS.name = "1"
var oneS1 = student.init()
oneS1.name = "2"
var oneS2 = student.init()
oneS2.name = "3"
let students = [oneS,oneS1,oneS2]
let endS = students.filter { (student) -> Bool in
    return student.name == "2"
}
if let endA = endS.last {
    print(endS.last)
}

//取出空数组
let nilArray = [[],[23,322],[4,3,4],[],[666,777],[]]
let tempNilArray = nilArray.filter { (array) -> Bool in
    return array.count > 0
}
print(tempNilArray)

//forEach遍历数据
let testArrA = [1,4,5,6,1]
let testArrB = [1,2,3,4,5]
let testArrC = ["a","b","c","D"]
(2..<testArrA.count).forEach { (countT) in
    print(countT)
}

//遍历
testArrC.enumerated().forEach { (oneStr) in
    print(oneStr.element)
}

//从某一点这个点开是,分离成两个数组,并去掉当前的元素
testArrA.split(separator: 4)
testArrC.split(separator: "b")
//条件分离
testArrA.split { (tempInt) -> Bool in
    return tempInt <= 1
}

//删除索引之前的对象
testArrC.dropFirst(0)
testArrC.dropLast(1)

//修改数组元素内容
print(testArrC.map{$0.lowercased()})

//排序
print(testArrC.sorted(by: < ))
print(testArrB.sorted(by: < ))

//倒序
print(Array(testArrA.reversed()))

//prefix,取前几位的值
print(testArrA.prefix(3))

//suffix,取后几位的值
print(testArrA.suffix(1))

// 运算符重载
func == (stu1: student,stu2: student) -> Bool {
    if stu1.name == stu2.name {
        return true
    }
    return false
}

let isEqual = oneS1 == oneS
let threeArr = [1] + [3] + [1,0,88]

let befor = 1
let later = ~1
print(later)

//枚举
enum WeekType {
    case One
    case Two
}

如果转载请注明转于:AirZilong的博客

2016-03-07 21:47:35 qq_32780047 阅读数 353
// 高级用法 (面试)
// 可选类型 值绑定(可选类型结合 if-else 使用), 都要定义局部变量
var bindingOptional:Int!
// local生命周期 - if 结束
// * 局部变量后面必须是可选类型, 其实判断的是可选类型是否为空, 当为空时,直接走 else, 都有值时,走 if,顺便完成局部变量的赋值,方便我们在 if 花括号中对局部变量的使用
if var local = bindingOptional {
    print("local = \(local)")
} else {
    print("值为空")
}

// switch - case
// 1.switch 中, 功能更强大
// 2.默认没有贯穿, fallthrough关键词为贯穿下面的内容, 就是在得到要的值后面还会输出下面的内容

var switchNumber = 5
// case 一定包含所有的情况, 如果情况不能都写完, 就用 default 代替
switch switchNumber {
case 0,1,2,3,4:
    print("小于5")
    fallthrough
case 6...100:
    print("大于5小于100")
    fallthrough
case 5:
    print("5")
    fallthrough
default:
    print("others")
}

// 高级用法(面试)
// switch - case 值绑定
// 把一个作为判断条件, 一个作为局部变量接受值
// 利用系统的推断
var (x,y) = (10, 0)
switch (x,y) {
case (var xValue, 0):
    print("xValue = \(xValue)")
case (0,var yValue):
    print("yValue = \(yValue)")
default:
    print("位于坐标系内")
}

// 循环
for var i = 0; i < 10; i++ {
    print("i = \(i)")
}

// for - in循环
for i in 1...10 {
    print("i = \(i)")
}

// while 循环
var whileNumber = 0
while whileNumber < 10 {
    print("whileNumber = \(whileNumber)")
    whileNumber++
}

// repeat - while 循环
// 先执行, 后判断
repeat {
    print("我能行")
} while false

// 标签语句
// 应用场景: 循环嵌套
// 准确的取消哪一个循环, 想取消哪一个循环, 就该哪一个循环取个标签
joner: while true {
    for var i = 0; i < 50; i++ {
        print("i == \(i)")
        if i == 5 {
           break joner
        }
    }
}

// 枚举
// 还是值类型
enum Person {
    case Shaoqiong
    case Xiaoze
    case Bowen
}

print(Person.Bowen.hashValue)

// ***开发中
// 原始值
// 指定枚举值的类型 Int
enum Fruit:Int {
    case Apple
    case Banana
    case Orange
}
// 原始值, rawValue 就是原始值
print(Fruit.Orange.rawValue)

// 函数, 是一个引用类型
// 函数其实就是OC当中的方法

// 定义函数使用 func
// 1.没返回值, 没参数
// 注意:()里卖写的是参数列表, ->代表返回值
// 函数的类型包括参数类型和返回值类型
// eg.()->Void 整体是一个类型
// 书写时:->Void 可以省
func printStr()->Void {
    print("hello world")
}
// 函数调用
printStr()

// 2.没返回值, 有参数
// (String)->Void为函数类型
func printPersonName(name:String) {
    print("name = \(name)")
}
// 调用
printPersonName("gangyun")
// *常量
var jonerFunc :(String)->Void = printPersonName
// 调用 jonerFunc
jonerFunc("qiong")
// *多个参数
func printPersonInfo(name:String,age:Int) {
    print("name = \(name), age = \(age)")
}
printPersonInfo("joner", age: 23)

// 3.有返回值, 无参数

// 4.有返回值, 有参数
// 函数类型 (String)->String
func returnPersonName(name:String) ->String {
    return name
}
var returnName =  returnPersonName("joner")
print("returnName = \(returnName)")

// 多个参数多个返回值, 借助元祖
// (String,Int,Float)->(String,Int,Float)为函数类型
func returnPersonInfo(name:String,age:Int, height:Float) ->(String,Int,Float) {
    return (name,age, height)
}
// 接受:
var (name,shaoqiongAge,height) =  returnPersonInfo("shaoqiong", age: 19, height: 160.0)
print("name = \(name),shaoqiongAge = \(shaoqiongAge),height = \(height)")

// *使用函数的注意事项
// 1.参数在默认情况下是 let 类型, 是不能改变的,想改变的话,参数必须使用 var 修饰
func changeBottleHeight(var height:Float) {
    // 高度的改变
    height += 49
}
// 2.
// 封装交换两个值得函数, 想改变-用地址(加&, 关键字- inout), 因为其为值传递
//当想要函数的交换, 影响外部值的时候, 变量的关键字-形参的关键字用 inout(输入输出关键字)
func swapTwoNumber( inout a:Int, inout b:Int) {
    // let tmp:Int = a;
    var tmp:Int = 0
    tmp = a
    a = b
    b = tmp
}
var aa = 49,bb = 94
swapTwoNumber(&aa, b: &bb)
print("aa = \(aa),bb = \(bb)")
2018-01-12 19:43:00 weixin_33672109 阅读数 20

为了更好的学习alamofier,看看那些点不进去的符号方法吧(不知道,学起来真的是难受)

defer 修饰符

  1. defer : 在当前作用域执行完后再执行defer中的代码
    get方法中执行顺序为:
    1.lock.lock()
    2.return requests[task.taskIdentifier]
    3.defer { lock.unlock() }
//摘自alamofier -> sessionDelegate.swift (第170-179行)
  open subscript(task: URLSessionTask) -> Request? {
        get {
            lock.lock() ; defer { lock.unlock() }
            return requests[task.taskIdentifier]
        }
        set {
            lock.lock() ; defer { lock.unlock() }
            requests[task.taskIdentifier] = newValue
        }
    }

奇怪的函数

<-

这个方法其实就是这个,自己观察吧。。。有兴趣自己写写。(装逼)
摘自ObjectMapper ->EnumOperators.swift

/// Object of Raw Representable type
public func <- <T: RawRepresentable>(left: inout T, right: Map) {
    left <- (right, EnumTransform())
}
public func >>> <T: RawRepresentable>(left: T, right: Map) {
    left >>> (right, EnumTransform())
}


/// Optional Object of Raw Representable type
public func <- <T: RawRepresentable>(left: inout T?, right: Map) {
    left <- (right, EnumTransform())
}

public func >>> <T: RawRepresentable>(left: T?, right: Map) {
    left >>> (right, EnumTransform())
}


/// Implicitly Unwrapped Optional Object of Raw Representable type
public func <- <T: RawRepresentable>(left: inout T!, right: Map) {
    left <- (right, EnumTransform())
}

// MARK:- Arrays of Raw Representable type

/// Array of Raw Representable object
public func <- <T: RawRepresentable>(left: inout [T], right: Map) {
    left <- (right, EnumTransform())
}

public func >>> <T: RawRepresentable>(left: [T], right: Map) {
    left >>> (right, EnumTransform())
}


/// Array of Raw Representable object
public func <- <T: RawRepresentable>(left: inout [T]?, right: Map) {
    left <- (right, EnumTransform())
}

public func >>> <T: RawRepresentable>(left: [T]?, right: Map) {
    left >>> (right, EnumTransform())
}


/// Array of Raw Representable object
public func <- <T: RawRepresentable>(left: inout [T]!, right: Map) {
    left <- (right, EnumTransform())
}

// MARK:- Dictionaries of Raw Representable type

/// Dictionary of Raw Representable object
public func <- <T: RawRepresentable>(left: inout [String: T], right: Map) {
    left <- (right, EnumTransform())
}

public func >>> <T: RawRepresentable>(left: [String: T], right: Map) {
    left >>> (right, EnumTransform())
}


/// Dictionary of Raw Representable object
public func <- <T: RawRepresentable>(left: inout [String: T]?, right: Map) {
    left <- (right, EnumTransform())
}

public func >>> <T: RawRepresentable>(left: [String: T]?, right: Map) {
    left >>> (right, EnumTransform())
}


/// Dictionary of Raw Representable object
public func <- <T: RawRepresentable>(left: inout [String: T]!, right: Map) {
    left <- (right, EnumTransform())
}

[]

这个其实就是用了subscript修饰符
摘自Map.swift

/// Sets the current mapper value and key.
    /// The Key paramater can be a period separated string (ex. "distance.value") to access sub objects.
    public subscript(key: String) -> Map {
        // save key and value associated to it
        return self[key, delimiter: ".", ignoreNil: false]
    }
    
    public subscript(key: String, delimiter delimiter: String) -> Map {
        let nested = key.contains(delimiter)
        return self[key, nested: nested, delimiter: delimiter, ignoreNil: false]
    }
    
    public subscript(key: String, nested nested: Bool) -> Map {
        return self[key, nested: nested, delimiter: ".", ignoreNil: false]
    }
    
    public subscript(key: String, nested nested: Bool, delimiter delimiter: String) -> Map {
        return self[key, nested: nested, delimiter: delimiter, ignoreNil: false]
    }
    
    public subscript(key: String, ignoreNil ignoreNil: Bool) -> Map {
        return self[key, delimiter: ".", ignoreNil: ignoreNil]
    }
    
    public subscript(key: String, delimiter delimiter: String, ignoreNil ignoreNil: Bool) -> Map {
        let nested = key.contains(delimiter)
        return self[key, nested: nested, delimiter: delimiter, ignoreNil: ignoreNil]
    }
    
    public subscript(key: String, nested nested: Bool, ignoreNil ignoreNil: Bool) -> Map {
        return self[key, nested: nested, delimiter: ".", ignoreNil: ignoreNil]
    }
    
    public subscript(key: String, nested nested: Bool, delimiter delimiter: String, ignoreNil ignoreNil: Bool) -> Map {
        // save key and value associated to it
        currentKey = key
        keyIsNested = nested
        nestedKeyDelimiter = delimiter
        
        if mappingType == .fromJSON {
            // check if a value exists for the current key
            // do this pre-check for performance reasons
            if nested == false {
                let object = JSON[key]
                let isNSNull = object is NSNull
                isKeyPresent = isNSNull ? true : object != nil
                currentValue = isNSNull ? nil : object
            } else {
                // break down the components of the key that are separated by .
                (isKeyPresent, currentValue) = valueFor(ArraySlice(key.components(separatedBy: delimiter)), dictionary: JSON)
            }
            
            // update isKeyPresent if ignoreNil is true
            if ignoreNil && currentValue == nil {
                isKeyPresent = false
            }
        }
        
        return self
    }

$0

如果你在闭包表达式中使用这些简写实际参数名,那么你可以在闭包的实际参数列表中忽略对其的定义,并且简写实际参数名的数字和类型将会从期望的函数类型中推断出来。 in 关键字也能被省略,因为闭包表达式完全由它的函数体组成:

不使用01这些来代替

let numbers = [1,2,5,4,3,6,8,7]
        sortNumbers = numbers.sorted(by: { (a, b) -> Bool in
            return a < b
        })
        print("numbers -" + "\(sortNumbers)")

使用0,1

let numbers = [1,2,5,4,3,6,8,7]
 var sortNumbers = numbers.sorted(by: {$0 < $1})
 print("numbers -" + "\(sortNumbers)")

高阶函数

map

可以对数组中的每一个元素做一次处理,并返回由新元素组成的集合。

// 计算字符串的长度
let stringArray = ["Objective-C", "Swift", "HTML", "CSS", "JavaScript"]
func stringCount(string: String) -> Int {
    return string.characters.count
}
stringArray.map(stringCount)

stringArray.map({string -> Int in
    return string.characters.count
})

// $0代表数组中的每一个元素
stringArray.map{
    return $0.characters.count
}

flatMap

1. flatMap返回后的数组中不存在nil,同时它会把Optional解包

let array = ["Apple", "Orange", "Puple", ""]

let arr1 = array.map { a -> Int? in
    let length = a.characters.count
    guard length > 0 else { return nil }
    return length  
}
arr1 // [{some 5}, {some 6}, {some 5}, nil]

let arr2 = array.flatMap { a-> Int? in
    let length = a.characters.count
    guard length > 0 else { return nil}
    return length    
}    
arr2 // [5, 6, 5]

2. flatMap还能把数组中存有数组的数组(二维数组、N维数组)一同打开变成一个新的数组

let array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

let arr1 = array.map{ $0 }
arr1 // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

let arr2 = array.flatMap{ $0 }
arr2 // [1, 2, 3, 4, 5, 6, 7, 8, 9]

3. flatMap也能把两个不同的数组合并成一个数组,这个合并的数组元素个数是前面两个数组元素个数的乘积

let fruits = ["Apple", "Orange", "Puple"]
let counts = [2, 3, 5]

let array = counts.flatMap { count in
    fruits.map ({ fruit in
         return fruit + "  \(count)"            
    })   
}
array // ["Apple 2", "Orange 2", "Puple 2", "Apple 3", "Orange 3", "Puple 3", "Apple 5", "Orange 5", "Puple 5"]

filer

过滤,可以对数组中的元素按照某种规则进行一次过滤

// 筛选出字符串的长度小于10的字符串
let stringArray = ["Objective-C", "Swift", "HTML", "CSS", "JavaScript"]
func stringCountLess10(string: String) -> Bool {
    return string.characters.count < 10
}
stringArray.filter(stringCountLess10)

stringArray.filter({string -> Bool in
    return string.characters.count < 10
})

// $0表示数组中的每一个元素
stringArray.filter{
    return $0.characters.count < 10
}

reduce

计算,可以对数组的元素进行计算

// 将数组中的每个字符串用‘、’拼接
let stringArray = ["Objective-C", "Swift", "HTML", "CSS", "JavaScript"]

func appendString(string1: String, string2: String) -> String {
    return string1 == "" ? string2 : string1 + "、" + string2
}
// reduce方法中的第一个参数是初始值
stringArray.reduce("", appendString)

stringArray.reduce("", {(string1, string2) -> String in
    return string1 == "" ? string2 : string1 + "、" + string2
})

// $0表示计算后的结果, $1表示数组中的每一个元素
stringArray.reduce("", {
    return $0 == "" ? $1 : $0 + "、" + $1

参考资料

感谢 感谢!
· 紫洁swift中高阶函数map、flatMap、filter、reduce

· 逆流丶而上: Swift中0、1的实际含义

2017-08-31 16:40:00 itchosen 阅读数 12159

 

本文是一篇详细且具有实战意义的教程,涵盖几乎所有枚举(Enum)知识点,为你解答Swift中枚举的应用场合以及使用方法。

switch语句类似,Swift中的枚举乍看之下更像是C语言中枚举的进阶版本,即允许你定义一种类型,用于表示普通事情中某种用例。不过深入挖掘之后,凭借Swift背后特别的设计理念,相比较C语言枚举来说其在实际场景中的应用更为广泛。特别是作为强大的工具,Swift中的枚举能够清晰表达代码的意图。

本文中,我们将首先了解基础语法和使用枚举的可能性,接着通过实战教你如何以及何时使用枚举。最后我们还会大致了解下Swift标准库中枚举是如何被使用的。

正式开始学习之前,先给出枚举的定义。之后我们将回过头再来讨论它。

枚举声明的类型是囊括可能状态的有限集,且可以具有附加值。通过内嵌(nesting),方法(method),关联值(associated values)和模式匹配(pattern matching),枚举可以分层次地定义任何有组织的数据。

深入理解(Diving In)

简要概述如何定义和使用枚举。

定义基本的枚举类型(Defining Basic Enums)

试想我们正在开发一款游戏,玩家能够朝四个方向移动。所以喽,玩家的运动轨迹受到了限制。显然,我们能够使用枚举来表述这一情况:

enum Movement{
    case Left
    case Right
    case Top
    case Bottom
}

紧接着,你可以使用多种模式匹配结构获取到Movement的枚举值,或者按照特定情况执行操作:

let aMovement = Movement.Left

// switch 分情况处理
switch aMovement{
case .Left: print("left")
default:()
}

// 明确的case情况
if case .Left = aMovement{
    print("left")
}

if aMovement == .Left { print("left") }

案例中,我们无须明确指出enum的实际名称(即case Move.Left:print("Left"))。因为类型检查器能够自动为此进行类型推算。这对于那些UIKit以及AppKit中错综复杂的枚举是灰常有用的。

枚举值(Enum Values)

当然,你可能想要为enum中每个case分配一个值。这相当有用,比如枚举自身实际与某事或某物挂钩时,往往这些东西又需要使用不同类型来表述。在C语言中,你只能为枚举case分配整型值,而Swift则提供了更多的灵活性。

// 映射到整型
enum Movement: Int {
    case Left = 0
    case Right = 1
    case Top = 2
    case Bottom = 3
}

// 同样你可以与字符串一一对应
enum House: String {
    case Baratheon = "Ours is the Fury"
    case Greyjoy = "We Do Not Sow"
    case Martell = "Unbowed, Unbent, Unbroken"
    case Stark = "Winter is Coming"
    case Tully = "Family, Duty, Honor"
    case Tyrell = "Growing Strong"
}

// 或者float double都可以(同时注意枚举中的花式unicode)
enum Constants: Double {
    case π = 3.14159
    case e = 2.71828
    case φ = 1.61803398874
    case λ = 1.30357
}

对于StringInt类型来说,你甚至可以忽略为枚举中的case赋值,Swift编译器也能正常工作。

// Mercury = 1, Venus = 2, ... Neptune = 8
enum Planet: Int {
    case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

// North = "North", ... West = "West"
// 译者注: 这个是swift2.0新增语法
enum CompassPoint: String {
    case North, South, East, West
}

Swift枚举中支持以下四种关联值类型:

  • 整型(Integer)
  • 浮点数(Float Point)
  • 字符串(String)
  • 布尔类型(Boolean)

因此你无法1为枚举分配诸如CGPoint类型的值。

倘若你想要读取枚举的值,可以通过rawValue属性来实现:

let bestHouse = House.Stark
print(bestHouse.rawValue)
// prints "Winter is coming"

不过某种情形下,你可能想要通过一个已有的raw value来创建一个enum case。这种情况下,枚举提供了一个指定构造方法:

enum Movement: Int {
    case Left = 0
    case Right = 1
    case Top = 2
    case Bottom = 3
}
// 创建一个movement.Right 用例,其raw value值为1
let rightMovement = Movement(rawValue: 1)

倘若使用rawValue构造器,切记它是一个可失败构造器(failable initializer)。换言之,构造方法返回值为可选类型值,因为有时候传入的值可能与任意一个case都不匹配。比如Movement(rawValue:42)

如果你想要以底层 C 二进制编码形式呈现某物或某事,使得更具可读性,这是一个非常有用的功能。例如,可以看一下BSD kqeue library中的VNode Flags标志位的编码方式:

enum VNodeFlags : UInt32 {
    case Delete = 0x00000001
    case Write = 0x00000002
    case Extended = 0x00000004
    case Attrib = 0x00000008
    case Link = 0x00000010
    case Rename = 0x00000020
    case Revoke = 0x00000040
    case None = 0x00000080
}

如此便可以使你的DeleteWrite用例声明一目了然,稍后一旦需要,只需将raw value传入 C 函数中即可。

嵌套枚举(Nesting Enums)

如果你有特定子类型的需求,可以对enum进行嵌套。这样就允许你为实际的enum中包含其他明确信息的enum。以RPG游戏中的每个角色为例,每个角色能够拥有武器,因此所有角色都可以获取同一个武器集合。而游戏中的其他实例则无法获取这些武器(比如食人魔,它们仅使用棍棒)。

enum Character {
  enum Weapon {
    case Bow
    case Sword
    case Lance
    case Dagger
  }
  enum Helmet {
    case Wooden
    case Iron
    case Diamond
  }
  case Thief
  case Warrior
  case Knight
}

现在,你可以通过层级结构来描述角色允许访问的项目条。

let character = Character.Thief
let weapon = Character.Weapon.Bow
let helmet = Character.Helmet.Iron

包含枚举(Containing Enums)

同样地,你也能够在structsclasses中内嵌枚举。接着上面的例子:

struct Character {
   enum CharacterType {
    case Thief
    case Warrior
    case Knight
  }
  enum Weapon {
    case Bow
    case Sword
    case Lance
    case Dagger
  }
  let type: CharacterType
  let weapon: Weapon
}

let warrior = Character(type: .Warrior, weapon: .Sword)

同样地,这也将有助于我们将相关的信息集中在一个位置。

关联值(Associated Value)

关联值是将额外信息附加到enum case中的一种极好的方式。打个比方,你正在开发一款交易引擎,可能存在两种不同的交易类型。除此之外每手交易还要制定明确的股票名称和交易数量:

简单例程(Simple Example)

enum Trade {
    case Buy
    case Sell
}
func trade(tradeType: Trade, stock: String, amount: Int) {}

然而股票的价值和数量显然从属于交易,让他们作为独立的参数显得模棱两可。你可能已经想到要往struct中内嵌一个枚举了,不过关联值提供了一种更清爽的解决方案:

enum Trade {
    case Buy(stock: String, amount: Int)
    case Sell(stock: String, amount: Int)
}
func trade(type: Trade) {}

模式匹配(Pattern Mathching)

如果你想要访问这些值,模式匹配再次救场:

let trade = Trade.Buy(stock: "APPL", amount: 500)
if case let Trade.Buy(stock, amount) = trade {
    print("buy \(amount) of \(stock)")
}

标签(Labels)

关联值不需要附加标签的声明:

enum Trade {
   case Buy(String, Int)
   case Sell(String, Int)
}

倘若你添加了,那么,每当创建枚举用例时,你都需要将这些标签标示出来。

(元组参数)Tuple as Arguments

更重要的是,Swift内部相关信息其实是一个元组,所以你可以像下面这样做:

let tp = (stock: "TSLA", amount: 100)
let trade = Trade.Sell(tp)

if case let Trade.Sell(stock, amount) = trade {
    print("buy \(amount) of \(stock)")
}
// Prints: "buy 100 of TSLA"

语法允许您将元组当作一个简单的数据结构,稍后元组将自动转换到高级类型,就比如enum case。想象一个应用程序可以让用户来配置电脑:

typealias Config = (RAM: Int, CPU: String, GPU: String)

// Each of these takes a config and returns an updated config
func selectRAM(_ config: Config) -> Config {return (RAM: 32, CPU: config.CPU, GPU: config.GPU)}
func selectCPU(_ config: Config) -> Config {return (RAM: config.RAM, CPU: "3.2GHZ", GPU: config.GPU)}
func selectGPU(_ config: Config) -> Config {return (RAM: config.RAM, CPU: "3.2GHZ", GPU: "NVidia")}

enum Desktop {
   case Cube(Config)
   case Tower(Config)
   case Rack(Config)
}

let aTower = Desktop.Tower(selectGPU(selectCPU(selectRAM((0, "", "") as Config))))

配置的每个步骤均通过递交元组到enum中进行内容更新。倘若我们从函数式编程2中获得启发,这将变得更好。

infix operator <^> { associativity left }

func <^>(a: Config, f: (Config) -> Config) -> Config { 
    return f(a)
}

最后,我们可以将不同配置步骤串联起来。这在配置步骤繁多的情况下相当有用。

let config = (0, "", "") <^> selectRAM  <^> selectCPU <^> selectGPU
let aCube = Desktop.Cube(config)

使用案例(Use Case Example)

关联值可以以多种方式使用。常言道:一码胜千言, 下面就上几段简单的示例代码,这几段代码没有特定的顺序。

// 拥有不同值的用例
enum UserAction {
  case OpenURL(url: NSURL)
  case SwitchProcess(processId: UInt32)
  case Restart(time: NSDate?, intoCommandLine: Bool)
}

// 假设你在实现一个功能强大的编辑器,这个编辑器允许多重选择,
// 正如 Sublime Text : https://www.youtube.com/watch?v=i2SVJa2EGIw
enum Selection {
  case None
  case Single(Range<Int>)
  case Multiple([Range<Int>])
}

// 或者映射不同的标识码
enum Barcode {
    case UPCA(numberSystem: Int, manufacturer: Int, product: Int, check: Int)
    case QRCode(productCode: String)
}

// 又或者假设你在封装一个 C 语言库,正如 Kqeue BSD/Darwin 通知系统:
// https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2
enum KqueueEvent {
    case UserEvent(identifier: UInt, fflags: [UInt32], data: Int)
    case ReadFD(fd: UInt, data: Int)
    case WriteFD(fd: UInt, data: Int)
    case VnodeFD(fd: UInt, fflags: [UInt32], data: Int)
    case ErrorEvent(code: UInt, message: String)
}

// 最后, 一个 RPG 游戏中的所有可穿戴装备可以使用一个枚举来进行映射,
// 可以为一个装备增加重量和持久两个属性
// 现在可以仅用一行代码来增加一个"钻石"属性,如此一来我们便可以增加几件新的镶嵌钻石的可穿戴装备
enum Wearable {
    enum Weight: Int {
    case Light = 1
    case Mid = 4
    case Heavy = 10
    }
    enum Armor: Int {
    case Light = 2
    case Strong = 8
    case Heavy = 20
    }
    case Helmet(weight: Weight, armor: Armor)
    case Breastplate(weight: Weight, armor: Armor)
    case Shield(weight: Weight, armor: Armor)
}
let woodenHelmet = Wearable.Helmet(weight: .Light, armor: .Light)

方法和属性(Methods and properties)

你也可以在enum中像这样定义方法:

enum Wearable {
    enum Weight: Int {
        case Light = 1
    }
    enum Armor: Int {
        case Light = 2
    }
    case Helmet(weight: Weight, armor: Armor)
        func attributes() -> (weight: Int, armor: Int) {
       switch self {
             case .Helmet(let w, let a): return (weight: w.rawValue * 2, armor: w.rawValue * 4)
       }
    }
}
let woodenHelmetProps = Wearable.Helmet(weight: .Light, armor: .Light).attributes()
print (woodenHelmetProps)
// prints "(2, 4)"

枚举中的方法为每一个enum case而“生”。所以倘若想要在特定情况执行特定代码的话,你需要分支处理或采用switch语句来明确正确的代码路径。

enum Device { 
    case iPad, iPhone, AppleTV, AppleWatch 
    func introduced() -> String {
       switch self {
         case AppleTV: return "\(self) was introduced 2006"
         case iPhone: return "\(self) was introduced 2007"
         case iPad: return "\(self) was introduced 2010"
         case AppleWatch: return "\(self) was introduced 2014"
       }
    }
}
print (Device.iPhone.introduced())
// prints: "iPhone was introduced 2007"

属性(Properties)

尽管增加一个存储属性到枚举中不被允许,但你依然能够创建计算属性。当然,计算属性的内容都是建立在枚举值下或者枚举关联值得到的。

enum Device {
  case iPad, iPhone
  var year: Int {
    switch self {
        case iPhone: return 2007
        case iPad: return 2010
     }
  }
}

静态方法(Static Methods)

你也能够为枚举创建一些静态方法(static methods)。换言之通过一个非枚举类型来创建一个枚举。在这个示例中,我们需要考虑用户有时将苹果设备叫错的情况(比如AppleWatch叫成iWatch),需要返回一个合适的名称。

enum Device { 
    case AppleWatch 
    static func fromSlang(term: String) -> Device? {
      if term == "iWatch" {
      return .AppleWatch
      }
      return nil
    }
}
print (Device.fromSlang("iWatch"))

可变方法(Mutating Methods)

方法可以声明为mutating。这样就允许改变隐藏参数selfcase值了3

enum TriStateSwitch {
    case Off, Low, High
    mutating func next() {
    switch self {
    case Off:
        self = Low
    case Low:
        self = High
    case High:
        self = Off
    }
    }
}
var ovenLight = TriStateSwitch.Low
ovenLight.next()
// ovenLight 现在等于.On
ovenLight.next()
// ovenLight 现在等于.Off

小结(To Recap)

至此,我们已经大致了解了Swift中枚举语法的基本用例。在开始迈向进阶之路之前,让我们重新审视文章开篇给出的定义,看看现在是否变得更清晰了。

枚举声明的类型是囊括可能状态的有限集,且可以具有附加值。通过内嵌(nesting),方法(method),关联值(associated values)和模式匹配(pattern matching),枚举可以分层次地定义任何有组织的数据。

现在我们已经对这个定义更加清晰了。确实,如果我们添加关联值和嵌套,enum就看起来就像一个封闭的、简化的struct。相比较struct,前者优势体现在能够为分类与层次结构编码。

// Struct Example
struct Point { let x: Int, let y: Int }
struct Rect { let x: Int, let y: Int, let width: Int, let height: Int }

// Enum Example
enum GeometricEntity {
   case Point(x: Int, y: Int)
   case Rect(x: Int, y: Int, width: Int, height: Int)
}

方法和静态方法的添加允许我们为enum附加功能,这意味着无须依靠额外函数就能实现4

// C-Like example
enum Trade {
   case Buy
   case Sell
}
func order(trade: Trade)

// Swift Enum example
enum Trade {
   case Buy
   case Sell
   func order()
}

枚举进阶(Advanced Enum Usage)

协议(Protocols)

我已经提及了structsenums之间的相似性。除了附加方法的能力之外,Swift也允许你在枚举中使用协议(Protocols)协议扩展(Protocol Extension)

Swift协议定义一个接口或类型以供其他数据结构来遵循。enum当然也不例外。我们先从Swift标准库中的一个例子开始.

CustomStringConvertible是一个以打印为目的的自定义格式化输出的类型。

protocol CustomStringConvertible {
  var description: String { get }
}

该协议只有一个要求,即一个只读(getter)类型的字符串(String类型)。我们可以很容易为enum实现这个协议。

enum Trade: CustomStringConvertible {
   case Buy, Sell
   var description: String {
       switch self {
       case Buy: return "We're buying something"
       case Sell: return "We're selling something"
       }
   }
}

let action = Trade.Buy
print("this action is \(action)")
// prints: this action is We're buying something

一些协议的实现可能需要根据内部状态来相应处理要求。例如定义一个管理银行账号的协议。

protocol AccountCompatible {
  var remainingFunds: Int { get }
  mutating func addFunds(amount: Int) throws
  mutating func removeFunds(amount: Int) throws
}

你也许会简单地拿struct实现这个协议,但是考虑应用的上下文,enum是一个更明智的处理方法。不过你无法添加一个存储属性到enum中,就像var remainingFuns:Int。那么你会如何构造呢?答案灰常简单,你可以使用关联值完美解决:

enum Account {
  case Empty
  case Funds(remaining: Int)

  enum Error: ErrorType {
    case Overdraft(amount: Int)
  }

  var remainingFunds: Int {
    switch self {
    case Empty: return 0
    case Funds(let remaining): return remaining
    }
  }
}

为了保持代码清爽,我们可以在enum的协议扩展(protocl extension)中定义必须的协议函数:

extension Account: AccountCompatible {

  mutating func addFunds(amount: Int) throws {
    var newAmount = amount
    if case let .Funds(remaining) = self {
      newAmount += remaining
    }
    if newAmount < 0 {
      throw Error.Overdraft(amount: -newAmount)
    } else if newAmount == 0 {
      self = .Empty
    } else {
      self = .Funds(remaining: newAmount)
    }
  }

  mutating func removeFunds(amount: Int) throws {
    try self.addFunds(amount * -1)
  }

}
var account = Account.Funds(remaining: 20)
print("add: ", try? account.addFunds(10))
print ("remove 1: ", try? account.removeFunds(15))
print ("remove 2: ", try? account.removeFunds(55))
// prints:
// : add:  Optional(())
// : remove 1:  Optional(())
// : remove 2:  nil

正如你所看见的,我们通过将值存储到enum cases中实现了协议所有要求项。如此做法还有一个妙不可言的地方:现在整个代码基础上你只需要一个模式匹配就能测试空账号输入的情况。你不需要关心剩余资金是否等于零。

同时,我们也在账号(Accout)中内嵌了一个遵循ErrorType协议的枚举,这样我们就可以使用Swift2.0语法来进行错误处理了。这里给出更详细的使用案例教程。

扩展(Extensions)

正如刚才所见,枚举也可以进行扩展。最明显的用例就是将枚举的casemethod分离,这样阅读你的代码能够简单快速地消化掉enum内容,紧接着转移到方法定义:

enum Entities {
    case Soldier(x: Int, y: Int)
    case Tank(x: Int, y: Int)
    case Player(x: Int, y: Int)
}

现在,我们为enum扩展方法:

extension Entities {
   mutating func move(dist: CGVector) {}
   mutating func attack() {}
}

你同样可以通过写一个扩展来遵循一个特定的协议:

extension Entities: CustomStringConvertible {
  var description: String {
    switch self {
       case let .Soldier(x, y): return "\(x), \(y)"
       case let .Tank(x, y): return "\(x), \(y)"
       case let .Player(x, y): return "\(x), \(y)"
    }
  }
}

枚举泛型(Generic Enums)

枚举也支持泛型参数定义。你可以使用它们以适应枚举中的关联值。就拿直接来自Swift标准库中的简单例子来说,即Optional类型。你主要可能通过以下几种方式使用它:可选链(optional chaining(?))、if-let可选绑定、guard let、或switch,但是从语法角度来说你也可以这么使用Optional:

let aValue = Optional<Int>.Some(5)
let noValue = Optional<Int>.None
if noValue == Optional.None { print("No value") }

这是Optional最直接的用例,并未使用任何语法糖,但是不可否认Swift中语法糖的加入使得你的工作更简单。如果你观察上面的实例代码,你恐怕已经猜到Optional内部实现是这样的5:

// Simplified implementation of Swift's Optional
enum MyOptional<T> {
  case Some(T)
  case None
}

这里有啥特别呢?注意枚举的关联值采用泛型参数T作为自身类型,这样可选类型构造任何你想要的返回值。

枚举可以拥有多个泛型参数。就拿熟知的Either类为例,它并非是Swift标准库中的一部分,而是实现于众多开源库以及
其他函数式编程语言,比如HaskellF#。设计想法是这样的:相比较仅仅返回一个值或没有值(née Optional),你更期望返回一个成功值或者一些反馈信息(比如错误值)。

// The well-known either type is, of course, an enum that allows you to return either
// value one (say, a successful value) or value two (say an error) from a function
enum Either<T1, T2> {
  case Left(T1)
  case Right(T2)
}

最后,Swift中所有在classstruct中奏效的类型约束,在enum中同样适用。

// Totally nonsensical example. A bag that is either full (has an array with contents)
// or empty.
enum Bag<T: SequenceType where T.Generator.Element==Equatable> {
  case Empty
  case Full(contents: T)
}

递归 / 间接(Indirect)类型

间接类型是 Swift 2.0 新增的一个类型。 它们允许将枚举中一个 case 的关联值再次定义为枚举。举个例子,假设我们想定义一个文件系统,用来表示文件以及包含文件的目录。如果将文件目录定义为枚举的 case,则目录 case 的关联值应该再包含一个文件的数组作为它的关联值。因为这是一个递归的操作,编译器需要对此进行一个特殊的准备。Swift 文档中是这么写的:

枚举和 case 可以被标记为间接的(indrect),这意味它们的关联值是被间接保存的,这允许我们定义递归的数据结构。

所以,如果我们要定义 FileNode 的枚举,它应该会是这样的:

enum FileNode {
  case File(name: String)
  indirect case Folder(name: String, files: [FileNode])
}

此处的 indrect 关键字告诉编译器间接地处理这个枚举的 case。也可以对整个枚举类型使用这个关键字。作为例子,我们来定义一个二叉树:

indirect enum Tree<Element: Comparable> {
    case Empty
    case Node(Tree<Element>,Element,Tree<Element>)
}

这是一个很强大的特性,可以让我们用非常简洁的方式来定义一个有着复杂关联的数据结构。

使用自定义类型作为枚举的值

如果我们忽略关联值,则枚举的值就只能是整型,浮点型,字符串和布尔类型。如果想要支持别的类型,则可以通过实现 StringLiteralConvertible 协议来完成,这可以让我们通过对字符串的序列化和反序列化来使枚举支持自定义类型。

作为一个例子,假设我们要定义一个枚举来保存不同的 iOS 设备的屏幕尺寸:

enum Devices: CGSize {
   case iPhone3GS = CGSize(width: 320, height: 480)
   case iPhone5 = CGSize(width: 320, height: 568)
   case iPhone6 = CGSize(width: 375, height: 667)
   case iPhone6Plus = CGSize(width: 414, height: 736)
}

然而,这段代码不能通过编译。因为 CGPoint 并不是一个常量,不能用来定义枚举的值。我们需要为想要支持的自定义类型增加一个扩展,让其实现 StringLiteralConvertible 协议。这个协议要求我们实现三个构造方法,这三个方法都需要使用一个String类型的参数,并且我们需要将这个字符串转换成我们需要的类型(此处是CGSize)。

extension CGSize: StringLiteralConvertible {
    public init(stringLiteral value: String) {
    let size = CGSizeFromString(value)
    self.init(width: size.width, height: size.height)
    }

    public init(extendedGraphemeClusterLiteral value: String) {
    let size = CGSizeFromString(value)
    self.init(width: size.width, height: size.height)
    }

    public init(unicodeScalarLiteral value: String) {
    let size = CGSizeFromString(value)
    self.init(width: size.width, height: size.height)
    }
}

现在就可以来实现我们需要的枚举了,不过这里有一个缺点:初始化的值必须写成字符串形式,因为这就是我们定义的枚举需要接受的类型(记住,我们实现了 StringLiteralConvertible,因此String可以转化成CGSize类型)

enum Devices: CGSize {
   case iPhone3GS = "{320, 480}"
   case iPhone5 = "{320, 568}"
   case iPhone6 = "{375, 667}"
   case iPhone6Plus = "{414, 736}"
}

终于,我们可以使用 CGPoint 类型的枚举了。需要注意的是,当要获取真实的 CGPoint 的值的时候,我们需要访问枚举的是 rawValue 属性。

let a = Devices.iPhone5
let b = a.rawValue
print("the phone size string is \(a), width is \(b.width), height is \(b.height)")
// prints : the phone size string is iPhone5, width is 320.0, height is 568.0

使用字符串序列化的形式,会让使用自定义类型的枚举比较困难,然而在某些特定的情况下,这也会给我们增加不少便利(比较使用NSColor / UIColor的时候)。不仅如此,我们完全可以对自己定义的类型使用这个方法。

对枚举的关联值进行比较

在通常情况下,枚举是很容易进行相等性判断的。一个简单的 enum T { case a, b } 实现默认支持相等性判断 T.a == T.b, T.b != T.a

然而,一旦我们为枚举增加了关联值,Swift 就没有办法正确地为两个枚举进行相等性判断,需要我们自己实现 == 运行符。这并不是很困难:

enum Trade {
    case Buy(stock: String, amount: Int)
    case Sell(stock: String, amount: Int)
}
func ==(lhs: Trade, rhs: Trade) -> Bool {
   switch (lhs, rhs) {
     case let (.Buy(stock1, amount1), .Buy(stock2, amount2))
       where stock1 == stock2 && amount1 == amount2:
       return true
     case let (.Sell(stock1, amount1), .Sell(stock2, amount2))
       where stock1 == stock2 && amount1 == amount2:
       return true
     default: return false
   }
}

正如我们所见,我们通过 switch 语句对两个枚举的 case 进行判断,并且只有当它们的 case 是匹配的时候(比如 Buy 和 Buy)才对它们的真实关联值进行判断。

自定义构造方法

静态方法 一节当中我们已经提到它们可以作为从不同数据构造枚举的方便形式。在之前的例子里也展示过,对出版社经常误用的苹果设备名返回正确的名字:

enum Device { 
    case AppleWatch 
    static func fromSlang(term: String) -> Device? {
      if term == "iWatch" {
      return .AppleWatch
      }
      return nil
    }
}

我们也可以使用自定义构造方法来替换静态方法。枚举与结构体和类的构造方法最大的不同在于,枚举的构造方法需要将隐式的 self 属性设置为正确的 case。

enum Device { 
    case AppleWatch 
    init?(term: String) {
      if term == "iWatch" {
      self = .AppleWatch
      }
      return nil
    }
}

在这个例子中,我们使用了可失败(failable)的构造方法。但是,普通的构造方法也可以工作得很好:

enum NumberCategory {
   case Small
   case Medium
   case Big
   case Huge
   init(number n: Int) {
    if n < 10000 { self = .Small }
    else if n < 1000000 { self = .Medium }
    else if n < 100000000 { self = .Big }
    else { self = .Huge }
   }
}
let aNumber = NumberCategory(number: 100)
print(aNumber)
// prints: "Small"

对枚举的 case 进行迭代

一个特别经常被问到的问题就是如何对枚举中的 case 进行迭代。可惜的是,枚举并没有遵守SequenceType协议,因此没有一个官方的做法来对其进行迭代。取决于枚举的类型,对其进行迭代可能也简单,也有可能很困难。在StackOverflow上有一个很好的讨论贴。贴子里面讨论到的不同情况太多了,如果只在这里摘取一些会有片面性,而如果将全部情况都列出来,则会太多。

对 Objective-C 的支持

基于整型的枚举,如 enum Bit: Int { case Zero = 0; case One = 1 } 可以通过 @objc 标识来将其桥接到 Objective-C 当中。然而,一旦使用整型之外的类型(如 String)或者开始使用关联值,我们就无法在 Objective-C 当中使用这些枚举了。

有一个名为_ObjectiveCBridgeable的隐藏协议,可以让规范我们以定义合适的方法,如此一来,Swift 便可以正确地将枚举转成 Objective-C 类型,但我猜这个协议被隐藏起来一定是有原因的。然而,从理论上来讲,这个协议还是允许我们将枚举(包括其实枚举值)正确地桥接到 Objective-C 当中。

但是,我们并不一定非要使用上面提到的这个方法。为枚举添加两个方法,使用 @objc 定义一个替代类型,如此一来我们便可以自由地将枚举进行转换了,并且这种方式不需要遵守私有协议:

enum Trade {
    case Buy(stock: String, amount: Int)
    case Sell(stock: String, amount: Int)
}

// 这个类型也可以定义在 Objective-C 的代码中
@objc class OTrade: NSObject {
    var type: Int
    var stock: String
    var amount: Int
    init(type: Int, stock: String, amount: Int) {
    self.type = type
    self.stock = stock
    self.amount = amount
    }
}

extension Trade  {

    func toObjc() -> OTrade {
    switch self {
    case let .Buy(stock, amount):
        return OTrade(type: 0, stock: stock, amount: amount)
    case let .Sell(stock, amount):
        return OTrade(type: 1, stock: stock, amount: amount)
    }
    }

    static func fromObjc(source: OTrade) -> Trade? {
    switch (source.type) {
    case 0: return Trade.Buy(stock: source.stock, amount: source.amount)
    case 1: return Trade.Sell(stock: source.stock, amount: source.amount)
    default: return nil
    }
    }
}

这个方法有一个的缺点,我们需要将枚举映射为 Objective-C 中的 NSObject 基础类型(我们也可以直接使用 NSDictionary),但是,当我们碰到一些确实需要在 Objective-C 当中获取有关联值的枚举时,这是一个可以使用的方法。

枚举底层

Erica Sadun 写过一篇很流弊的关于枚举底层的博客,涉及到枚举底层的方方面面。在生产代码中绝不应该使用到这些东西,但是学习一下还是相当有趣的。在这里,我准备只提到那篇博客中一条,如果想了解更多,请移步到原文:

枚举通常都是一个字节长度。[...]如果你真的很傻很天真,你当然可以定义一个有成百上千个 case 的枚举,在这种情况下,取决于最少所需要的比特数,枚举可能占据两个字节或者更多。

Swift 标准库中的枚举

在我们准备继续探索枚举在项目中的不同用例之前,先看一下在 Swift 标准库当中是如何使用枚举可能会更诱人,所以现在让我们先来看看。

Bit 这个枚举有两个值,OneZero。它被作为 CollectionOfOne<T> 中的 Index 类型。

FloatingPointClassification 这个枚举定义了一系列 IEEE 754 可能的类别,比如 NegativeInfinity, PositiveZeroSignalingNaN

Mirror.AncestorRepresentation Mirror.DisplayStyle 这两个枚举被用在 Swift 反射 API 的上下文当中。

Optional 这个就不用多说了

Process 这个枚举包含了当前进程的命令行参数(Process.argc, Process.arguments)。这是一个相当有趣的枚举类型,因为在 Swift 1.0 当中,它是被作为一个结构体来实现的。

实践用例

我们已经在前面几个小节当中看过了许多有用的枚举类型。包括 OptionalEither, FileNode 还有二叉树。然而,还存在很多场合,使用枚举要胜过使用结构体和类。一般来讲,如果问题可以被分解为有限的不同类别,则使用枚举应该就是正确的选择。即使只有两种 case,这也是一个使用枚举的完美场景,正如 Optional 和 Either 类型所展示的。

以下列举了一些枚举类型在实战中的使用示例,可以用来点燃你的创造力。

错误处理

说到枚举的实践使用,当然少不了在 Swift 2.0 当中新推出的错误处理。标记为可抛出的函数可以抛出任何遵守了 ErrorType 空协议的类型。正如 Swift 官方文档中所写的:

Swift 的枚举特别适用于构建一组相关的错误状态,可以通过关联值来为其增加额外的附加信息。

作为一个示例,我们来看下流行的JSON解析框架 Argo。当 JSON 解析失败的时候,它有可能是以下两种主要原因:

  1. JSON 数据缺少某些最终模型所需要的键(比如你的模型有一个 username 的属性,但是 JSON 中缺少了)
  2. 存在类型不匹配,比如说 username 需要的是 String 类型,而 JSON 中包含的是 NSNull6

除此之外,Argo 还为不包含在上述两个类别中的错误提供了自定义错误。它们的 ErrorType 枚举是类似这样的:

enum DecodeError: ErrorType {
  case TypeMismatch(expected: String, actual: String)
  case MissingKey(String)
  case Custom(String)
}

所有的 case 都有一个关联值用来包含关于错误的附加信息。

一个更加通用的用于完整 HTTP / REST API 错误处理的ErrorType应该是类似这样的:

enum APIError : ErrorType {
    // Can't connect to the server (maybe offline?)
    case ConnectionError(error: NSError)
    // The server responded with a non 200 status code
    case ServerError(statusCode: Int, error: NSError)
    // We got no data (0 bytes) back from the server
    case NoDataError
    // The server response can't be converted from JSON to a Dictionary
    case JSONSerializationError(error: ErrorType)
    // The Argo decoding Failed
    case JSONMappingError(converstionError: DecodeError)
}

这个 ErrorType 实现了完整的 REST 程序栈解析有可能出现的错误,包含了所有在解析结构体与类时会出现的错误。

如果你看得够仔细,会发现在JSONMappingError中,我们将Argo中的DecodeError封装到了我们的APIError类型当中,因为我们会用 Argo 来作实际的 JSON 解析。

更多关于ErrorType以及此种枚举类型的示例可以参看官方文档

观察者模式

在 Swift 当中,有许多方法来构建观察模式。如果使用 @objc 兼容标记,则我们可以使用 NSNotificationCenter 或者 KVO。即使不用这个标记,didSet语法也可以很容易地实现简单的观察模式。在这里可以使用枚举,它可以使被观察者的变化更加清晰明了。设想我们要对一个集合进行观察。如果我们稍微思考一下就会发现这只有几种可能的情况:一个或多个项被插入,一个或多个项被删除,一个或多个项被更新。这听起来就是枚举可以完成的工作:

enum Change {
     case Insertion(items: [Item])
     case Deletion(items: [Item])
     case Update(items: [Item])
}

之后,观察对象就可以使用一个很简洁的方式来获取已经发生的事情的详细信息。这也可以通过为其增加 oldValue newValue 的简单方法来扩展它的功能。

状态码

如果我们正在使用一个外部系统,而这个系统使用了状态码(或者错误码)来传递错误信息,类似 HTTP 状态码,这种情况下枚举就是一种很明显并且很好的方式来对信息进行封装7

enum HttpError: String {
  case Code400 = "Bad Request"
  case Code401 = "Unauthorized"
  case Code402 = "Payment Required"
  case Code403 = "Forbidden"
  case Code404 = "Not Found"
}

结果类型映射(Map Result Types)

枚举也经常被用于将 JSON 解析后的结果映射成 Swift 的原生类型。这里有一个简短的例子:

enum JSON {
    case JSONString(Swift.String)
    case JSONNumber(Double)
    case JSONObject([String : JSONValue])
    case JSONArray([JSONValue])
    case JSONBool(Bool)
    case JSONNull
}

类似地,如果我们解析了其它的东西,也可以使用这种方式将解析结果转化我们 Swift 的类型。

UIKit 标识

枚举可以用来将字符串类型的重用标识或者 storyboard 标识映射为类型系统可以进行检查的类型。假设我们有一个拥有很多原型 Cell 的 UITableView:

enum CellType: String {
    case ButtonValueCell = "ButtonValueCell"
    case UnitEditCell = "UnitEditCell"
    case LabelCell = "LabelCell"
    case ResultLabelCell = "ResultLabelCell"
}

单位

单位以及单位转换是另一个使用枚举的绝佳场合。可以将单位及其对应的转换率映射起来,然后添加方法来对单位进行自动的转换。以下是一个相当简单的示例:

enum Liquid: Float {
  case ml = 1.0
  case l = 1000.0
  func convert(amount amount: Float, to: Liquid) -> Float {
      if self.rawValue < to.rawValue {
     return (self.rawValue / to.rawValue) * amount
      } else {
     return (self.rawValue * to.rawValue) * amount
      }
  }
}
// Convert liters to milliliters
print (Liquid.l.convert(amount: 5, to: Liquid.ml))

另一个示例是货币的转换。以及数学符号(比如角度与弧度)也可以从中受益。

游戏

游戏也是枚举中的另一个相当好的用例,屏幕上的大多数实体都属于一个特定种族的类型(敌人,障碍,纹理,...)。相对于本地的 iOS 或者 Mac 应用,游戏更像是一个白板。即开发游戏我们可以使用全新的对象以及全新的关联创造一个全新的世界,而 iOS 或者 OSX 需要使用预定义的 UIButtons,UITableViews,UITableViewCells 或者 NSStackView.

不仅如此,由于枚举可以遵守协议,我们可以利用协议扩展和基于协议的编程为不同为游戏定义的枚举增加功能。这里是一个用来展示这种层级的的简短示例:

enum FlyingBeast { case Dragon, Hippogriff, Gargoyle }
enum Horde { case Ork, Troll }
enum Player { case Mage, Warrior, Barbarian }
enum NPC { case Vendor, Blacksmith }
enum Element { case Tree, Fence, Stone }

protocol Hurtable {}
protocol Killable {}
protocol Flying {}
protocol Attacking {}
protocol Obstacle {}

extension FlyingBeast: Hurtable, Killable, Flying, Attacking {}
extension Horde: Hurtable, Killable, Attacking {}
extension Player: Hurtable, Obstacle {}
extension NPC: Hurtable {}
extension Element: Obstacle {}

字符串类型化

在一个稍微大一点的 Xcode 项目中,我们很快就会有一大堆通过字符串来访问的资源。在前面的小节中,我们已经提过重用标识和 storyboard 的标识,但是除了这两样,还存在很多资源:图像,Segues,Nibs,字体以及其它资源。通常情况下,这些资源都可以分成不同的集合。如果是这样的话,一个类型化的字符串会是一个让编译器帮我们进行类型检查的好方法。

enum DetailViewImages: String {
  case Background = "bg1.png"
  case Sidebar = "sbg.png"
  case ActionButton1 = "btn1_1.png"
  case ActionButton2 = "btn2_1.png"
}

对于 iOS 开发者,R.swift这个第三方库可以为以上提到的情况自动生成结构体。但是有些时候你可能需要有更多的控制(或者你可能是一个Mac开发者8)。

API 端点

Rest API 是枚举的绝佳用例。它们都是分组的,它们都是有限的 API 集合,并且它们也可能会有附加的查询或者命名的参数,而这可以使用关联值来实现。

这里有个 Instagram API 的简化版:

enum Instagram {
  enum Media {
    case Popular
    case Shortcode(id: String)
    case Search(lat: Float, min_timestamp: Int, lng: Float, max_timestamp: Int, distance: Int)
  }
  enum Users {
    case User(id: String)
    case Feed
    case Recent(id: String)
  }
}

Ash Furrow的Moya框架就是基本这个思想,使用枚举对 rest 端点进行映射。

链表

Airspeed Velocity有一篇极好的文章说明了如何使用枚举来实现一个链表。那篇文章中的大多数代码都超出了枚举的知识,并涉及到了大量其它有趣的主题9,但是,链表最基本的定义是类似这样的(我对其进行了一些简化):

enum List {
    case End
    indirect case Node(Int, next: List)
}

每一个节点(Node) case 都指向了下一个 case, 通过使用枚举而非其它类型,我们可以避免使用一个可选的 next 类型以用来表示链表的结束。

Airspeed Velocity 还写过一篇超赞的博客,关于如何使用 Swift 的间接枚举类型来实现红黑树,所以如果你已经阅读过关于链表的博客,你可能想继续阅读这篇关于红黑树的博客

设置字典(Setting Dictionaries)

这是 Erica Sadun 提出的非常非常机智的解决方案。简单来讲,就是任何我们需要用一个属性的字典来对一个项进行设置的时候,都应该使用一系列有关联值的枚举来替代。使用这方法,类型检查系统可以确保配置的值都是正确的类型。

关于更多的细节,以及合适的例子,可以阅读下她的文章

局限

与之前类似,我将会用一系列枚举的局限性来结束本篇文章。

提取关联值

David Owens写过一篇文章,他觉得当前的关联值提取方式是很笨重的。我墙裂推荐你去看一下他的原文,在这里我对它的要旨进行下说明:为了从一个枚举中获取关联值,我们必须使用模式匹配。然而,关联值就是关联在特定枚举 case 的高效元组。而元组是可以使用更简单的方式来获取它内部值,即 .keyword 或者 .0

// Enums
enum Ex { case Mode(ab: Int, cd: Int) }
if case Ex.Mode(let ab, let cd) = Ex.Mode(ab: 4, cd: 5) {
    print(ab)
}
// vs tuples:
let tp = (ab: 4, cd: 5)
print(tp.ab)

如果你也同样觉得我们应该使用相同的方法来对枚举进行解构(deconstruct),这里有个 rdar: rdar://22704262 (译者注:一开始我不明白 rdar 是啥意思,后来我 google 了下,如果你也有兴趣,也可以自己去搜索一下)

相等性

拥有关联值的枚举没有遵守 equatable 协议。这是一个遗憾,因为它为很多事情增加了不必要的复杂和麻烦。深层的原因可能是因为关联值的底层使用是使用了元组,而元组并没有遵守 equatable 协议。然而,对于限定的 case 子集,如果这些关联值的类型都遵守了 equatable 类型,我认为编译器应该默认为其生成 equatable 扩展。

// Int 和 String 是可判等的, 所以 Mode 应该也是可判等的
enum Ex { case Mode(ab: Int, cd: String) }

// Swift 应该能够自动生成这个函数
func == (lhs: Ex.Mode, rhs: Ex.Mode) -> Bool {
    switch (lhs, rhs) {
       case (.Mode(let a, let b), .Mode(let c, let d)):
       return a == c && b == d
       default:
       return false
    }
}

元组(Tuples)

最大的问题就是对元组的支持。我喜欢使用元组,它们可以使很多事情变得更简单,但是他们目前还处于无文档状态并且在很多场合都无法使用。在枚举当中,我们无法使用元组作为枚举的值:

enum Devices: (intro: Int, name: String) {
  case iPhone = (intro: 2007, name: "iPhone")
  case AppleTV = (intro: 2006, name: "Apple TV")
  case AppleWatch = (intro: 2014, name: "Apple Watch")
}

这似乎看起来并不是一个最好的示例,但是我们一旦开始使用枚举,就会经常陷入到需要用到类似上面这个示例的情形中。

迭代枚举的所有case

这个我们已经在前面讨论过了。目前还没有一个很好的方法来获得枚举中的所有 case 的集合以使我们可以对其进行迭代。

默认关联值

另一个会碰到的事是枚举的关联值总是类型,但是我们却无法为这些类型指定默认值。假设有这样一种情况:

enum Characters {
  case Mage(health: Int = 70, magic: Int = 100, strength: Int = 30)
  case Warrior(health: Int = 100, magic: Int = 0, strength: Int = 100)
  case Neophyte(health: Int = 50, magic: Int = 20, strength: Int = 80)
}

我们依然可以使用不同的值创建新的 case,但是角色的默认设置依然会被映射。



來源:简书

|--------------------------------------------------------------------
* 这里有精选的技术分享,也有程序猿的日常
* 技术, 面经,转型,成长,欢迎一起参与讨论
* https://blog.csdn.net/itchosen
---------------------------------------------------------------------|

如果你对老罗的话题或者IT技术感兴趣,请添加微信入讨论群:chaintips

 

 

没有更多推荐了,返回首页