簡介
特點
（1）優于OC，快速，安全
（2）取消了預編譯指令包括宏定義（OC用的太多了）
（3）取消了OC指針和不安全訪問的使用（看不到星星了）
（4）舍棄 Objective-C 早期應用 Smalltalk 的語法，全面改為點語法
（5）3.0中對Foundation框架做了很多改變，去除了NS，將絕大部分class轉換成struct結構體（為了考慮性能和安全性，絕大部分使用結構體來代替以前的類，但是在實際使用感覺不到）
（6）可以使用現有的 Cocoa 和 Cocoa Touch 框架
, 以前是OC調UIKit，現在就是Swift調UIKit，這點事沒問題的
（7）Swift因為語法的嚴謹性可以讓很多錯誤提前遇到，這樣很少出現bug讓程序停在main導致無法找到
（8）@UIApplicationMain是程序的入口
（9）只有.h沒有.m
（10）所有的代碼都包括在{}里，默認方法func都有縮進！
（11）語法的allocinit替換成（）PlayGround
（1）可以看蘋果官方自帶的tips和100個tips，都在Placground來使用基礎點
（1）不適用self. 在閉包或者編譯器提示的時候再使用
（2）分號是用來分割語句的，如果一行洗很多，就可以加分號，一般時候可以不加
（3）#function打印執行的函數
（4）添加標記用到// MARK: - 選擇，如果是接下來要做的可以用// TODO：和// FIXME：這些非常有用
一、常量和變量
定義
let 定義常量，一經賦值不允許再修改
-
var 定義變量，賦值之后仍然可以修改
常量和變量的細節- 使用 : 類型，僅僅只定義類型
- 常量有一次設置的機會
- 應該盡量先選擇常量，只有在必須修改時，才需要修改為 var
// 定義常量并且直接設置數值
let x: Int = 10
// 常量數值一經設置，不能修改，以下代碼會報錯
// x = 30
let y: Int
// 常量有一次設置的機會，以下代碼沒有問題，因為 `y` 還沒有被設置數值
y = 10
// 一旦設置之后，則不能再次修改，以下代碼會報錯，因為 `y` 已經被設置了數值
// y = 50
print(x + y)
// 變量設置數值之后，可以繼續修改數值
var z: Int
z = 100
z = 200
print(x + y + z)
自動推導
Swift 能夠根據右邊的代碼，推導出變量的準確類型
只有相同類型的值才能夠進行運算
// 整數默認的類型是 Int
let intValue = 200
// 小數的默認類型是 Double
let doubleValue = 10.5
// 如果要對不同類型的數據進行計算，必須要顯式的轉換
print(intValue + Int(doubleValue))
print(Double(intValue) + doubleValue)
注意：Swift對類型要求異常嚴格，任何不同類型的數據不能直接運算（哪怕是Int和Double），不會做一些自動的轉換來轉換成Double。Swift不存在基本數據類型，Int和Double都是結構體其實，強轉用Double(x)完成，或者在定義的時候直接指定變量的類型let x : Double = 10;（很少使用）
二、控制流
if
- Swift 中沒有 C 語言中的非零即真概念
- 在邏輯判斷時必須顯示地指明具體的判斷條件 true / false
- if 語句條件的 () 可以省略
- 但是 {} 不能省略
let num = 100
if num > 10 {
print("大 \(num)")
} else {
print("小 \(num)")
}
三目
- Swift 中的 三目 運算保持了和 OC 一致的風格
- 提示：以下代碼，可以按 cmd + shift + y，打開控制臺，查看輸出結果
num > 10 ? print("大 \(num)") : print("小 \(num)")
或者
num > 10 ? print("大 \(num)") : ()
這樣就對后面的不作處理。
() 表示空執行。
switch
- switch 不再局限于整數
- switch 可以針對任意數據類型進行判斷
- 每一個 case 后面必須有可以執行的語句
- 不再強制需要 break
- 如果沒有任何需要執行的語句，可以使用 break
要保證處理所有可能的情況，不然編譯器直接報錯，不處理的條件可以放在 default 分支中 - 每一個 case 中定義的變量僅在當前 case 中有效，而 OC 中需要使用 {}
- 多值 case 可以使用 , 分隔
let scoreString = "優"
switch scoreString {
case "優":
let name = "學生"
print(name + "80~100分")
case "良", "中": print("60~80分")
case "差": print("不及格")
default: break
}
switch 的條件判斷
- switch 中可以使用 where 子句判斷條件
- 如果只做條件判斷，case 部分可以使用 _ 省略
- 提示：Swift 中可以使用 _ 忽略任何不關心的內容
let score = 90
switch score {
case _ where score >= 80: print("優")
case _ where score >= 70: print("良")
case _ where score >= 60: print("中")
default: print("差")
}
for
- swift取消了i++和++i和傳統的for循環
for i in 0...5 {
}
for i in 0..<5 {
}
- 反序遍歷
for i in (0..<10).reversed() {
}
三、可選項（Optional）
簡要
（1）定義變量時，如果是可選的，表示可以有值，也可以是nil，用“？”
（2）強行解包 “！”，程序員來注意！，并且要少用，可能會崩
（3）最常見的錯誤：解包的時候發現nil。fatal error: unexpectedly found nil while unwrapping an Optional value
（4）let可選的話，沒有默認值，需要賦值。var可選的話，默認值為nil
（5）可選項在參與計算時候必須解包
概念
- Optional 是 Swift 的一大特色，也是 Swift 初學者最容易困惑的問題
- 定義變量時，在類型后面添加一個 ?，表示該變量是可選的
- 定義變量時，如果指定是可選的，表示該變量：
- 可以有一個指定類型的值
- 也可以是 nil
定義
- 格式1(自動推導)：var 變量名: Optional = 值
- 格式2(泛型)：var 變量名：Optional<類型> = 值
- 格式3(簡化格式)：var 變量名: 類型? = 值
// 格式1
let x: Optional = 20
// 格式2
let y: Optional<Int> = 30
// 格式3
let z: Int? = 10
print(x)
print(y)
print(z)
默認值
- 變量可選項的默認值是 nil
- 常量可選項沒有默認值，需要在定義時，或者構造函數中賦值
var x1: Int?
print(x1)
let x2: Int?
// 常量可選項沒有默認值，在賦值之前不能使用
// print(x2)
x2 = 100
print(x2)
計算和強行解包
- 可選值在參與計算前，必須解包 unwarping
- 只有解包(unwrap)后才能參與計算
- 在可選項后添加一個 !，表示強行解包
- 如果有值，會取值，然后參與后續計算
- 如果為 nil，強行解包會導致崩潰
print(x! + y! + z!)
程序員要對每一個 ! 負責
可選解包
- 如果只是調用可選項的函數，而不需要參與計算，可以使用可選解包
- 在可選項后，使用 ? 然后再調用函數
- 使用可選解包可以：
- 如果有值，會取值，然后執行后續函數
- 如果為 nil，不會執行任何函數
var optionValue: Int?
print(optionValue?.description)
// 輸出 nil
optionValue = 10
print(optionValue?.description)
// 輸出 Optional("10")
與強行解包對比，可選解包更安全，但是只能用于函數調用，而不能用于計算
可選項判斷
不強行解包的方法
由于可選項的值可能為 nil，不允許直接參與運算，因此在實際開發中，經常需要判斷可選項是否有值。
如果單純使用 if，會讓代碼嵌套層次很深，不宜閱讀和維護，為了解決這一問題，蘋果提供了以下三種方式：
- ??
- if let / var
- guard let / var
??
- ?? 運算符可以用于判斷可選項是否為 nil，如果是則使用后面的值替代
注意：?? 的優先級低，在使用時，應該注意使用 ()
let x: Int? = 10
let y: Int? = 100
print((x ?? 0) + (y ?? 0))
if let / var
- 使用 if let，一旦進入 if 分支，表示可選項一定有值
- 常量/變量的作用域僅在 {} 內部
- 使用 , 可以判斷多個可選項是否有值
- 使用同名常量/變量，避免再次起名的煩惱
- 如果要在分支邏輯中修改值，可以使用 var，通常使用 let
let name: String? = "Mike"
let age: Int? = 18
if let name = name,
let age = age {
print("\(name) 今年 \(age) 歲")
} else {
print("姓名或者年齡為 nil")
}
guard let / var
- guard 是與 if let 相反的語法，Swift 2.0 推出
- guard 同樣可以判斷可選項是否有值
- 多值判斷使用 , 分隔
- 如果發現 nil，在 else 分支返回
- 分支結束后，所有的 常量/變量 都有值
- 相比較 if let，guard 語法的分支結構能節省一層
- 如果要在后續邏輯中修改值，可以使用 var，通常使用 let
func demo(name: String?, age: Int?) {
guard let name = name,
let age = age else {
print("姓名或者年齡為 nil")
return
}
print("\(name) 今年 \(age) 歲")
}
demo(name: name, age: age)
guard let和if let可以用同名變量接收。
因為總會取名字，if let name = name這樣就可以，注意后面使用的時候用非空的那個！并且iflet和guardlet可以依次判斷，先判斷是一個字典，再拿字典的數組，在判斷數組的值，可以一條線判斷出來。
四、字符串
用String，是一個結構體，具有絕大多數NSString功能，支持直接遍歷
（1）遍歷：
func demo3() {
// 字符串遍歷（NSString不支持這么遍歷）
let str = "wowosnshi是"
for s in str.characters {
print(s)
}
}
（2）長度：
// 返回指定編碼對應的字節數，每個漢字三個字節
print(str.lengthOfBytes(using: .utf8))
// 返回真正字符串長度
print(str.characters.count)
（3）拼接：要注意可選項拼接不解決會帶上Optional，剩下的都可以拼接，再也不用看StringWithFormat了
let name = "AA"
let age = 19
let title : String? = "sss"
print("\(name)\(age)\(title ?? "")")
（4）格式化：
- 格式化成日期
let h = 8 , m = 10, s = 44
// OC中用stringWithFormat格式化日期，Swift中可以
let strDate = String(format: "%02d-%02d-%02d", h,m,s)
print(strDate)
（5）截取字符串：建議用NSStrin作中轉，因為swift取串方法一直在改變
- NSString方法
let str = "紅紅火火恍恍惚惚"
let strOC = str as NSString
strOC .substring(to: 1)
strOC.substring(with: NSMakeRange(0, 2))
五、數組
（1）就是中括號，注意數組的類型，并且基本數據類型不需要包裝，可以直接方數組里，如果類型不一樣（混合數組，但是基本不用），自動推導[NSObject]。在Swift中還有一個[AnyObject類型]，標示任意對象，因為在Swift中一個類可以沒有任何父類。
（2）遍歷：
// 遍歷1(按照下標遍歷)
for i in 0..<array.count {
}
// 遍歷2（遍歷元素）
for s in array {
}
// 遍歷3（同時遍歷下標和元素）
for e in array.enumerated() {
// let e: (offset: Int, element: String) e是一個元組
print("\(e.offset), \(e.element)")
}
// 遍歷4（同時遍歷下標和元素）
for (n,s) in array.enumerated() {
print("\(n),\(s)")
}
// 反序遍歷
for s in array.reversed() {
}
// 反序索引下標(這樣寫才對，先枚舉再反序)
for (n,s) in array.enumerated().reversed() {
}
（3）增刪改：
array.append("AA")
array[1] = "BBB"
array.remove(at: 2)
（4）合并：用“+”號。但是要合并的數組的兩個類型必須一致。
六、字典
一般是[String：NSObject]，對應鍵值對.由于3.0后大部分都是結構體了,AnyObject不好用了，Any范圍更大
（1）字典數組：
（2）增刪改：和數組都類似，就是兩個字典合并不像數組直接相加，而是需要遍歷
七、函數
（1）外部參數，當外部參數用_替代的時候，會在外部調用的時候忽略形參名
（2）函數的默認值（OC不具備），這個使Swift比OC靈活很多很多，一個方法可以做很多事，因為OC會有各種參數和組合，Swift只需寫一個最多的參數，然后不需要的設定默認值就是了
（3）無返回值 ：直接省略 （） Void都可以
（4）閉包：類似Block，比Block還廣泛。OC中Block是匿名函數，Swift中函數是特殊的閉包。閉包在整個開發中和Block的應用場景一樣。用于控制器/自定義視圖/異步執行完成的回調。這些回調的特點就是都是以參數回調處理結果，返回值為Void。
- 定義：
let biBao = { (x: Int) -> Int in
return x + 100
}
print(biBao(10))
- GCD：將任務添加到隊列，指定執行任務的函數。任務就是Block/閉包，隊列以同步/異步的方式執行。
func loadData(compeletion:@escaping ( _ result: [String])->()) -> Void {
DispatchQueue.global().async {
print("耗時操作會獲得一些結果 \(Thread.current)")
Thread.sleep(forTimeInterval: 1.0)
let json = ["天氣","不錯","刮大風"]
// 主線程回調
DispatchQueue.main.async(execute: {
print("主線程更新UI \(Thread.current)")
// 回調 -> 通過參數傳遞 執行閉包
compeletion(json)
})
}
}
調用：
// 執行的適合我就拿到了值
loadData { (result) in
print("獲取的新聞數據 \(result)")
}
尾隨閉包：如果函數的最后一個參數是閉包，那么參數就省略了，最后一個參數直接{}大括號包裝
閉包的循環引用：
（5）面向對象（各種構造函數）：（）就是allocInit，在Swift中對應init()。在swift中一個項目所有類都是共享的，可以直接訪問，每一個類都默認有一個命名空間。A.name B.name God.name Dog.name。同一個類可以從屬于不同的命名空間（假如有一個框架有Person類，做用戶，還有一個框架做后臺，也用Person。在OC中就只能靠前綴解決，HouTaiPerson，KuangJiaPerson。而Swift中的命名空間就是項目名。AAA項目有一個Person，那么AAA.Person就是AAA的Person類，此時再導入框架，那也是框架的.Person）
- 在自定義的Nsobjiect類中，has no initalizers 標示沒有初始化器，初始化器可以有多個，默認是init。當這個類有屬性的時候，屬性要分配內存空間，就是說要有初始值。那么其實就是先給自己的屬性分配，然后給父初始。其實這么一看，Swift和OC是相反的！
思路：OC是先調用爸爸。就是Person，Person會再調用NSObject，就是先跑上去什么都不管，先初始化了NSObject，然后才往下走挨個初始化。Swift是把自己完全初始化，再上去初始化爸爸，這么看比OC快了一圈，性能要好。
- 重載構造函數：（重寫是父類有這個方法，override。重載是函數名相同，參數和個數不同。init就重寫，init+參數就重載。OC是沒有重載的！都是initWithXXXXX）。重載其實是最基本的方式，OC沒有其實很low，但是Swift有。
注意：如果重載了構造函數并且沒有實現父類的init，那么系統不再提供init構造函數了（默認是有的），因為默認的構造函數不能給本類的屬性分配空間（你不自己寫name = ，系統就沒辦法分配）
-
KVC構造函數：只需記住下面4點
所以一般在模型中加個？ 然后用KVC實現（先調用init因為是運行時機制） -
模型中屬性定義：基本數據類型 = 0，對象設置？
運行時中，基本類型設置？ 屬性設置私有都會讓運行時拿不到，此時kvc就會出錯。
如果子類沒有重寫父類方法，調用的時候就會直接調用父類的方法。當繼承一個類，就繼承所有屬性和方法，包括KVC。當PERSON寫好了KVC后，
-
整體
（6）便利構造函數：關鍵字Convenience（開發用的很少，因為模型都是框架轉，UI不需要便利）
*目的：條件判斷，只有滿足條件才實例化對象，防止不必要的內存開銷，簡化對象創建。本身是不負責屬性的創建和初始化的。
（7）deinit:類似OC的Dealloc
八、分類：extension
便利構造函數 + 分類可以省略抽取很多代碼。例如給UITextField/UIButton寫分類，然后寫便利構造函數，方便。
九、Swift的類，結構體，枚舉三種都有構造函數，都可以有方法，就像OC的類
十、其它
懶加載：
在OC開發中，懶加載一般自定義控件。在Swift中，懶加載還是需要用的，可以保證控件延遲創建，還能避免處理控件解包。如果直接定義控件var label = UILabel，根據代碼從上到下，會讓控件在ViewDidLad之前就提前創建了。所以需要懶加載。OC中懶加載就是Get方法，Swift直接lazy var。當然也可以private lazy var來限定作用域。
（1）簡單的懶加載：
（2）完整的懶加載：（）就是函數執行，就是一個特殊的閉包，所以懶加載本質是一個閉包。一般不這么寫。
（3）OC和Swift區別
- OC：
- (UILabel *)label{
//如果label等于nil就會創建!
if (_label == nil) {
_label = [[UILabel alloc]init];
_label.text = @"loirou";
[_label sizeToFit];
_label.center = self.view.center;
}
return _label;
}
OC是等于nil時候就懶加載
[self.view addSubview:self.label];
//釋放label
_label = nil;
//會再次調用懶加載的代碼
NSLog(@"%@",self.label);
當label設nil的時候就在此調用。在ios6中，didReceiveMemoryWarning是不清理視圖的。
- Swift：
此時釋放的時候就會報錯。因為定義的時候沒有？，就是一定有值得。
那么如果定義時候加？ 一旦label = nil，也不會在執行懶加載了！因為懶加載根本沒寫如果是空就創建。
懶加載只會在第一次調用的時候執行閉包。Swift中一定注意不要主動清理視圖或控件，因為懶加載不會創建了（例如內存警告別干掉控件，干掉了在也用不成了，因為懶加載就一次）
計算型屬性（只讀）：
（1）getter/setter（開發不用）：
// 開發一般不用，還給搞一個_name。
// swift一般不會重寫getter和setter
private var _name: String? // 假裝的一個值
var name: String? { get{return _name} set{_name = newValue}} // get返回成員變量 set記錄成員變量
override func viewDidLoad() {
super.viewDidLoad()
demo()
}
}
（2）計算型屬性：readOnly只讀：OC中重寫get。Swift也是重寫get，不管set就可以。
// 只讀，此時set賦值時候就會報錯
var name: String? { get{return "ABC"}}
// 還有一種簡寫：
var name: String? { return "ABC"}
看這類屬性，是本身不保存內容的，都是通過計算獲得結果。就可以當我就是個沒有參數只有返回值的函數??！我每次return值給你我的任務就完成了。每次你調用我這個屬性的時候，我都會進行一次計算！都會執行我的代碼然后return給你。我自身不存儲的。
（3）懶加載和計算型屬性的區別：
（4）存儲型屬性：需要開辟空間，存儲數據。一般的屬性都是存儲型屬性（懶加載）
（5）存儲和計算都可以？或者不加?？辞闆r是不是必選
（四）Swift中設置模型數據：
Swift做好模型后。別的控件拿到模型后，由視圖自己來顯示。此時在didSet里寫。就是替代OC的Setter方法。（OC的Setter要考慮_成員變量 = 值，而且如果是copy需要.copy，而Swift不需要考慮一切）
命名空間：
- 在同一個空間（項目），全局共享。用第三方時，如果直接拖拽，那就從屬于一個空間，很有可能沖突，所以用Cocopod
-
動態獲得命名空間（從info.plist加載），命名空間和項目名稱有關系。info的Bundle name其實就是命名空間（一般寫的很奇怪 #（ProdectNmae））。
打印info
print(Bundle.main.infoDictionary)
賦值
// 獲取命名空間的值，可選 let str =
Bundle.main.infoDictionary?["CFBundleName"] as? String ?? ""
let con = NSClassFromString(str + "." + "ViewController") as? UIViewController.Type
反射機制：
對于任何類都可以知道類的所有屬性和方法，對于任何對象都可以調用任何屬性和方法，這種動態獲取的信息和動態調用對象屬性方法的功能成java的反射機制（Swift也有了）
（1）在OC中利用反射機制
- 利用NSClassFromString方法來使用字符串獲取類
- 利用isMemberOfClass判斷是否是某一個類
- 利用isKindOfClass判斷是否是某一個類的子類
- 利用conformsToProtocol判斷對象是否遵守某一個協議
- 利用respondsToSelector判斷是否實現了某一個方法
- 利用performSelector或者objc_msgSend間接調用方法
（2）在Swift中利用反射機制類似。工作中用的很多很多。
場景：AppDelegate（OC中也用過，利用NSClassFromString獲得類，然后設置根控制器。但是Swift中多了一個命名空間寫法。）
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
window = UIWindow(frame: UIScreen.main.bounds)
// 依據String名字拿到控制器(添加項目名稱，命名空間，不能有數字和特殊符號)
// 返回的是AnyClass？ 需要as？強轉
// 控制器添加Type類型
let rootControl = NSClassFromString("SwiftyDemo.ViewController") as? UIViewController.Type
let vc = rootControl?.init()
window?.rootViewController = vc
window?.makeKeyAndVisible()
return true
}
（3）第三方框架，用了很多反射機制和工廠方法，為了實現大量的解耦和封裝，很麻煩。一個方法可能跳10個方法10個控制器才寫了一個加法。但是如果涉及高級開發和封裝，必須要經過這一步。
