簡單介紹一下Swift

Swift 語言由蘋果公司在 2014 年推出，用來撰寫 OS X 和 iOS 應用程序，Swift語言讓應用開發更簡單、更快、更穩定，確保最終應用有著更好的質量更多了解Swift可以去 《The Swift Programming Language》中文版，這次分享給大家是Swift基礎知識，如果你耐心看完本篇文章，并且可以理解Swift的編程技巧和方法，恭喜你可以順利的使用Swift開發了，已經掌握了Swift的基本語法，想要真正從事蘋果開發，還需要在以后的學習中不斷探索和挖掘Swift
在接下來的文章中，直接深入主題，不做過多沒必要的文字說明，提高大家閱讀和吸收能力

一、常量和變量
常量：使用let來定義常量，定義之后不可以修改
變量：使用var來定義變量，定義之后可以修改
在使用過程中建議先定義常量,如果需要修改再修改為變量

import UIKit
let a : Int = 10
var b : Int = 20
b = 30 變量可以修改
// a = 20是錯誤的，常量是不能修改的

二、數據類型
1、類型介紹
Swift中的數據類型也有:整型/浮點型/對象類型/結構體類型等，整型分為有符號整型和無符號整型，例如Int、UInt，浮點型分為Float和Double

// 定義一個Int類型
var m : Int = 10
// 定義一個Double類型
let n : Double = 3.14

2、類型推導
Swift是強類型的語言，Swift中任何一個標識符都有明確的類型，如果定義一個標識符時有直接進行賦值,那么標識符后面的類型可以省略，Swift會自動根據后面的賦值來決定前面的標識符的數據類型，同時可以通過option+鼠標左鍵來查看變量的數據類型

Swift會自動識別a是整數，如果之后再賦值給a一個其他類型(比如浮點型)數值,則會報錯
var a = 20
// 正確寫法
var b = 3.33
b = 6.66

3、基本運算
Swift中在進行基本運算時必須保證類型一致,否則會出錯，相同類型之間才可以進行運算，Swift中沒有隱式轉換
Swift中數據類型的轉化，Int類型轉成Double類型是Double(標識符)，Double類型轉成Int類型是Int(標識符)

let a = 12
let b = 3.14

// 錯誤寫法，形同類型之間才可以進行運算
// let c = a + b
// let c = a * b

// 正確寫法，轉換類型進行運算
let c = Double(a) + b
let d = a + Int(b)

三、邏輯分支
1、分支的了解
分支即if、switch、三目運算符等判斷語句，通過分支語句可以控制程序的執行流程
2、if分支語句
和OC不同，Swift判斷句可以不加()，在Swift的判斷句中必須有明確的真假，不再有非0即真，必須有明確的Bool值，Bool有兩個取值:false、true，沒有Yes、NO的使用

例1
確定值存在的判斷
let a = 12

// 錯誤寫法，在Swift的判斷句中必須有明確的真假，不再有非0即真
//if a {
//    print("a")
//}

// 正確寫法
if a > 9 {
    print(a)
}

例2
可選類型的判斷，判斷如果view有值,則設置背景
let view : UIView? = UIView()
// 錯誤寫法
//if view {
//    view.backgroundColor = UIColor.red
//}

if view != nil {
    view!.backgroundColor = UIColor.red
}

3、三目運算符
Swift 中的 三目 運算符和 OC 的用法是一樣的

var a = 12
var b = 24

var result = a > b ? a : b
println(result)

4、guard的使用
guard是很重要的，在以后的開發中會經常用到，來判斷該值是否是可選類型，guard在Swift2.0就出現了，與if語句非常類似，它設計的目的是提高程序的可讀性
guard語句必須帶有else語句，當條件表達式為true時候跳過else語句中的內容，執行語句組內容，條件表達式為false時候執行else語句中的內容，跳轉語句一般是return、break、continue和throw

例1
guard用法說明
guard 條件表達式 else {
    // 條換語句，走這里的都是錯誤的，判斷不符合要求的
    break
}
語句組，正確的執行這里

例2
簡單使用guard的用法
 func gotToSchool(time:Int) -> Void {
        guard time > 6 else {
            print("去上學")
            return
        }
        print("不去上學")
    }
gotToSchool(time: 5)

