Swift基礎語法

簡介

• 特點
  （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）存儲和計算都可以？或者不加。看情況是不是必選

（四）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個控制器才寫了一個加法。但是如果涉及高級開發和封裝，必須要經過這一步。