在Xcode 7.2上编译Swift编译速度越来越慢，查了很多资料下面是我总结的几点原因。
下面代码均为Swift 3.0

1.lazy属性

    // 200ms+
    private lazy var label: UILabel1 = {
        let l = UILabel()
        l.font = UIFont.systemFont(ofSize: 19)
        return l
    }()
    
    private lazy var label: UILabel2 = {
        $0.font = UIFont.systemFont(ofSize: 19)
        return $0
    }(UILabel())

    private var label3: UILabel!
    
    self.label2 = UILabel()
    self.label2.font = UIFont.systemFontOfSize(19)

lazy属性一个大概200ms+，一次无所谓如果太多就会造成编译慢，多次使用请不要用lazy

2.数组操作

    //  300+ms
    func plus()  {
        let arr1 = ["1"]
        let arr2 = ["2"]
        let arr3 = ["3"]
        
        let result = arr1 + arr2 + arr3
    }

   //3ms+
    func append()  {
        let arr1 = ["1"]
        let arr2 = ["2"]
        let arr3 = ["3"]
        
        var result = arr1
        result.append(contentsOf: arr2)
        result.append(contentsOf: arr3)
    }

多个数组合并请不要用操作运算符直接操作

3.optional

// 2.6ms ?? 与其它操作符一起用 可能会很耗时 
var optionalInt: Int? = 10 let plus = (optionalInt ?? 0) + 10

// 0.5ms 使用变量将?? 的值存起来 再进行预算
var optionalInt: Int? = 10
var nonnullInt = optionalInt ?? 0
let plus = nonnullInt + 10

//10.8ms 直接将??运算的结果赋给属性 可能会很耗时
let label = UILabel()
let optionalStr : String? = nil
label.text = optionalStr ?? ""

// 0.3ms ??运算的结果用变量存起来再赋给属性
let label = UILabel()
let optionalStr : String? = nil
let displayText = optionalStr ?? ""
label.text = displayText

虽然Swift 给出了 ？？ 这个运算符相当方便，可是用的时候还是多注意点耗时问题的

4.字符串操作

    //4.9ms
    func plus_asString(){
        let string: NSString = "123"
        let result = "当前城市" + (string as String)
    }

    //0.3ms
    func plus_stringVAR(){
        let nsstring: NSString = "123"
        let string = nsstring as String
        let result = "当前城市" + string
    }

    //17.2ms
    func stringFormate(){
        let nsstring: NSString = "123"
        let string = nsstring as String
        let result = "当前城市\(string)"
    }

5.复杂一点的集合 eg:字典

    //50612.1ms
    let a = [
        "A" : [
            ["B": [1, 2, 3, 4, 5]],
            ["C": [ ]],
            ["D": [ ["A": [ 1 ]]]]
        ]
    ]

    // 8.8ms
    let b = [
        "A" : [
            ["B": [1, 2, 3, 4, 5]] as [String: [Int]],
            ["C": [ ]] as [String: [Int]],
            ["D": [ ["A": [ 1 ]] as [String: [Int]]]] as [String : [[String: [Int]]]]
        ]
    ]

复杂的字典请把类型标注上，虽然Xcode有自动推断功能，可是这个可是需要耗费大量的编译时间的

6.闭包

        let array = [1, 2, 3, 4]
        let array1 = array.map { a -> String in
            return "\(a)"
        }

        let array = [1, 2, 3, 4]
        let array1 = array.map { "\($0)" }

第二种是第一种的简写版，省略了闭包里的参数以及返回值，用$0代替第一个参数.
简易的闭包还好，若使用RxSwift进行开发，闭包比较复杂，请最好把参数不全，省略的代价就是Xcode编译很慢

其实编译慢的问题，主要还是自动推断的bug（我觉得）
若Xcode优化到了极致时，上述代码越简洁越好，
至少现在编译慢的问题可以从这方面去入手，我相信可以加快很多的编译速度