Swift編程權威指南第2版 讀後收穫

　　自從參加工做一直在用OC作iOS開發。在2015年的時候蘋果剛推出swift1.0不久，當時畢竟是新推出的語言，你們也都頗有激情的學習。不過在學完後發現很難在實際項目中使用，再加上當時公司項目都是基於OC來作的開發，就把swift放一邊了。

　　後來也不斷看到網上對swift的各類評價，有好有壞，總之是一門剛推出的語言吧。語法設計，與OC無縫銜接等存在一些問題仍是能夠接受的。

　　自從2017年9月蘋果推出swift4.0後，基本大的語法變更沒有了。慢慢的有不少公司開始使用swift開發公司項目了。這也說明swift已經穩定的能夠解決實際項目問題了。

　　2018年由於工做變更，入職如今的公司。公司的項目是大部分基於swift開發，少許使用OC。這個時候我感受須要系統學習下swift了。在網上搜了搜有沒有比較好的swift書籍。看了不少評價發現《Swift編程權威指南》不管從入門難度仍是講解方式都挺適合個人。索性就選它了。我是用kindle看的。時間是在上下班的地鐵上和下班後的休息時間。先後用時一個月左右。

　　閱讀這本書對個人感覺仍是挺多的。索性把讀完的感覺寫下來。由於人的記憶力太弱了，一星期忘一半，二星期忘七成。我怕不寫下來。半年後我基本上不記得說了都是講什麼了。

　　這裏講的基本上是與OC的對比，還後後面三章的三個項目做者的開發方式對我目前開發方式的反思。

 

1、swift對比OC來講它要表達的哲學是：安全，簡潔。

這兩點在平時的編程中無處不在，舉個例子：

classDog: NSObject{
    letorigin: String= "中國"
    fileprivatevarname: String?
    privatevarage: Int?
    
    init(_name: String?, age: Int= 1) {
        self.name= name ?? "旺財"
        self.age= age
    }
}

　　定義了一個Dog類，一個常量「origin」，當一個變量被定義成let型，則只能被賦值一次。「name」和」age」是兩個可空類型的變量。重載了一個init方法，在init方法中有兩個形參。「name」爲可空類型，」age」的默認值爲一。在init方法中將這兩個變量賦值給屬性。其中判斷name有值就設置name,爲空時設置默認值「旺財」。

　　定義一個類只需這麼幾行代碼，相比OC簡潔了不少。安全上：顯示標識出哪些變量可空，哪些變量不可修改。即提升了性能，又提升了安全性。

 

2.OC中的block代碼塊被swift中的閉包替代

在swift中，函數也是一等公民，同基本類型同樣。能夠作屬性，函數參數，返回值自由使用。

其定義方式同OC區別很大，如：

swift定義與OC的定義

    let sum: ((Int,Int) -> Int) = {(a, b) in
            returna + b
     }
     let res = sum(1, 2)
     print(res)

    int(^SumBlock) (int, int) = ^(intx, inty) {
        return  x + y;
    };

 

3.字符串使用的區別

對於平時使用較多的字符串處理，變化仍是比較大的。

let str = "hello world"
var str0 = str.prefix(2)//前兩個
var str1 = str.suffix(2)//後兩個
        
let index0 = str.index(str.endIndex, offsetBy: -4)
var str2 = str[index0..<str.endIndex]//後4個
        
let index1 = str.index(str.startIndex, offsetBy: 4)
var str3 = str[str.startIndex..<index1]//前4個

與OC的對比

    NSString*str = @"hello world";
    id str0 = [str substringToIndex:2];
    id str1 = [str substringFromIndex:str.length-2];
    id str2 = [str substringWithRange:NSMakeRange(2, 3)];

 

4.在swift中，結構體的使用很是普遍，它的做用和用法與類類似，主要區別是結構體不能被繼承。因此考慮到若是類型不會被繼承生成子類，均可以使用結構體替換。此外結構體嵌套也是swift與OC相比變化較大的部分。

struct Animal {
    let region = "中國"
    var name: String?
    var color = UIColor.red
     
    init(name: String,color: UIColor) {
        self.name= name
        self.color= color
    }
    
    struct Dog {
        let legNum = 4
        func run() -> String{
            return"跑回家"
        }
    }
}

 

5.枚舉。

swift提供的枚舉比OC強大太多。枚舉中能夠繼續定義枚舉，結構體，類，方法。很是靈活。

 

enum SDCEnumType: Int{
    case circle = 20
    case check
    
    func enumTypeString(type: SDCEnumType) -> String{
        switch type {
        case .circle:
            return"circle"
        default:
            if type.rawValue== 21{
                return"check"
            } else{
                return"其餘狀況"
            }
        }
    }
    
    enum SDCEnumSubType {
        case square(SDCEnumType)
        case ellipse(SDCEnumType)
    }
}

 

6.swift提供的協議也是很是的靈活,能夠進行協議擴展，協議繼承，定於初始化方法，協議關聯等。

protocol Student {
    var name: String{getset}
    var age: Int{get}
    static func study(date:Date) -> Date
    
    init(name:String)
}
extension Student{
    var score:Float{
        return80.8
    }
    
}
protocol Childe:Student{
    
}

 

7.後面的Mac,iPhone,OC與Swift混合項目讓我對編程過程的理解：

1.平時不多關注Mac程序開發，這本書在後面的例子中寫了一個Mac應用的demo。算是對Mac應用有了必定的認識。

2.編程步驟分兩步：

一，實現功能。

二，進行設計模式調整。

這個兩個步驟在平時的編程中，我只是進行代碼實現，對於完成功能後的設計模式優化卻沒有作。想一想工做了這麼久，編程都是隻走了一半，真是汗顏。

 

8.範型的使用。

在OC中範型經常使用的場景是對集合內容的限制，而在swift中，範型已經涉及到函數。這樣瞬間使函數的戰鬥力增長了10倍。

swift是強類型語言，同一個運算符兩邊的類型必須是一致的。

func SwapTwoValues <T> (inout a: T,inout b :T){
    let  tempValue = a
    a = b
    b = tempValue
}
 
structIntStack{
    var items = [Int]()
    //壓棧
    mutating func push(item:Int){
        items.append(item)
    }
    //出棧
    mutating func pop()->Int{
        return items.removeLast()
    }
}
 
struct Stack<Ele>{
    var items = [Ele]()
    mutating func push(item:Ele){
        items.append(item)
    }
    mutating func pop()->Ele{
        return items.removeLast()
    }
}

 

9.在swift中，每一個運算符其實也是一個函數。這個與OC比起來有着概念性的差異。

 

//前置運算符，表示2的var0次方
prefix operator ^
prefix func^ ( var0: Double) -> Double{
    return pow(2, var0)
}
//後置運算符，表示var0的2次方
postfix operator ^
postfix func ^ (var0: Double) -> Double{
    return var0*var0
}