5、switch分支
Switch作為選擇結構中必不可少的語句也被加入到了Swift中，只要有過編程經驗的人對Switch語句都不會感到陌生，蘋果對Switch進行了大大的增強，使其擁有其他語言中沒有的特性
基本用法和OC用法一致，switch后可以不跟()，case后可以不跟break(默認會有break)

例1
switch對整數的判斷

let sex = 0
switch sex {
case 0 :
    print("男")
case 1 :
    print("女")
default :
    print("其他")
}

例2
一個case判斷中,可以判斷多個值，多個值以,隔開

let sex = 0
switch sex {
case 0, 1:
    print("正常人")
default:
    print("其他")
}

例3
希望出現之前的case穿透,則可以使用關鍵字fallthrough

let sex = 0
switch sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}

Switch支持多種數據類型

① 浮點型的switch判斷

let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}

② 支持字符串類型

let m = 5
let n = 10
var result = 0

let opration = "+"

switch opration {
    case "+":
        result = m + n
    case "-":
        result = m - n
    case "*":
        result = m * n
    case "/":
        result = m / n
default:
    result = 0
}

③ switch支持區間判斷
開區間:0..<10 表示:0~9,不包括10
閉區間:0...10 表示:0~10

let score = 88
switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("幾個")
case 80..<90:
    print("良好")
case 90..<100:
    print("優秀")
default:
    print("滿分")
}

四、循環
在開發中經常會需要循環，常見的循環有：for、while、do while
1、for循環

① 傳統寫法
for var i = 0; i < 10; i++ {
    print(i)
}

② 區間for循環
for i in 0..<10 {
    print(i)
}

for i in 0...10 {
    print(i)
}

③ 特殊寫法
如果在for循環中不需要用到下標i，用`_`標示
for _ in 0..<10 {
    print("hello")
}

2、while和do while循環

① while的判斷句必須有正確的真假,沒有非0即真，while后面的()可以省略
var a = 0
while a < 10 {
    a++
}

② do while循環，使用repeat關鍵字來代替了do
let b = 0
repeat {
    print(b)
    b++
} while b < 20

五、字符串
OC和Swift中字符串的區別，在OC中字符串類型時NSString,在Swift中字符串類型是String，OC中字符串@"",Swift中字符串""
Swift中的String 是一個結構體，性能更高，NSString 是一個 OC 對象，性能略差，String 支持直接遍歷，Swift 提供了 String 和 NSString 之間的無縫轉換，可以使用as或者as?進行轉換
1、遍歷字符串

// 字符串遍歷
var str = "Hello, Swift"
for c in str.characters {
    print(c)
}

2、字符串拼接

例1
let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2

例2
let name = "why"
let age = 18
let info = "my name is \(name), age is \(age)"

例3
字符串的格式化
let min = 3
let second = 4
let time = String(format: "%02d:%02d", arguments: [min, second])

3、字符串的截取
Swift中提供了特殊的截取方式，該方式非常麻煩，簡單的方式是將String轉成NSString來使用，在標識符后加:as NSString即可

let myStr = "www.baidu.com"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

六、數組
數組（Array）是一串有序的由相同類型元素構成的集合，數組中的集合元素是有序的，可以重復出現，swift數組類型是Array，是一個泛型集合
1、數組的初始化
數組分成可變數組和不可變數組，使用let修飾的數組是不可變數組，使用var修飾的數組是可變數組

// 定義一個可變數組，必須初始化才能使用
var array1 : [String] = [String]()

// 定義一個不可變數組
let array2 : [NSObject] = ["xiaoming", 18]

在聲明一個Array類型的時候可以使用下列的語句之一
var stuArray1:Array<String>
var stuArray2: [String]

聲明的數組需要進行初始化才能使用，數組類型往往是在聲明的同時進行初始化的
// 定義時直接初始化
var array = ["xm", "xl", "my"]

// 先定義,后初始化
var array : Array<String>
array = ["xm", "xl", "my"]

2、對數組的基本操作

// 添加數據
array.append("xiaoming")

// 刪除元素
array.removeFirst()

// 修改元素
array[0] = "xiaoming"

// 取值
array[1]

3、數組的遍歷

// 遍歷數組
for i in 0..<array.count {
    print(array[i])
}

