swift 风格

swift 风格：

继承、遵守委托等，一个一个用 extention 写

e.g.：

extention xxx: UITableViewDelegate {

}

extention xxx: UITableViewDataSource {

}

txtention xxx: UIScrollerViewDelegate {

}

连续判断是否有值（是否不为空），不要分段写，写在一起，eg:

var subview: UIView?
var volume: Double?

// later on...
if let subview = subview, let volume = volume {
  // do something with unwrapped subview and volume
}

声明一个变量或者常量。eg：

let message = "Click the button"
let currentBounds = computeViewBounds()
var names = ["Mic", "Sam", "Christine”]
var names: [String] = []
var lookup: [String: Int] = [:]
Preferred:
    
    

     
     
let playerMark = (player == current ? "X" : "O")
    
    
 
定义变量或者常量时（数组和字典除外），如果给定初始值的话，那不需要指定类型，eg：
Preferred:
     
     

      
      
let width = 120.0                                    // Double
let widthString = (width as NSNumber).stringValue    // String
     
     
Not Preferred:
     
     

      
      
let width: NSNumber = 120.0                          // NSNumber
let widthString: NSString = width.stringValue        // NSString
      
      

      
      
定义全局变量或者常量的时候，使用枚举包含的形式来定义，这样更加方便和实例变量进行区别，eg：
      
      
Preferred:
       
       

        
        
enum Math {
  static let e = 2.718281828459045235360287
  static let root2 = 1.41421356237309504880168872
}

let hypotenuse = side * Math.root2
        
        

        
        
Not Preferred:
         
         

          
          
let e = 2.718281828459045235360287  // pollutes global namespace
let root2 = 1.41421356237309504880168872

let hypotenuse = side * root2 // what is root2?
         
         
       
       
      
      

      
      
字典或或者数组的初始化值写法，eg:
      
      
Preferred:
       
       

        
        
var names: [String] = []
var lookup: [String: Int] = [:]
        
        
var names = ["Mic", "Sam", "Christine"]
       
       
Not Preferred:
       
       

        
        
var names = [String]()
var lookup = [String: Int]()
        
        
let names = [String]()
       
       
      
      

      
      
声明字典或或者数组的时候，不加 Array 等，eg:
      
      
Preferred:
       
       

        
        
var deviceModels: [String]
var employees: [Int: String]
var faxNumber: Int?
       
       
Not Preferred:
       
       

        
        
var deviceModels: Array<String>
var employees: Dictionary<Int, String>
var faxNumber: Optional<Int>
        
        

        
        

        
        
关于弱引用self，eg：
        
        
Preferred
         
         

          
          
resource.request().onComplete { [weak self] response in
  guard let strongSelf = self else {
    return
  }
  let model = strongSelf.updateModel(response)
  strongSelf.updateUI(model)
}
         
         
Not Preferred
         
         

          
          
// might crash if self is released before response returns
resource.request().onComplete { [unowned self] response in
  let model = self.updateModel(response)
  self.updateUI(model)
}
         
         
        
        
// deallocate could happen between updating the model and updating UI
resource.request().onComplete { [weak self] response in
  let model = self?.updateModel(response)
  self?.updateUI(model)
}
关于 public 等关键字的使用， eg：
Preferred:
          
          

           
           
private let message = "Great Scott!"

class TimeMachine {  
  fileprivate dynamic lazy var fluxCapacitor = FluxCapacitor()
}
           
           

          
          
Not Preferred:
          
          

           
           
fileprivate let message = "Great Scott!"

class TimeMachine {  
  lazy dynamic fileprivate var fluxCapacitor = FluxCapacitor()
}
           
           
区别：private：同文件的其他模块可以访问.
           
           

           
           
for 循环使用，e.g.：
           
           
for var i = 0; i < 5; i++ {
           
           
}
           
           
for _ in 0..<3 {
  print("Hello three times")
}

for (index, person) in attendeeList.enumerated() {
  print("\(person) is at position #\(index)")
}

for index in stride(from: 0, to: items.count, by: 2) {
  print(index)
}

for index in (0...3).reversed() {
  print(index)
}
          
          
       
       
      
      

      
      
       
       

        
        在之前，一个函数的参数的闭包的捕捉策略默认是escaping，如果是一个非逃逸闭包需要显示的添加声明@noescape。简单的介绍就是如果这个闭包是在这个函数结束前内被调用，就是非逃逸的即noescape。如果这个闭包是在函数执行完后才被调用，调用的地方超过了这函数的范围，所以叫逃逸闭包。
       
       
e.g.:
      
      
 func api_get_shops(latitude: Double, longitude: Double, successCompleted: @escaping (_ status: String,_ msg: String,_ data: [AnyObject]) -> ()) {
……………….
    sendRequestForDataDictionary(api_name: "get_shops", parame: dic, complete: successCompleted)
}



Preferred:	尽量省略类名或者结构名
       
       

        
        
let selector = #selector(viewDidLoad)
view.backgroundColor = .red
let toView = context.view(forKey: .to)
let view = UIView(frame: .zero)
       
       
Not Preferred:
       
       

        
        
let selector = #selector(ViewController.viewDidLoad)
view.backgroundColor = UIColor.red
let toView = context.view(forKey: UITransitionContextViewKey.to)
let view = UIView(frame: CGRect.zero)
        
        

       
       
Preferred:
       
       

        
        
struct Stack<Element> { ... }
func write<Target: OutputStream>(to target: inout Target)
func swap<T>(_ a: inout T, _ b: inout T)
       
       
Not Preferred:
       
       

        
        
struct Stack<T> { ... }
func write<target: OutputStream>(to target: inout target)
func swap<Thing>(_ a: inout Thing, _ b: inout Thing)
       
       

不必要的代码可以删除：
Preferred:
       
       

        
        
override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
  return Database.contacts.count
}
       
       
Not Preferred:
       
       

        
        
override func didReceiveMemoryWarning() {
  super.didReceiveMemoryWarning()
  // Dispose of any resources that can be recreated.
}

override func numberOfSections(in tableView: UITableView) -> Int {
  // #warning Incomplete implementation, return the number of sections
  return 1
}

override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
  // #warning Incomplete implementation, return the number of rows
  return Database.contacts.count
}
       
       


只有在参数列表的结尾有一个闭包表达式参数时，才使用尾随闭包语法，如果参数列表有两个闭包表达式的参数，不使用尾随闭包。
Preferred:
       
       

        
        
UIView.animate(withDuration: 1.0) {
  self.myView.alpha = 0
}

UIView.animate(withDuration: 1.0, animations: {
  self.myView.alpha = 0
}, completion: { finished in
  self.myView.removeFromSuperview()
})
       
       
Not Preferred:
       
       

        
        
UIView.animate(withDuration: 1.0, animations: {
  self.myView.alpha = 0
})

UIView.animate(withDuration: 1.0, animations: {
  self.myView.alpha = 0
}) { f in
  self.myView.removeFromSuperview()
}