一、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的枚举可以是:
- 整型(Integer)
- 浮点数(Float Point)
- 字符串(String)
- 布尔类型(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"))
}
}