// forin方式，經常使用
for item in array {
    print(item)
}

// 設置遍歷的區間
for item in array[0..<2] {
    print(item)
}

4、數組的合并

// 數組合并
// 注意：只有相同類型的數組才能合并
var array = ["xm", "xl","my"]
var array1 = ["haha", "wsz"]
var array2 = array + array1;

// 不建議一個數組中存放多種類型的數據
var array3 = [2, 3, "why"]
var array4 = ["yz", 23]
array3 + array4

七、字典
字典是由兩部分集合構成的，一個是鍵（key）集合，一個是值（value）集合，鍵集合是不能有重復元素的，而值集合是可以重復的，鍵和值是成對出現的，Swift字典類型是Dictionary，也是一個泛型集合
1、Swift中的可變和不可變字典，使用let修飾的數組是不可變字典，使用var修飾的數組是可變字典

// 定義一個可變字典
var dict1 : [String : NSObject] = [String : NSObject]()

// 定義一個不可變字典
let dict2 = ["name" : "xl", "age" : 18]

在聲明一個Dictionary類型的時候可以使用下面的語句之一
var dict1: Dictionary<Int, String>
var dict2: [Int: String]

聲明的字典需要進行初始化才能使用，字典類型往往是在聲明的同時進行初始化的
// 定義字典的同時,進行初始化
var dict = ["name" : "why", "age" : 18]

// swift中任意對象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]

2、字典的基本操作

// 添加數據
dict["height"] = 1.80
dict["weight"] = 65.0

// 刪除字段
dict.removeValueForKey("height")

// 修改字典
dict["name"] = "lmj"

// 查詢字典
dict["name"]

3、字典的遍歷

// 遍歷字典中所有的值
for value in dict.values {
    print(value)
}
// 遍歷字典中所有的鍵
for key in dict.keys {
    print(key)
}
// 遍歷所有的鍵值對
for (key, value) in dict {
    print(key)
    print(value)
}

4、字典的合并

// 字典的合并
var dict1 = ["name" : "xl", "age" : 20]
var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
// 字典不可以相加合并
for (key, value) in dict1 {
    dict2[key] = value
}

八、元組
元組是Swift中特有的,OC中并沒有相關類型，類似于數組或者字典，可以用于定義一組數據，組成元組類型的數據可以稱為“元素”
1、元組的定義

元組的常見寫法
// 使用元組描述一個人的信息
("1001", "張三", 30, 90)
// 給元素加上元素名稱,之后可以通過元素名稱訪問元素
(id:"1001", name:"張三", english_score:30, chinese_score:90)

2、元祖的簡單使用

// 元祖使用

// 寫法一:
let object = (xiaoming, "18")
print(object.0)
print(object.1)

// 寫法二:
let object = (name : xiaoming, age : "18")
print(object.name)
print(object.age)

// 寫法三:
let (name, age) = (xiaoming, "18")
print(name)
print(age)

九、可選類型
在OC開發中,如果一個變量暫停不使用,可以賦值為0(基本屬性類型)或者賦值為空(對象類型)，在swift開發中，nil也是一個特殊的類型.因為和真實的類型不匹配是不能賦值的(swift是強類型語言)，但是開發中賦值nil，在所難免，因此推出了可選類型
可選類型的取值：空值或者有值
1、定義可選類型

// 寫法一:定義可選類型
let name : Optional<String> = nil

// 寫法二:定義可選類型,語法糖(常用)
let name : String? = nil

2、可選類型的使用

// 定義可選類型
var string : Optional<String> = nil

// 給可選類型賦值
string = "Hello world"

// 打印結果
print(string)
// 結果:Optional("Hello world")\n

// 取出可選類型的真實值(解包)
print(string!)
// 結果:Hello world\n

// 注意:如果可選類型為nil，強制取出其中的值(解包)，會出錯
string = nil
print(string!) // 報錯

// 正確寫法:
if string != nil {
    print(string!)
}

// 簡單寫法:為了讓在if語句中可以方便使用string
// 可選綁定
if let str = string {
    print(str)
}

十、函數
1、函數介紹
函數相當于OC中的方法，函數的格式如下

func 函數名(參數列表) -> 返回值類型 {
    代碼塊
    return 返回值
}

