Swift 合理使用结构体,枚举,extensions
枚举
Swift枚举是first-class types，它有很多Swift class具有的特性
- Associated Values 关联值
- 计算属性
- 实例方法
- 构造函数
- 遵循协议
- 支持extensions
好了，那么Swift中，这样的一个“登录结果”应该如何用枚举来表示呢？
通常，失败的时候，我们希望知道失败的原因是啥，出错的时候，我们希望知道错误的原因是啥。
利用Associated Values 关联值，来实现这一点
于是,这个枚举变成了酱紫
enum LHLoginResult {
case Success
case Failure(message:String)
case Error(error:NSError)
}
等等，现在是三种结果，要是能提供一个接口，只返回给我一个Bool，告诉我登陆成功还是失败就更好了
利用Extension和计算属性，我们添加一个方便的接口
extension LoginResult{
var isSuccess:Bool{
switch self {
case .Success:
return true
default:
return false
}
}
}
通常，App需要Log出一些信息，我们继续完善这个枚举，让它支持Log
用extension,让这个枚举遵循协议CustomStringConvertible(Swift中的一个log相关的协议)
extension LoginResult:CustomStringConvertible{
var description: String {
switch self {
case .Success:
return "Success"
case let .Failure(message):
return message
case let .Error(error):
return error.localizedDescription
}
}
}
除此之外，Swift的枚举还支持RawValues
enum ASCIIControlCharacter: Character {
case Tab = "\t"
case LineFeed = "\n"
case CarriageReturn = "\r"
}
再深入一点，我们来看看Swift中一些默认使用枚举来定义的类型
Optional
public enum Optional : _Reflectable, NilLiteralConvertible {
case None
case Some(Wrapped)
/// Construct a `nil` instance.
public init()
/// Construct a non-`nil` instance that stores `some`.
public init(_ some: Wrapped)
/// If `self == nil`, returns `nil`. Otherwise, returns `f(self!)`.
@warn_unused_result
public func map(@noescape f: (Wrapped) throws -> U) rethrows -> U?
/// Returns `nil` if `self` is `nil`, `f(self!)` otherwise.
@warn_unused_result
public func flatMap(@noescape f: (Wrapped) throws -> U?) rethrows -> U?
/// Create an instance initialized with `nil`.
public init(nilLiteral: ())
}
可见，Optional本身就是一个枚举，包含了两种可能性：None（nil），Some(Wrapped)(这里利用了Swift范型)。
结构体
除了枚举之外，结构体也是Objective C转过来的同学比较容易忽略的一个数据结构。
Swift的结构体和C的结构体有很大区别，它有很多Class相关的特性
- 定义属性来存储值
- 定义方法来提供功能
- 定义subscripts，来实现用下标访问[]
- 定义构造函数，来初始化
- 遵循某一个协议
- 支持extenstion
当然，有一些特性是它不具有的
- 继承
- 类型转换和runtime类型检查
- deinit方法，来进行销毁时候的资源释放
- 引用计数，让多个引用指向同一个实例。
比如，在OC中，你通常这样写一个Model
//.h 头文件
@interface LHPerson : NSObject<NSCopying,NSCoding>
@property (copy,nonatomic)NSString * name;
@property (assign,nonatomic)NSUInteger age;
- (instancetype)initWithName:(NSString *)name age:(NSUInteger)age;
+ (instancetype)personWithName:(NSString *)name age:(NSUInteger)age;
@end
=================================================================
//.m文件
@implementation LHPerson
- (instancetype)initWithName:(NSString *)name age:(NSUInteger)age{
if (self = [super init]) {
_name = name;
_age = age;
}
return self;
}
+ (instancetype)personWithName:(NSString *)name age:(NSUInteger)age{
return [[self alloc] initWithName:name age:age];
}
#pragma mark - NSCoding
- (instancetype)initWithCoder:(NSCoder *)aDecoder{
if (self = [super init]) {
_name = [aDecoder decodeObjectForKey:@"name"];
_age = [aDecoder decodeIntegerForKey:@"age"];
}
return self;
}
- (void)encodeWithCoder:(NSCoder *)aCoder{
if (_name != nil) [aCoder encodeObject:_name forKey:@"name"];
[aCoder encodeInteger:_age forKey:@"age"];
}
#pragma mark - NSCopying
- (instancetype)copyWithZone:(NSZone *)zone{
LHPerson * copyed = [[self.class allocWithZone:zone] init];
copyed->_age = self.age;
copyed->_name = self.name;
return copyed;
}
@end
同样的Model，在Swift应该怎么写呢？
上面的Model更适合结构体来存储
通常，你可以这么写
struct Person{
var name:String
var age:Int
init(name:String,age:Int){
self.name = name
self.age = age
}
}
为了自定义Log，我们可以让结构体实现CustomStringConvertible协议
struct Person:CustomStringConvertible{
var name:String
var age:Int
init(name:String,age:Int){
self.name = name
self.age = age
}
var description: String{
return "Name:\(name) Age:\(age)"
}
}
结构体相对于Class的优势在于
- Struct是值类型，每次传递的时候，都会进行一次拷贝，也就是说，在多线程的环境下，它是线程安全的，当你把一个Struct作为参数传递给一个Class的时候，你不需要担心这个Class会修改我原始的Struct
- Struct不需要考虑内存泄漏
通常，当以下一条或者多条满足的时候，你可以优先考虑使用结构体
- 这个数据结构主要目的是用来封装一系列相关的值的时候
- 当传递值的时候，希望传递的是拷贝的时候
- 这个数据结构本身存储的数据也是值类型，也就是说传递的时候是值传递
- 这个数据结构不需要从其他地方继承。
Extensions
Swift的Extensions可以给class,struct,enum,protocol添加功能性的方法/属性/subscripts。这和Objective C的Category很像。但是Swift Extension更加强力，并且不像Category，它不需要名字。
通过Extensions，你可以
- 增加计算属性，或者计算类型的属性
- 定义实例方法和类型方法
- 提供新的构造函数
- 定义和使用嵌套类型
- 定义subscripts
- 让一个类型遵循一个协议
红色的部分是个人觉得比较容易忽略的。
协议扩展
协议扩展是OC转过来的最容易忽略的，Swift是一个很适合《面相协议编程的语言》,很多基本的类型。比如AnyObject和Any都是协议类型（事实上，在Swift的时候，不知不觉你已经面相协议编程了）。
@objc public protocol AnyObject {
}
public typealias Any = protocol<>
其中，协议扩展最灵活的地方是，支持where语句条件扩展。
比如，这是我写Swift代码的一个自定义操作符SetUp,用协议来定义的。
public protocol SetUp {}
extension SetUp where Self: AnyObject {
//Add @noescape to make sure that closure is sync and can not be stored
public func SetUp(@noescape closure: Self -> Void) -> Self {
closure(self)
return self
}
}
extension NSObject: SetUp {}
然后，我只是希望，当AnyObject遵循这个协议的时候具有具有SetUp.接着，用第二次协议扩展，来让NSObject遵循这个协议。于是，任何NSObject的子类，你都可以这么调用
let textfield = UITextField().SetUp {
$0.frame = CGRectMake(0, 0,200, 30)
$0.textAlignment = .Center
$0.font = UIFont.systemFontOfSize(14)
$0.center = view.center
$0.placeholder = "Input some text"
$0.borderStyle = UITextBorderStyle.RoundedRect
}
extensions也可以用来设计接口
系统的SequenceType是Array遵循的协议，于是你可以这样调用
let array = [1,2,3,4,5]
let array2 = array.filter({$0 > 1}).map({$0 * 2})//4 6 8 10
其中，这个map的定义如下
public func map(@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
我们可以自定义myMap来定义个自己的映射方法。
extension SequenceType{
public func myMap(@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]{
print("Map begin")
var result = [T]()
try self.forEach { (e) in
do{
let item = try transform(e)
result.append(item)
}catch let error{
throw error
}
}
print("Map end")
return result
}
}
let arr = [1,2,3]
let mapped = arr.myMap({"\($0)"})
print(mapped)
会发现Log
Map begin Map end ["1", "2", "3"]
知名的Swift函数响应式编程开源库RxSwift，就是利用了Extensions，来让你定义自己的操作符。
extensions的常用用途
分离代码逻辑
把部分逻辑放倒extensions中，能够让代码更易于维护可扩展
class TableviewController: UITableViewController {
}
extension TableviewController{
override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
//
}
override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
}
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
}
}
再看看系统Array
public struct Array : CollectionType, MutableCollectionType, _DestructorSafeContainer {
//...
}
extension Array : ArrayLiteralConvertible {
//...
}
extension Array : _ArrayType {
//...
}
通过extension,把代码逻辑分离开.从而实现:《对扩展开放，对修改封闭》
扩展没有源代码（不易修改源代码）的类
比如，你在OC中，的工具方法，可以这么写
Tips：这里可以不写前缀lh_
extension UIScreen{
class var lh_width:CGFloat{
get{
return UIScreen.mainScreen().bounds.size.width
}
}
class var lh_height:CGFloat{
get{
return UIScreen.mainScreen().bounds.size.width
}
}
class var lh_bounds:CGRect{
get{
return UIScreen.mainScreen().bounds
}
}
}
原文：http://blog.csdn.net/hello_hwc/article/details/51870667#t1