swift ： 枚举

一、swift支持：关联值（传参），静态方法，协议，扩展，泛型

枚举基本使用：

enum Direction {
    case Left
    case Right
}

let dir = Direction.Right;
switch dir {
case Direction.Right:
    print("Right");
case Direction.Left:
    print("left");
}

枚举值
与OC不一样，OC只能是Int，Swift的枚举可以是：

1. 整型(Integer)
2. 浮点数(Float Point)
3. 字符串(String)
4. 布尔类型(Boolean)

1：枚举的初始化

我发现枚举中是不能实现init方法的，重新init编译器就会报错
如果枚举没有指定类型，那么只能通过let dir = Direction.Right;实例化枚举

enum Direction {
    case Left
    case Right
}
let dir = Direction.Right;

但是如果指定了类型，可以通过init来实例化

并且返回的是一个可选类型。因为可能有不存在的case，比如：

let dir = Direction.init(rawValue: 100)

这是dir就是nil，因为没有case是100，case默认是0，1

2：嵌套枚举

enum Person {
    enum Man: String {
        case Boy = "tom"
    }
    enum Woman {
        case Gril
    }
}

print(Person.Man.Boy); 			//打印：Boy
print(Person.Man.Boy.rawValue); //打印：tom

3：初始值（rawValue）

某个case的变量表示的原始值，就用rawValue访问，如下

enum OBTest:Int {
    case First
    case Second
    case Threed = 5
    case Four
}
print("first = \(OBTest.First.rawValue)"); 		//first = 0
print("Second = \(OBTest.Second.rawValue)");	//Second = 1
print("Threed = \(OBTest.Threed.rawValue)");	//Threed = 5
print("Four = \(OBTest.Four.rawValue)");		//Four = 6

如果是字符串类型，那么没有给定初始值，就是它的成员名

enum OBPerson: String {
    case 张无忌
    case zhangsanfeng
}

var s = OBPerson.zhangsanfeng.rawValue
debugPrint(s) //"zhangsanfeng"

4：关联值

其实就是枚举的case可以传值

enum Animal {
    case Cat(name:String)
    case Dog(eat:String)
}

func testAnimal(ani: Animal) {
    switch ani {
    case .Cat(let name):
        print("My name is \(name)");
    case .Dog(let eat):
        print("eat : \(eat)");
    }
}
let ani = Animal.Cat(name: "jack");
testAnimal(ani: ani);

//打印
// My name is jack

5：属性

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

enum Screen {
    case Screen_320
    case Screen_375
	//	 属性
    var iphone:String {
        switch self {
        case .Screen_320:
            return "iphone 4"
        case .Screen_375:
            return "iphone 6"
        }
    }
    
    //方法
    func ps() {
        switch self {
        case .Screen_320:
            print("iphone 4")
        case .Screen_375:
            print("iphone 6")
        }
    }
}
print(Screen.Screen_320.iphone);	//打印  iphone 4

//拓展
extension Screen {
    func printString() {
        switch self {
        case .Screen_320:
            print("iphone 4")
        case .Screen_375:
            print("iphone 6")
        }
            
    }
}

Screen.Screen_375.printString(); 	//打印  iphone 6
Screen.Screen_320.ps();  			//打印  iphone 4

6：泛型

枚举还支持泛型enum Animal<T>

enum Animal<T> {
    case Cat(name:T)
    case Dog(eat:T)
}

let cat = Animal<String>.Cat(name: "我是猫")
switch cat {
case .Cat(let name):
    print(name)
case .Dog(let eat):
    print(eat)
}
打印  我是猫

7：协议

swift厉害之处还有可以遵守协议

protocol OBProtocol {
    func obPrint()
}

enum Directions:Int,OBProtocol {
    func obPrint() {
        print(self)
    }
    case Left
    case Right
}
let dirs = Directions.init(rawValue: 1);
dirs?.obPrint(); 								//打印： Right
let dir_left = Directions.init(rawValue: 100000);
(dir_left ?? Directions.Left).obPrint();		//打印： Left

上面说到用init实例化，可能会出现没有case的情况，所以这里的值是可选类型。可以使用??解包，设置默认值，

8：extension

还有一个拓展，枚举还可以拓展

enum Directions:Int {
    case Left
    case Right
}

extension Directions {
    func obExtensionPrint() {
        print("我是extension中的类型：\(self)")
    }
}

let dirs = Directions.init(rawValue: 1);
dirs?.obExtensionPrint() 
//打印： 我是extension中的类型：Right

二、Result

Result也是一个枚举，有两个关联值success和failure，可以用来处理网络的结果

public enum Result<Success, Failure> where Failure : Error {
    case success(Success)
    case failure(Failure)
   .
   .
   .
    public func get() throws -> Success
    public init(catching body: () throws -> Success)
}

extension Result {
    public static func != (lhs: Result<Success, Failure>, rhs: Result<Success, Failure>) -> Bool
}

示例：
Error是一个协议，实现一个遵守Error协议的子类

//Error
struct OBError: Error {
    var msg:Any?;
    init(err: Any) {
        self.msg = err;
    }
}
//类似于封装的网络方法
func request(code :Int ,result : (Result<Any, Error>)->()){
    let dict = ["name":"ob","age":25] as [String : Any];
    if code == 200 {
        result(Result.success(dict));
    } else {
        let err = OBError.init(err: "error");
        result(Result.failure(err))
    }
}

调用

request(code: 500) { (result) in
    switch result {
    case .success(let data):
        print("data = \(data)");//data = ["name": "ob", "age": 25]
        
    case .failure(let err):
        print("err = \(err)");// err = OBError(msg: Optional("error"))
    }
}