Swifter 100 tips 读后总结

1. 将protocol的方法2为mutating,原因如下:

   1. protocol也适用于struct和enum中,如果不添加mutating,那么在struct和enum中将会提示没有实现协议方法,无法通过编译.
   2. 如果去掉protocol中的mutating字段,那么struct和中将会报错说不能改变成员变量.
   3. 在class 中实现protocol 方法的时候,不需要添加mutating字段,因为class可以随意更改自己的成员变量,所以在protocol里边用mutating修饰方法,对于class的实现是完全透明的,可以当做不存在.

2. 多元组 (Tuple)

   这是一个oc中没有使用过的结合类型,使用它可以帮助我们简化很多问题,比如:

   1. 在oc甚至java中,交换2个变量的值,我们通常会这么写:

   func swapMel<T>(a: inout T, b: inOut T) {
        let temp = a
        a = b
        b = temp
   }
   

   这样做很容易理解,但是产生了一个中间变量,这是我们不想看到的结果,所以有人会这么写:

   func swapMel<T>(a: inOut T, b: inOut T) {
        a = a ^ b
        b = b ^ a
        a = a ^ b
   }
   

   这样,我们就没有新增一个中间变量,就进行了2个变量的值的交换,但是这样做的代价就是不容易理解.当我们用swift中的Tuple来实现就简单多了,并且很容易理解:

   func swapMel<T>(a: inOut T, b: inOut T) {
        (a, b) = (b, a)
   }
   

   这样我们就完成了2个变量的交换过程,很简单.

   2. oc中的返回值只能有一个,所以在解决某些问题的时候会显得很麻烦,比如:

   CGRect有一个辅助方法CGRectDivide,它是将一个CGRect在一定位置切分成2个区域,具体使用方法如下:

   CGRect rect = CGRectMake(0, 0, 100, 100);
   CGRect small;
   CGRect large;
   CGRectDivide(rect, &small, &large, 20, CGRectMinXEdge);
   

   它将{0, 0, 100, 100}分割成了small:{0, 0, 20, 100} 和 large: {20, 0, 80, 100} 2个区域,

   下边我们可以用swift的Tuple来实现,并对比一下:

   extension CGRect {
        func divided(atDistance: CGFload, from fromEdge: CGRectEdge) -> (slice: CGRect, remainder: CGRect) {
            //...
        }
   }
   

   使用的时候,做法如下:

   let rect = CGRect(x: 0, y: 0, width: 100, height: 100)
   let (small, large) = rect.divided(atDistance: 20, from: .minXEdge)
   

   这样看起来就很简单明了

3. @autoclosure 和 ??

   1. @autoclosure做的事情就是吧一句表达式自动封装成一个闭包(closure).

   比如我们有一个方法接受一个闭包参数,当闭包执行结果为true的时候进行打印:

   func logIfTrue(_ predicate: () -> Bool) {
        if predicate() {
            print("True")
        }
   }
   

   在调用的时候,我们会这样写:

   logIfTrue({return 2 > 1})
   

   swift中对闭包的写法进行了一些简化,当只有一条return语句的时候,我们可以这样写:

   logIfTrue({2 > 1})
   

   因为这个闭包是logIfTrue函数的最后一个参数,也就是尾随闭包,所以我们还可以简写如下:

   logIfTrue{2 > 1}
   

   犹豫简写的过多,这样看起来其实已经不那么好理解了,这时候我们就可以使用@autoclosure:

   func logIfTrue(_ predicate: @autoclosure () -> Bool) {
        if predicate() {
            print("True")
        }
   }
   

   这时候我们就可以直接写:

   logIfTrue(2 > 1)
   

   他会自动把 2 > 1这个表达式转换成 () -> Bool,这样我么就得到一个写法简单,表意清除的式子.

   2. ??

   ?? 使用来快速判断nil的.语意是:如果??操作符左边的值是非nil的Optional值,就返回他的value,如果是nil,就有??操作符右边的值代替,比如:

   var level: Int?
   var startLevel = 1
   
   var currentLevel = level ?? startLevel
   

   注意:@autoclosure并不支持带有输入参数的方法,也就是形如() -> T的参数才能使用这个特性进行简化.

   // ?? 的2中形式和底层实现
   func ??<T>(optional: T?, defaultValue: @autoclosure () -> T?) -> T?
   func ??<T>(optional: T?, defaultValue: @autoclosure () -> T) -> T
   // 我们之前用到的是第二种
   func ??<T>(optional: T?, defaultValue: @autoclosure () -> T) -> T {
        switch optinal {
            case .Some(let value):
                return value
            case .None:
                return defaultValue()
        }
   }
   

   有人可以会对为什么使用@autoclosure有疑问,说不使用闭包,直接赋值不好吗? 原因是这样的,这个默认值可能是经过特别复杂的计算获得的,但是它只有在??左侧为nil的时候才用的到,当??左侧非nil的时候我们根本用不到,所以就不用计算这个默认值,我们通过这个闭包,就可以把默认值的计算推迟到optional判定为nil之后,这就是巧妙之处.

   另外,swift中的&& 和||操作符其实也用到了@autoclosure

4. Optional Chaining

   使用Optional Chaining可以让我们拜托很多不必要的判断和取值,但是使用的时候要小心,还是有坑的

   因为Optional Chaining是随时都可能提前返回nil的,所以使用Optional Chaining所得到的东西其实都是Optional的,比如下边一段代码:

   class Toy {
       let name: String
       init(name: String) {
           self.name = name
       }
   }
   
   class Pet {
       var toy: Toy?
   }
   
   class Child {
       var pet: Pet?
   }
   

   在实际使用中,当我们想要知道小明的宠物的玩具的名字的时候,可以通过Optional Chaining来拿到:

   let toyName = xiaoming.pet?.toy?.name
   

   虽然我们访问的是name,并且Toy中name被定义为一个确定的String,而不是String?, 但我们拿到的toyName其实还是String?类型.因为在Optional Chaining中随时可能会遇到nil而提前返回,这个时候我们拿到的就是nil了.

   然而,实际使用中,我们通常会通过Optional Binding(可选绑定)来取值这样的代码:

   if let toyName = xiaoming.pet?.toy?.name {
        // 这时候拿到的toyName必然不是nil
   }
   

   单独这样看还是很清楚的,如果和其他的特性结合在一起,可能就会很麻烦了:

   // 给Toy添加一个extension
   // 当 child 的pet 有toy的时候就玩,没有就不能玩
   extension Toy {
       func play() {
           // ...
       }
   }
   

   拿小明举例子, 如果小明的pet有toy的话,就玩之:

   xiaoming.pet?toy?.play()
   

   如果现在除了小明还有小李小张等,我们需要把这一串调通抽象出来,做一个闭包方便使用.传入一个child对象,于是我们就可能写成下边这个样子:

   这是错误的代码:

   let playClosure = {(child: Child) -> () in
    child.pet?.toy?play()
   }
   

   这样的代码是没有意义的!可能有人会问,问题处在那里呢?

   问题就在play()的调用上.定义的时候没有写play()的返回值,就是Void(同()是等价的),但是经过前面的Optional Chaining以后,我们拿到的是一个Optional的结果,也就是我们最后得到的应该是一个closure:

   let playClosure = {(child: Child) -> ()? in
    child.pet?.toy?play()
   }
   

   这样调用的返回将是一个()?(等同于Void?),虽然看起来很奇怪,但这是事实.使用的时候,我们通过Optional Binding来判定方法是否调用成功:

   if let result: () = playClosure(xiaoming) {
        print("happy")
   } else {
        print("no toy")
   }