func是關鍵字，多個參數列表之間可以用逗號（,）分隔，也可以沒有參數，使用箭頭“->”指向返回值類型，如果函數沒有返回值，返回值為Void.并且“-> 返回值類型”部分可以省略

2、常見的函數類型

① 沒有參數，沒用返回值
func about() -> Void {
    print("iphone6s plus")
}
// 調用函數
about()

如果沒用返回值,Void可以寫成()
func about1() -> () {
    print("iphone6s plus")
}
// 如果沒有返回值，后面的內容可以都不寫
func about2() {
    print("iphone6s plus")
}
about2()

② 有參數，沒用返回值
func callPhone(phoneNum : String) {
    print("打電話給\(phoneNum)")
}
callPhone("+86 110")

③ 沒用參數，有返回值
func readMessage() -> String {
    return "吃飯了嗎?"
}
var str = readMessage()
print(str)

④ 有參數，有返回值
func sum(num1 : Int，num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20，num2: 30)
print(result)

3、函數的使用
① 外部參數和內部參數
在函數內部可以看到的參數,就是內部參數，在函數外面可以看到的參數,就是外部參數，默認情況下,從第二個參數開始,參數名稱既是內部參數也是外部參數，如果第一個參數也想要有外部參數，可以設置標簽，在變量名前加標簽即可，如果不想要外部參數,可以在參數名稱前加_

// num1和a是外部參數的名稱
func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int {
    return num1 * num2 * num3
}
var result1 = ride(num1: 20, a: 4, b: 5)

// 方法的重載:方法名稱相同，但是參數不同，可以稱之為方法的重載(了解)
func ride(num1: Int, _ num2 :Int) -> Int {
    return num1 * num2
}

var result2 = ride(20, 20)

② 默認參數
如果沒有傳入具體的參數,可以使用默認參數

func makecoffee(type :String = "卡布奇諾") -> String {
    return "制作一杯\(type)咖啡。"
}

let coffee1 = makecoffee("鐵觀音")
let coffee2 = makecoffee()

③ 可變參數
Swift中函數的參數個數可以變化，它可以接受不確定數量的輸入類型參數，它們必須具有相同的類型，我們可以通過在參數類型名后面加入（...）的方式來指示這是可變參數

func sum(numbers:Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(100.0, 20, 30)
sum(30, 80)

④ 引用類型(指針的傳遞)
默認情況下，函數的參數是值傳遞，如果想改變外面的變量，則需要傳遞變量的地址，必須是變量，因為需要在內部改變其值，Swift提供的inout關鍵字就可以實現

// 函數一：值傳遞
func swap(var a : Int, var b : Int) {
    let temp = a;
    a = b;
    b = temp
    print("a:\(a), b:\(b)")
}

var a = 10
var b = 20
swap(a, b: b)
print("a:\(a), b:\(b)")

// 函數二:指針的傳遞
func swap1(inout a : Int, inout b : Int) {
    let temp = a
    a = b
    b = temp

    print("a:\(a), b:\(b)")
}

swap1(&a, b: &b)
print("a:\(a), b:\(b)")

⑤ 函數的嵌套使用
swift中函數可以嵌套使用，即函數中包含函數,但是不推薦該寫法
十一、類的使用
1、類的介紹和定義
Swift也是一門面向對象開發的語言，面向對象的基礎是類，類產生了對象，class是Swift中的關鍵字，用于定義類

定義的類,可以沒有父類.那么該類是rootClass，通常情況下，定義類時，繼承自NSObject(非OC的NSObject)
class 類名 : SuperClass {
    // 定義屬性和方法
}

2、定義類的屬性
Swift中類的屬性有多種：存儲屬性，存儲實例的常量和變量；計算屬性，通過某種方式計算出來的屬性；類屬性，與整個類自身相關的屬性
① 存儲屬性
存儲屬性是最簡單的屬性，它作為類實例的一部分，用于存儲常量和變量，可以給存儲屬性提供一個默認值，也可以在初始化方法中對其進行初始化

// 給存儲屬性賦值
stu.age = 10
stu.name = "xiaoming"

stu.chineseScore = 89.0
stu.mathScore = 98.0

② 計算屬性
計算屬性并不存儲實際的值，而是提供一個getter和一個可選的setter來間接獲取和設置其它屬性，計算屬性一般只提供getter方法，如果只提供getter，而不提供setter，則該計算屬性為只讀屬性,并且可以省略get{}

class Student : NSObject {
    // 存儲屬性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 計算屬性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 沒有意義,因為之后獲取值時依然是計算得到的
        // newValue是系統分配的變量名，內部存儲著新值
        set {
            self.averageScore = newValue
        }
    }
}

