假设现在项目中有一个已经由其他人实现的Person类：
class Person {
var name: String
var age: Int
init(name: String, age: Int) {
self.name = name
self.age = age
}
convenience init() {
self.init(name: "unknow", age: 1)
}
func say() {
print("Hi, my name is \(name)")
}
}
该类有一个已经写好的say函数：
var p = Person(name: "Jack", age: 18)
p.say() // Hi, my name is Jack
现在假如有一个需求，我们需要用到Person类的所有功能，唯一不同的就是要改变say函数的功能，需要将age也打印出来，但是又不能去修改Person类的代码。
按照常规的处理方式，这时我们可以用两种方式：第一种就是创建一个Person的子类，重写say函数。第二种就是写一个Person的扩展，这里不采用子类的方式，因为这种情况下，扩展才是优先的。
创建扩展：
extension Person {
func jkr_say() {
print("Hi, my name is \(name), my age is \(age)")
}
}
不同于Objective-C，扩展不能够重写，所以需要定义一个不同名的函数。同时，按照一般Objective-C的编码习惯，添加一个前缀。
现在就可以使用我们扩展的函数：
p.jkr_say() // Hi, my name is Jack, my age is 18
扩展
这里其实就已经完成了需求，但是还有另外一种方式，先看一下效果：
p.jkr.say() // Hi, my name is Jack, my age is 18
函数名仍然是say，但是通过p.jkr.xxx来调用，这个jkr就是我们的自定义前缀。
通过代码的语法可以判断，要实现这种调用链，jkr应该是实例p的一个实例属性。所以需要为Person添加一个实例属性，这个实例属性中有我们定义的say函数。首先我们先定义这个实例属性对于的类型，采用结构体来实现一个前缀的封装，并在内部添加一个say函数：
struct JKRPrefix {
func say() {
print("Hi my name is...")
}
}
然后为Person添加一个实例，由于不能够修改源码，所以要通过扩展，而扩展只能够扩展计算属性：
extension Person {
var jkr: JKRPrefix {
get {
JKRPrefix()
}
}
}
现在就可以实现之前的函数调用，现在还无法获取到Person实例的name和age属性，这里先只打印出了如下字符串：
p.jkr.say() // Hi my name is...
了能够通过jkr使用Person实例的属性和方法，这里明显需要将Person实例传给jkr：
struct JKRPrefix {
var proxy: Person
func say() {
print("Hi, my name is \(proxy.name), my age is \(proxy.age)")
}
}
extension Person {
var jkr: JKRPrefix {
get {
JKRPrefix(proxy: self)
}
}
}
现在就可以实现前缀的调用：
p.jkr.say() // Hi, my name is Jack, my age is 18
注：上面并没有出现循环引用，Person类的jkr属性是计算属性，并没有存储和引用关系。
范型
现在的JKRPrefix是只能支持Person类型的，因为proxy属性限定了Person类型，为了让JKRPrefix能够又扩展性，这里使用范型，swift对于范型的支持比Objective-C强大很多：
struct JKRPrefix<ProxyType> {
var proxy: ProxyType
func say() {
(proxy as? Person).map { print("Hi, my name is \($0.name), my age is \($0.age)") }
}
}
extension Person {
var jkr: JKRPrefix<Person> {
get {
JKRPrefix(proxy: self)
}
}
}
现在JKRPrefix已经可以支持所有的类型了，下面尝试为String也添加一个前缀：
extension String {
var jkr: JKRPrefix<String> {
get {
JKRPrefix(proxy: self)
}
}
}
let str = "ABC"
str.jkr.say() // 无任何打印
附加条件判断
上面可以看到，str.jkr明明是不需要say函数的，但是由于say方法是写在JKRPrefix中的，str.jkr也有了say函数，虽然可以通过proxy属性的类型判断来避免类型错误，但是这也不是一个完美的办法。
首先，swift支持扩展的附加条件判断。这里可以使用附加条件判断，对JKRPrefix的扩展的范型类型进行条件限定，首先先将say函数抽离出来写在扩展中，然后进行附加条件判断：
struct JKRPrefix<ProxyType> {
var proxy: ProxyType
// func say() {
// (proxy as? Person).map { print("Hi, my name is \($0.name), my age is \($0.age)") }
// }
}
extension JKRPrefix where ProxyType: Person {
func say() {
print("Hi, my name is \(proxy.name), my age is \(proxy.age)")
}
}
现在，只有Person实例才有say函数，String实例是没有的：
p.jkr.say() // Hi, my name is Jack, my age is 18
// str.jkr.say() // 报错，找不到
协议
上面已经实现了前缀对于不同类型的通用适配，现在的问题就是在于不太方便用，因为不同类型，都要去写对于的扩展来添加一个jkr的计算属性，这个添加jkr计算的功能又都是几乎相同的。在Objective-C中，对于所有类型都有一个相同的属性或者方法，抽取父类是第一想到的办法。而在这个需求中，这些毫不相干的类型抽取父类明显不是一个好办法。
对于这类需求，可以使用面向协议编程的思想。Swfit提供了面向协议编程的支持，相比于Objective-C的协议，Swift更加的强大。Swift可以通过对协议的扩展，支持协议的默认实现，这就可以让协议做到定义一些带有实现逻辑的计算属性或者函数，来让遵守这个协议的类都直接使用它们。同时，Swfit又支持扩展来遵守协议，实现不修改类型的源码，让其遵守协议。
下面将Person和String的jkr计算属性都抽取出到一个协议中：
protocol JKRPrefixProtocol : Any {}
extension JKRPrefixProtocol {
var jkr: JKRPrefix<Self> {
get { JKRPrefix(proxy: self) }
set {}
}
}
下面将之前删除的无用代码都去掉：
struct JKRPrefix<ProxyType> {
var proxy: ProxyType
}
protocol JKRPrefixProtocol : Any {}
extension JKRPrefixProtocol {
var jkr: JKRPrefix<Self> {
get { JKRPrefix(proxy: self) }
set {}
}
}
现在所有代码都封装好了，为一个类增加带前缀的方法需要两步:
第一步类扩展遵守协议：
extension Person: JKRPrefixProtocol {}
第二步对JKRPrefix做附近条件判断的扩展：
extension JKRPrefix where ProxyType: Person {
func say() {
print("Hi, my name is \(proxy.name), my age is \(proxy.age)")
}
}
就可以了：
var p = Person(name: "Jack", age: 18)
p.jkr.say() // Hi, my name is Jack, my age is 18
结构体的附加条件判断
下面为String添加一个方法，使其能够返回字符串中数字的个数：
extension String: JKRPrefixProtocol {}
extension JKRPrefix where ProxyType == String {
func numberCount() -> Int {
var count = 0
for c in proxy where ("0"..."9").contains(c) {
count += 1
}
return count
}
}
var str = "123abc789"
print(str.jkr.numberCount())
需要注意的就是结构体类型判断用" == "。
Self和self
上面是实例方法的添加，下面为前缀扩展添加类方法的功能，需要添加类方法。
如果前缀要实现类方法，由于实例方法是在JKRPrefix的扩展中添加中，那么也应该在JKRPrefix中的添加类方法：
extension JKRPrefix where ProxyType == String {
static func hello() {
print(ProxyType.self, "向你问好")
}
}
// 预计实现的效果
// String.jkr.hello()
能够通过 String.jkr调用出jkr，那么可以确定jkr属性一定是JKRPrefixProtocol的类属性，jkr类型还不确定，先用Int替代：
extension JKRPrefixProtocol {
static var jkr: Int {
3
}
}
能够通过String.jkr.xxx调用出 JKRPrefix的类方法，那么jkr可以确定是JKRPrefix.Type：
extension JKRPrefixProtocol {
static var jkr: JKRPrefix<Self>.Type {
get { JKRPrefix<Self>.self }
set {}
}
}
Self代表当前类型,self代表方法调用者，在实例方法中代表实例，在类方法中代码当前类型：
func test() {
print(Self.self == type(of: self)) // true
}
static func test() {
print(Self.self == self.self) // true
}
在JKRPrefixProtocol的扩展中，分别添加了连个jkr属性，一个实例属性，一个类属性，其中JKRPrefix<Self>范型中对于的Self都是代表遵守协议的当前类的类型。
计算实例属性 var jkr 中 返回的 JKRPrefix(proxy: self) 实例传入的 self 代表遵守协议的当前类型的实例本身。
计算类型属性 static var jkr 中 返回的 JKRPrefix<Self>.self，JKRPrefix.self返回的是 JKRPrefix 的类型，这样就可以调用JKRPrefix中的类方法。
完整代码：
protocol JKRPrefixProtocol : Any {}
extension JKRPrefixProtocol {
var jkr: JKRPrefix<Self> {
get { JKRPrefix(proxy: self) }
set {}
}
static var jkr: JKRPrefix<Self>.Type {
get { JKRPrefix<Self>.self }
set {}
}
}
extension String: JKRPrefixProtocol {}
extension JKRPrefix where ProxyType == String {
func numberCount() -> Int {
var count = 0
for c in proxy where ("0"..."9").contains(c) {
count += 1
}
return count
}
static func hello() {
print(ProxyType.self, "向你问好")
}
}
var str = "123abc123";
print(str.jkr.numberCount()) // 6
String.jkr.hello() // String 向你问好
关联对象
前面已经实现了为Person增加了一个带前缀的say函数。假如现在有一个需求，要为Person增加了一个业务逻辑，存储一个lines属性，当调用say的时候，判断是否有lines，有lines的时候打印lines。
Swift也支持关联对象，通过扩展为类添加一个关联对象。现在为Person扩展了一个带前缀lines属性的关联对象，和一个带前缀的自定义初始化方法：
extension Person: JKRPrefixProtocol {
// 将扩展单独存储在一个文件中，就可以实现LINES_KEY对外界的隐藏
fileprivate static var LINES_KEY: Void?
}
extension JKRPrefix where ProxyType: Person {
func say() {
// 可选值绑定
if let str = lines {
print("\(proxy.name) say: \(str)")
} else {
print("\(proxy.name) say: 大家好，我是某龙套")
}
}
// 关联对象
var lines: String? {
get {
objc_getAssociatedObject(proxy, &ProxyType.LINES_KEY) as? String
}
set {
objc_setAssociatedObject(proxy, &ProxyType.LINES_KEY, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
}
// 默认参数、可选类型参数
static func person(name: String = "某龙套", age: Int, lines: String? = nil) -> Person{
var p = Person.init(name: name, age: age)
p.jkr.lines = lines
return p
}
}
var persons = [
Person.jkr.person(name: "Jack", age: 31, lines: "我是有台词还露脸的大咖"),
Person.jkr.person(name: "Ling", age: 21, lines: "我是男七号的裸替，能露下脸很开心"),
Person.jkr.person(age: 36)
]
// 我是男七号的裸替，能露下脸很开心
print(persons[1].jkr.lines ?? "")
// 某龙套 36
print(persons[2].name, persons[2].age, persons[2].jkr.lines ?? "")
for p in persons {
// Jack say: 我是有台词还露脸的大咖
// Ling say: 我是男七号的裸替，能露下脸很开心
// 某龙套 say: 大家好，我是某龙套
p.jkr.say()
}
