关于Swift 中扩展的思考 - 如何优雅组织扩展(extension)

注意：

文中的方案随着 swift 4的发布，不再推荐这么做。因为限定扩展 struct 在 swift 4已经不再是问题，所以不推荐这么做。另外具体实现，没有特别地方，建议参照 RxSwift 即可，毕竟这个已经做的很好了。

原文

Swift中的扩展，或许是众多 Swift 迷最爱的功能吧。毋庸置疑扩展（extension）是强大的，灵活的，给我们的代码带来了很多好处。我们在享受 extension强大的功能的同时，也必然为会为此付出一定的代价。

本文实现方式已在 Swift 3测试通过

代价：
extension的灵活性，让我们可以随意的扩展，添加喜欢的功能。正是extion的灵活性。也导致了extension的恶化

• 没有统一的访问方式。我们会经常遇到项目组内，写了大量的功能类似的扩展。项目成员通过有效的沟通才能知晓，究竟扩展了那些新的功能；但是如果是对于新加入项目组或者其他非项目组成员使用的时候，就会遇到很大的问题：不知道究竟实现了那些扩展，导致沟通，重复代码，维护的困难性

• 命名冲突。extension很多是模块内的或者直接是public对所有模块可见的。那么命令的冲突在所难免。

问题：有没有解决上述问题的办法呢？
答案：有的。本身还是通过从extension出发来解决。

关于解决办法思考？
a，统一访问和管理：把所有的extension功能放在一个 struct或 class。通过作为被扩展（extension）类/结构的一个属性，那么就可以实现统一管理和访问啦。这个是不是很简单？思路确实不错，认为就这么简单，就错了。
b，有效组织功能：在上面 a 的思路中已经解决统一访问和管理的问题。那么如何讲所有的 extension的功能有效的组织在一起呢？

• 为每一个扩展建立一个类/结构，在对这个类或者结构进行丰富。显然这个方式不是我们期望的，这样添加的类太多，也不利于本身的管理。这个方案不合理，放弃
• 泛型：swift 中的泛型无疑是强大的。之前我们提到为每一个类创建一个类是不合理，我们回过头来思考，这些所有的类基本功能其实是相似的。泛型这个类型可以满足我们的需求。
  c， 在 a 和 b 之后就可以满足我们的要求了么？ b在解决问题的同时，引入了新的问题，如何给指定类型的，添加相关功能呢？限定
  类型的扩展（constraint extension）解决。extension YourClass where T ...
  d，在 c 解决了指定类型的扩展后。对于结构（struct）会悲哀的发现，swift 语法和编译器提示这种思路行不同。怎么解决呢？ 泛型在思考，可以对于 protocol 进行扩展，那么把 c 中的类，替换成 protocol呢。这下所有问题都解决了。

思路本身没啥特别的，就是一个问题一个问题的思考和解决，方向是简单，易用。

总结：
1，可重用类：

/// 扩展的protocol：用于扩展具体的功能
protocol GeneralExt {
    associatedtype DT
    /// 访问原来的value
    var v: DT { get }
}
/// 扩展点基础实现:
public final class ExtBaseImpl: GeneralExt {
    typealias DT = T
    public let v: T
    public init(v: T) {
        self.v = v
    }
}
/// 扩展点protocol：作为扩展和访问点
protocol ExtPoint {
    associatedtype DT
    
     /// 访问 扩展功能（这个可以修改为其他的名字，所有的功能在该属性下访问 zh.*），比如修改 ch，那么就通过 ch.*
    var zh: DT { get }
}

2, 实现自己的扩展点：假定被扩展的类/结构为 TA

• 给 TA 实现 ExtPoint： 注意返回对象需要为 ExtBaseImpl

extension TA: ExtPoint {
    var zh:ExtBaseImpl {
        return ExtBaseImpl.init(v: self)
    }
}

• 给 GeneralExt 限定 类来实现需要添加的功能：

extension GeneralExt where DT == TA {
  .... 你扩展的功能
}
如果 TA 为 class，还可写成
extension GeneralExt where DT : TA {
  .... 你扩展的功能
}
//提示： == 形式的扩展可以访问 : 的属性/方法，反过来是不行的。同样方式的，访问是OK的

样例代码：测试代码

/// 扩展的protocol：用于扩展具体的功能
protocol GeneralExt {
    associatedtype DT
    
    /// 访问原来的value
    var v: DT { get }
}

/// 扩展点基础实现:
public final class ExtBaseImpl: GeneralExt {
    typealias DT = T
    public let v: T
    
    public init(v: T) {
        self.v = v
    }
}

/// 扩展点protocol：作为扩展和访问点
protocol ExtPoint {
    associatedtype DT
    
    /// 访问 扩展功能（这个可以修改为其他的名字，所有的功能在该属性下访问 zh.*），比如修改 ch，那么就通过 ch.*）
    var zh: DT { get }
}

// 给 Int 添加扩展点
extension Int: ExtPoint {
    var zh:ExtBaseImpl {
        return ExtBaseImpl.init(v: self)
    }
}

extension GeneralExt where DT == Int {
    var tripleValue:Int {
        return v * 3  // 通过 v 访问原始的value
    }
    
    var string:String {
        return "\(v)"
    }
    
    var tripleString:String {
        return "\(tripleValue)" // 这里直接使用了 扩展的 tripleValue
    }
}

// Int 我们扩展的所有功能，都可以通过 zh.* 来访问了
// 当然我们自己扩展必要的文档是要写的，这样使用和阅读就很容易了

// 给 String 添加扩展点
extension String: ExtPoint {
    var zh:ExtBaseImpl {
        return ExtBaseImpl.init(v: self)
    }
}

extension GeneralExt where DT == String {
    var doubleString:String {
        return v + v
    }
    var tripleString:String {
        return doubleString + v
    }
}

// 给 UIView 添加扩展点
extension UIView: ExtPoint {
    var zh:ExtBaseImpl {
        return ExtBaseImpl.init(v: self)
    }
}

extension GeneralExt where DT == UIView {
    var viewName:String {
        return "view name "
    }
    var viewFrame:CGRect {
        return v.frame
    }
}

extension GeneralExt where DT : UIView {
    var viewName2:String {
        // 这里无法访问 viewName
        return "view name2 "
    }
}

extension GeneralExt where DT : UIView {
    var viewName3:String {
        // 这里无法访问 viewName
        return "view name3 " + viewName2
    }
}

extension GeneralExt where DT == UIView {
    var viewName4:String {
        // 这里可以访问所有的 viewName
        return "view name4 " + viewName + viewName2 + viewName3
    }
}

1.zh.string
1.zh.tripleString
1.zh.tripleValue

"test".zh.doubleString
"test".zh.tripleString

let v = UIView()
v.zh.viewName
v.zh.viewFrame
v.zh.viewName2
v.zh.viewName3
v.zh.viewName4