③ 類屬性
類屬性是與類相關聯的，而不是與類的實例相關聯，類屬性的設置和修改,需要通過類來完成，類屬性使用static來修飾

class Student : NSObject {
    // 類屬性
    static var corseCount : Int = 0
}

// 設置類屬性的值
Student.corseCount = 3
// 取出類屬性的值
print(Student.corseCount)

④ 監聽屬性的改變
在OC中我們可以重寫set方法來監聽屬性的改變，在Swift中可以通過屬性觀察者來監聽和響應屬性值的變化，通常是監聽存儲屬性和類屬性的改變，(對于計算屬性，我們不需要定義屬性觀察者，因為我們可以在計算屬性的setter中直接觀察并響應這種值的變化)
willSet：在屬性值被存儲之前設置，此時新屬性值作為一個常量參數被傳入，該參數名默認為newValue，我們可以自己定義該參數名；didSet：在新屬性值被存儲后立即調用，與willSet相同，此時傳入的是屬性的舊值，默認參數名為oldValue；
willSet與didSet只有在屬性第一次被設置時才會調用，在初始化時，不會去調用這些監聽方法

class Person : NSObject {
    var name : String? {
        // 可以給newValue自定義名稱
        willSet (new){ // 屬性即將改變,還未改變時會調用的方法
            // 在該方法中有一個默認的系統屬性newValue，用于存儲新值
            print(name)
            print(new)
        }
        // 可以給oldValue自定義名稱
        didSet (old) { // 屬性值已經改變了,會調用的方法
            // 在該方法中有一個默認的系統屬性oldValue，用于存儲舊值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在賦值時,監聽該屬性的改變
// 在OC中是通過重寫set方法
// 在swift中,可以給屬性添加監聽器
p.name = "xiaoming"

十二、類的構造函數
構造函數類似于OC中的初始化方法init方法，默認情況下載創建一個類時,必然會調用一個構造函數，即便是沒有編寫任何構造函數，編譯器也會提供一個默認的構造函數，如果是繼承自NSObject，可以對父類的構造函數進行重寫
1、構造函數的基本使用
① 類的屬性必須有值，如果不是在定義時初始化值,可以在構造函數中賦值

class Person: NSObject {
    var name : String
    var age : Int
    // 重寫了NSObject(父類)的構造方法
    override init() {
        name = ""
        age = 0
    }
}

// 創建一個Person對象
let p = Person()

② 初始化時給屬性賦值
我們在創建一個對象時就會給屬性賦值，可以自定義構造函數，如果自定義了構造函數,會覆蓋init()方法，即不在有默認的構造函數

class Person: NSObject {
    var name : String
    var age : Int

    // 自定義構造函數,會覆蓋init()函數
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
}

// 創建一個Person對象
let p = Person(name: "xiaoming", age: 18)

③ 字典轉模型(初始化時傳入字典)

例1
class Person: NSObject {
    var name : String
    var age : Int

    // 自定義構造函數,會覆蓋init()函數
    init(dict : [String : NSObject]) {
        name = dict["name"] as! String
        age = dict["age"] as! Int
    }
}

// 創建一個Person對象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)

例2
利用KVC字典轉模型
class Person: NSObject {
    // 結構體或者類的類型，必須是可選類型，因為不能保證一定會賦值
    var name : String?

    // 基本數據類型不能是可選類型，否則KVC無法轉化
    var age : Int = 0

    // 自定義構造函數，會覆蓋init()函數
    init(dict : [String : NSObject]) {
        // 必須先初始化對象
        super.init()

        // 調用對象的KVC方法字典轉模型
        setValuesForKeysWithDictionary(dict)
    }
}

// 創建一個Person對象
let dict = ["name" : "xiaoming", "age" : 18]
let p = Person(dict: dict)

十三、閉包
Swift閉包和OC中的block非常相似，OC中的block是匿名的函數，Swift中的閉包是一個特殊的函數，block和閉包都經常用于回調
1、OC中Block的使用

首先介紹一下OC中Block寫法
① 第一種Block方式

@property (nonatomic, copy) void(^callBack)(NSString *name);
callBack 是block對象
回調方法
if(_callBack){
_callBack(name)
}

② 第二種Block方式

typedef void(^CallBack)(NSString *str);
@property (nonatomic, copy) CallBack callback;
callback是block對象
回調方法
if(_callBack){
_callBack(name)
}

③ 第三種Block方式

- (void)setUpWith:(void(^)(NSString *str))callback;
callback是block對象
回調方法
if(_callBack){
_callBack(name)
}

總結
Block的寫法:
    類型：
    返回值類型(^block的名稱)(block的參數)

    值:
    ^(參數列表) {
        // 執行的代碼
    };

2、Swift中閉包的使用
① 第一種閉包方式

var callBack : (()->())?

② 第二種閉包方式

func loadRequest(callBack : ()->()){
                callBack()
    }

總結
閉包的寫法:
   callBack: (形參列表) -> (返回值類型)
    類型:(形參列表) -> (返回值類型)
    值:
    {
        (形參) -> 返回值類型 in
        // 執行代碼
    }

閉包的簡寫，如果閉包沒有參數，沒有返回值，in和in之前的內容可以省略

尾隨閉包寫法
① 如果閉包是函數的最后一個參數，則可以將閉包寫在()后面
    httpTool.loadRequest() {
        print("回到主線程", NSThread.currentThread());
    }
② 如果函數只有一個參數,并且這個參數是閉包,那么()可以不寫
    // 開發中建議該寫法
    httpTool.loadRequest {
        print("回到主線程", NSThread.currentThread());
    }

3、閉包的循環引用
如果在HttpTool中有對閉包進行強引用,則會形成循環引用，在Swift中檢測一個對象是否銷毀,可以實現對象的deinit函數

// 析構函數(相當于OC中dealloc方法)
    deinit {
        print("ViewController----deinit")
    }

4、swift中解決循環引用的方式
① 使用weak,對當前控制器使用弱引用
但是因為self可能有值也可能沒有值，因此weakSelf是一個可選類型，在真正使用時可以對其強制解包(該處強制解包沒有問題，因為控制器一定存在,否則無法調用所在函數)

解決一
weak var weakSelf = self
    httpTool.loadData {
        print("加載數據完成,更新界面:", NSThread.currentThread())
        weakSelf!.view.backgroundColor = UIColor.redColor()
    }

② 可以寫在閉包中,并且在閉包中用到的self都是弱引用

解決二
 httpTool.loadData {[weak self] () -> () in
        print("加載數據完成,更新界面:", NSThread.currentThread())
        self!.view.backgroundColor = UIColor.redColor()
    }

③ 使用關鍵字unowned
unowned 更像OC中的 unsafe_unretained，unowned 表示即使它原來引用的對象被釋放了，仍然會保持對被已經釋放了的對象的一個 "無效的" 引用，它不能是 Optional 值，也不會被指向 nil

解決三
httpTool.loadData {[unowned self] () -> () in
        print("加載數據完成,更新界面:", NSThread.currentThread())
        self.view.backgroundColor = UIColor.redColor()
    }

十四、懶加載
swift中也有懶加載的方式，希望所有的對象在使用時才真正加載到內存中，和OC不同的是swift有專門的關鍵字來實現懶加載，lazy關鍵字可以用于定義某一個屬性懶加載
1、懶加載普通方式

lazy var 變量：類型 = 系統類()
lazy var button：UIButton = UIButton()

2、懶加載升級方式

lazy var array : [String] = {
        () -> [String] in
        return ["xiaoming", "xl", "lisi"]
    }()

心得體會：
Swift好用，如果你讀完本篇文章基本上掌握了Swift基礎知識，剩下的就是實戰了，實戰會增加你編寫Swift的能力，對Swift有更深的理解，后期也會補充新的Swift知識，也會分享自己的開源Swift項目共大家學習討論，請關注下我的github賬號lb2281075105，開始分享自己的項目和Demo，如果更好的意見請及時給我說哦，合理我會毫不猶豫采納，謝謝，您的點贊會更加激勵我的熱情。