详解Swift中的七个陷阱以及避免方法

编辑：Bison

投稿： bestswifter

"Swift正在完成一个惊人的壮举，它正在改变我们在苹果设备上编程的方式，引入了很多现代范例，例如：函数式编程和相比于OC这种纯面向对象语言更丰富的类型检查。"

enum Grain  { case Wheat, Corn }  class  NewYorkPizza  { let crustGrain: Grain = .Wheat } class  ChicagoPizza  { let crustGrain: Grain = .Wheat } class CornmealPizza  { let crustGrain: Grain = .Corn  } 

NewYorkPizza().crustGrain     // returns Wheat ChicagoPizza().crustGrain     // returns Wheat CornmealPizza().crustGrain     // returns Corn 

enum Grain { case Wheat, Corn }  class Pizza {     var crustGrain: Grain { return .Wheat }     // other common pizza behavior } class NewYorkPizza: Pizza {} class ChicagoPizza: Pizza {} 

class CornmealPizza: Pizza {     override var crustGain: Grain { return .Corn } } 

class CornmealPizza: Pizza {     override var crustGrain: Grain { return .Corn } } <br> 现在它可以通过编译并成功运行：<br>  NewYorkPizza().crustGrain         // returns Wheat ChicagoPizza().crustGrain         // returns Wheat CornmealPizza().crustGrain         // returns Corn 

var pie: Pizza <br> 

pie =  NewYorkPizza();        pie.crustGrain     // returns Wheat pie =  ChicagoPizza();      pie.crustGrain     // returns Wheat pie = CornmealPizza();      pie.crustGrain     // returns Corn 

enum Grain { case Wheat, Corn }  struct  NewYorkPizza     { let crustGrain: Grain = .Wheat } struct  ChicagoPizza     { let crustGrain: Grain = .Wheat } struct CornmealPizza     { let crustGrain: Grain = .Corn  } 

NewYorkPizza()    .crustGrain     // returns Wheat ChicagoPizza()    .crustGrain     // returns Wheat CornmealPizza()    .crustGrain     // returns Corn <br> 当我们使用引用类型的时候，我们通过一个超类Pizza来达到目的。但是对于值类型将要求一个协议和一个协议扩展来合作完成。<br>  protocol Pizza {}  extension Pizza {  var crustGrain: Grain { return .Wheat }  }  struct  NewYorkPizza: Pizza { } struct  ChicagoPizza: Pizza { } struct CornmealPizza: Pizza {  let crustGain: Grain = .Corn } <br> 

NewYorkPizza().crustGrain         // returns Wheat ChicagoPizza().crustGrain         // returns Wheat CornmealPizza().crustGrain         // returns Wheat  What?! <br> 对于执行结果，我们想说cornmeal pizza并不是Wheat制作的，返回结果出现错误！哎呀！我把<br>  struct CornmealPizza: Pizza {  let crustGain: Grain = .Corn } <br> 

:warning: 在协议扩展中重写协议中的属性时要仔细核对

struct CornmealPizza: Pizza {  let crustGrain: Grain = .Corn } <br> 重新执行<br>  NewYorkPizza().crustGrain         // returns Wheat ChicagoPizza().crustGrain         // returns Wheat CornmealPizza().crustGrain     // returns Corn  Hooray! <br> 

var pie: Pizza <br> 

pie =  NewYorkPizza(); pie.crustGrain  // returns Wheat pie =  ChicagoPizza(); pie.crustGrain  // returns Wheat pie = CornmealPizza(); pie.crustGrain  // returns Wheat    Not again?! <br> 

protocol  Pizza {  var crustGrain: Grain { get }  } extension Pizza {  var crustGrain: Grain { return .Wheat }  } 

pie =  NewYorkPizza();  pie.crustGrain     // returns Wheat pie =  ChicagoPizza();  pie.crustGrain     // returns Wheat pie = CornmealPizza();  pie.crustGrain     // returns Corn    Whew! 

:warning: 在协议扩展中定义的每一个属性，需要在协议中进行声明

// PizzaFramework:  public protocol Pizza { }  public struct  NewYorkPizza: Pizza  { public init() {} } public struct  ChicagoPizza: Pizza  { public init() {} } public struct CornmealPizza: Pizza  { public init() {} } 

import PizzaFramework  public enum Grain { case Wheat, Corn }  extension Pizza         { var crustGrain: Grain { return .Wheat    } } extension CornmealPizza { var crustGrain: Grain { return .Corn    } } <br> 

var pie: Pizza = CornmealPizza() pie.crustGrain                            // returns Wheat   Wrong! <br> 

:warning: 不要对导入的协议进行扩展，新增可能需要动态调度的属性

enum Grain { case Wheat, Corn }  protocol  Pizza { var crustGrain: Grain { get }  } extension Pizza { var crustGrain: Grain { return .Wheat }  }  struct  NewYorkPizza: Pizza  { } struct  ChicagoPizza: Pizza  { } struct CornmealPizza: Pizza  { let crustGrain: Grain = .Corn } <br> 让我们用Pizza做一顿饭。不幸的是，并不是每顿饭都会吃pizza，所以我们使用一个通用的Meal结构体来适应各种情况。我们只需要传入一个参数就可以确定进餐的具体类型。<br>  struct Meal: MealProtocol {     let mainDish: MainDishOfMeal } <br> 

protocol MealProtocol {     typealias MainDish_OfMealProtocol     var mainDish: MainDish_OfMealProtocol {get}     var isGlutenFree: Bool {get} } 

extension MealProtocol {     var isGlutenFree: Bool  { return false } } <br> Swift中的 Where提供了一种方式去表达约束性协议扩展。当主菜是pizza的时候，我们知道pizza有scrustGrain属性，我们就可以访问这个属性。如果没where这里的限制，我们在不是Pizza的情况下访问scrustGrain是不安全的。<br>  extension MealProtocol  where  MainDish_OfMealProtocol: Pizza {     var isGlutenFree: Bool  { return mainDish.crustGrain == .Corn } } <br> 一个带有Where的扩展叫做约束性扩展。<br> 

let meal: Meal = Meal(mainDish: CornmealPizza()) 

meal.isGlutenFree    // returns false // 根据协议拓展，理论上应该返回true <br> 

:warning: 如果一个新的属性需要动态调度，避免使用约束性协议扩展

class Holder  {     var x = 0 }  var n = 1 var h: Holder? = nil h?.x = n++ <br> 

:warning: 避免把一个有副作用的表达式的结果通过可选链赋值给等号左边的变量

enum Grain {     case Wheat, Corn }  struct CornmealPizza {     func setCrustGrain(inout grain: Grain)  {         grain = .Corn     } } <br> 

let pizza = CornmealPizza() var grain: Grain = .Wheat pizza.setCrustGrain(&grain) grain        // returns Corn <br> 现在我们尝试在函数中返回闭包，然后在闭包中设置参数的值：<br>  struct CornmealPizza {     func getCrustGrainSetter() -> (inout grain: Grain) -> Void {         return { (inout grain: Grain) in             grain = .Corn         }     } } <br> 使用这个闭包只需要多一次调用：<br>  var grain: Grain = .Wheat let pizza = CornmealPizza() let aClosure = pizza.getCrustGrainSetter() grain            // returns Wheat (We have not run the closure yet) aClosure(grain: &grain) grain            // returns Corn <br> 到目前为止一切正常，但如果我们直接把参数传进getCrustGrainSetter函数而不是闭包呢？<br>  struct CornmealPizza {     func getCrustGrainSetter(inout grain: Grain)  ->  () -> Void {         return { grain = .Corn }     } } 然后再试一次：<br>  var grain: Grain = .Wheat let pizza = CornmealPizza() let aClosure = pizza.getCrustGrainSetter(&grain) print(grain)                // returns Wheat (We have not run the closure yet) aClosure() print(grain)                // returns Wheat  What?!? <br> 

:warning: 避免在闭包中使用inout参数

struct CornmealPizza {     func getCrustGrainSetterWithCurry(inout grain: Grain)() -> Void {         grain = .Corn     } } 和显式创建闭包时一样，我们调用这个函数然后返回一个闭包：<br>  var grain: Grain = .Wheat let pizza = CornmealPizza() let aClosure = pizza.getCrustGrainSetterWithCurry(&grain) <br> 

aClosure() grain                // returns Corn <br> 

:warning: 避免在柯里化函数中使用inout参数，因为如果你后来将柯里化改为显式的创建闭包，这段代码就会产生错误

博主app上线啦，快点此来围观吧

更多经验请点击