Swift 优雅的前缀

闷热的周末，午后

• 朋友的自拍.jpg

从OC转Swift不再需要添加类前缀了，如OC的PMHomeViewController转到Swift可以命名为HomeViewController。因为Swift有命名空间的概念了。不用担心与系统或者第三方命名。如果创建的类和系统的类重名，调用自己的直接调用即可，系统的类则需要加上相应的框架名字，如

import UIKit
class UIView {
    
}
class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        let v1 = UIKit.UIView()
        let v2 = Project.UIView() //项目名称或说Target为Project，通常被省略
        print("v1:\(v1)")
        print("v2:\(v2)")
    }
}
//v1:<UIView: 0x7ff24e40a830; frame = (0 0; 0 0); layer = <CALayer: 0x6000027f2a80>>
//v2:Project.UIView

此处Project就有命名空间的意思了

本文借鉴Swift编程从入门到精通-MJ大神精选课程中的一节，将加前缀的推导过程整理并加深自己的理解。看过的朋友可跳过。

假设有个字符串，需要计算包含的数字个数。通常的做法是写个方法传递该字符串，返回数字的个数，如：

//计算字符串里的数字
let str = "123test123" 

 func numberCount(_ str: String) -> Int {
    var count = 0
    for c in str {
        if ("0"..."9").contains(c) {
            count += 1
        }
    }
    return count
 }

优化成Swift 风格

 func numberCount(_ str: String) -> Int {
    var count = 0
    for c in str where ("0"..."9").contains(c) {
        count += 1
    }
    return count
 }

可以直接调用

print("数字count", numberCount(str))

一般情况，写的是字符串相关的方法，会扩充到相应类/结构体的扩展extension里

 extension String {
     //给字符串扩展功能
     func numberCount() -> Int {
         var count = 0
         for c in self where ("0"..."9").contains(c) {
             count += 1
         }
         return count
     }
 }
 print(str.numberCount()) //可以使用str直接调用改方法

调方法有小括号，可以改为计算属性，去掉小括号

 extension String {
     //改为计算属性
     var numberCount: Int {
         var count = 0
         for c in self where ("0"..."9").contains(c) {
             count += 1
         }
         return count
     }
 }
 print(str.numberCount)

计算属性可能跟系统自带的产生冲突

解决办法

1. 仿照OC写前缀

var pm_numberCount: Int {
     var count = 0
     for c in self where ("0"..."9").contains(c) {
        count += 1
     }
     return count
  }
 print(str.pm_numberCount)

2. 仿照RxSwift，给str添加前缀，实现：str.pm.numberCount类似的效果

 print(str.pm.numberCount)

扩展.pm属性，然后在PM中扩展方法

extension String {
    var pm: PM {
        //返回PM初始化话，传入当前字符串
        return PM(self)
    }
}

struct PM {
    //属性列表
    var string: String = ""
    //初始化
    init(_ string: String) {
        self.string = string
    }
    //给字符串扩充方法
    var numberCount: Int {
        var count = 0
        for c in self.string where ("0"..."9").contains(c) {
            count += 1
        }
        return count
    }
}

不够通用，给字符串扩充功能，给数组呢，都要添加属性列表、初始化一遍？考虑泛型，扩展方法列表都扩展.pm属性。

struct PM<Base> {
    //属性列表
    var base: Base
    //初始化
    init(_ base: Base) {
        self.base = base
    }
}

extension String {
    var pm: PM<String> {
        PM(self)
    }
}

然后给PM扩展方法

 //扩展 PM(self) base就是字符串，Base是泛型String类型
 extension PM where Base == String {
     var numberCount: Int {
         var count = 0
         for c in base where ("0"..."9").contains(c) {
             count += 1
         }
         return count
     }
 }

这样也可以给自定义的类扩充.pm属性

class PMPerson {}
extension PMPerson {
    var pm: PM<PMPerson> {
        //Base就是PMPerson
        PM(self)
    }
}
 extension PM where Base == PMPerson { //==只是Person类，: Person及其子类
     func test() {
         print("test--")
     }
 }

再进一步优化，不仅给成员属性增加，给类属性也增加.pm属性，实现类似String.pm.numberCount

extension String {
    var pm: PM<String> {
        PM(self)
    }
    static var pm: PM<String>.Type {
        PM<String>.self
    }
}
extension PM where Base == String {
     var numberCount: Int {
         var count = 0
         for c in base where ("0"..."9").contains(c) {
             count += 1
         }
         return count
     }
     static func Stringtest() {
         print("Stringtest")
     }
 }

这样也实现了类属性增加.pm属性，实现String.pm.Stringtest()
这样以后自定义的类都可以像上述那样，增加成员属性、类属性.pm，并扩充方法，如下Dog类

class Dog{ }
extension Dog {
    var pm: PM<Dog> {
        PM(self)
    }
    static var pm: PM<Dog>.Type {
        PM<Dog>.self
    }
}
extension PM where Base == Dog {
    func dogf1() {
        
    }
    static func dogf2() {
        
    }
}

后续有想添加.pm属性的，都可以这样扩展。但相同的部分，可用协议优化

protocol PMCompatible {}
extension PMCompatible {
    var pm: PM<Self> {
        set{} //mutating能编译过
        get{PM(self)}
    }
    static var pm: PM<Self>.Type {
        set{}
        get{PM<Self>.self}
    }
}

只要让类遵守该PMCompatible协议，就有.pm属性，继续优化

class Dog: PMCompatible { }
extension PM where Base == Dog {
    mutating func eat() {
        print("eat")
    }
}

不管字符串是String还是NSString/NSMutableString，都遵守该协议

extension String: PMCompatible {}
extension NSString: PMCompatible {}
//扩展PM遵守字面量协议
extension PM where Base: ExpressibleByStringLiteral {
   static var random10String: String {
        let letters = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
        var randomString = ""
        for _ in 0..<10 {
            let ch = letters.randomElement()
            randomString.append(ch!)
        }
        return randomString
    }
}

以上优雅的实现了
String.pm.random10String：随机产生10个字符串
str.pm.numberCount：计算字符串里数字的个数

核心代码

struct PM<Base> {
    var base: Base
    init(_ base: Base) {
        self.base = base
    }
}

protocol PMCompatible {}
extension PMCompatible {
    var pm: PM<Self> {
        set{} //mutating能编译过
        get{PM(self)}
    }
    static var pm: PM<Self>.Type {
        set{}
        get{PM<Self>.self}
    }
}

最后，要给哪个类/结构体/枚举如XXX扩展.pm属性，只需遵守PMCompatible协议并扩充extension PM where Base == XXX即可

struct XXX { }
extension XXX: PMCompatible { }
extension PM where Base == XXX {
  //扩充方法或属性
  func test1() {
  }
  static func test1 {
  }
  
}
//XXX.pm.test1()
//XXX().pm.test1()