今天系統(tǒng)的總結(jié)一下swift的語法，方便后期查看。

本篇學(xué)習(xí)總結(jié):

• 常量和變量
• 變量和常量的輸出
• 類型安全和類型推導(dǎo)
• 基本運(yùn)算
• 區(qū)間運(yùn)算符
• 邏輯分支(if, guard, switch)
• 循環(huán)語句(for, while,repeat while)
• 集合(Array, Dictionary, Set,元組)
• 可選類型
• 類型轉(zhuǎn)換

好了，帶著知識點(diǎn)，我們一一開始閱讀吧 ??

常量和變量

Swift中定義標(biāo)識符必須明確指明該標(biāo)識符是常量還是變量。常量和變量將名字（標(biāo)識符）和一個特定類型的值關(guān)聯(lián)起來。

使用let定義變量，表示該值不能更改
使用var定義變量，表示該值可以更改

語法格式：

// let / var 標(biāo)識符名稱 : 標(biāo)識符類型 = 賦值
let score : Double = 89.5
var age : Int = 20
// Swift中如果一行只有一條語句的時候，那么語句結(jié)束時的;可以省略

注意點(diǎn)：

• 1.在開發(fā)中，我們一般優(yōu)先使用常量，只有發(fā)現(xiàn)標(biāo)識符需要修改時，在使用變量，這樣做防止我們在不希望它值修改的情況下，在其他地方被修改。
• 2.常量的本質(zhì)：標(biāo)識符指向的內(nèi)存地址不可以被修改，但是可以通過內(nèi)存地址找到對應(yīng)的對象，修改對象內(nèi)部的屬性。
• 3.省略：上面的例子中:Double 和 :Int是可以省略的，事實(shí)上，我們也不需要經(jīng)常使用類型標(biāo)注，如果在定義一個變量或常量的時候就初始化一個值，那么Swift九江推斷出這個變量或常量的類型，可以通過option + 鼠標(biāo)左鍵來查看標(biāo)識符類型。
• 4.標(biāo)識符名稱，也就是變量和常量的名字不能包含空白字符，數(shù)學(xué)符號，箭頭，保留的或者無效的Unicode碼位，連線，制表符，也不能以數(shù)字開頭。

變量和常量的輸出

Swift中使用print()打印變量和常量中的值

print("hello swift")
// 當(dāng)需要輸出變量或常量的時候，可以直接使用字符串插值的方式把變量名或常量名當(dāng)做占位符加入到字符串當(dāng)中，Swift會用常量或變量的當(dāng)前值來替換這些占位符
// 通過將常量或變量放入()中并在前面加上\將其轉(zhuǎn)義
let version : Double = 4.0
print("hello swift \(version)")

類型安全和類型推導(dǎo)

Swift是一門類型安全的語言，類型安全的語言可以讓我們清楚的知道值的類型，幫助我們規(guī)避很多錯誤。Swift會在編譯代碼的時候進(jìn)行類型檢查，如果我們錯誤的將不匹配的類型進(jìn)行附值，編譯器會報(bào)錯。
同理，如果沒有為值進(jìn)行類型說明，Swift會通過檢查我們給變量賦的值并在編譯階段會自動推斷出附值的合適類型，這個過程就是類型推導(dǎo)。

我們可以通過option + 鼠標(biāo)左鍵查看標(biāo)識符類型。

let score  = 89.5
var age  = 20
// 編譯器會在賦值時自動根據(jù)其值推斷出 score為Double類型，age為Int類型
let sum = 55.5 + 30
// 甚至編譯器會推斷出算式的值得類型為Double

基本運(yùn)算

Swift中相同類型的數(shù)據(jù)之間才可以進(jìn)行運(yùn)算，Swift中沒有類似OC中的隱式類型轉(zhuǎn)換，所以當(dāng)兩個變量類型不同時，需要進(jìn)行強(qiáng)制類型轉(zhuǎn)換，前面提到過Swift時一門強(qiáng)類型語言，即使Int8類型和Int類型也不能直接進(jìn)行運(yùn)算，同樣需要強(qiáng)制轉(zhuǎn)換類型才可以。

強(qiáng)制類型轉(zhuǎn)換 Int(標(biāo)識符a)，Double(標(biāo)識符b)

let n = 10
let x : Int8 = 5
let m = 10.5

let result = Double(n) + m // Int轉(zhuǎn)化為Double
let result1 = Int(m) + n // Double轉(zhuǎn)化為Int
let retule2 = Int(x) + n // Int8 與 Int進(jìn)行運(yùn)算同樣需要轉(zhuǎn)化

除了不同類型之間運(yùn)算需要進(jìn)行強(qiáng)制類型轉(zhuǎn)換外，Swift中其他基本運(yùn)算符與OC中一樣，Swift中還添加了一些非常方便的元素符.

區(qū)間運(yùn)算符

1. 閉區(qū)間運(yùn)算符(a...b)，定義了從a到b的一組范圍，并且包含a和b，要求a <= b.
2. 半開區(qū)間運(yùn)算符(a..<b)，定義了從a到b 但不包括b的區(qū)間，要求a <= b，當(dāng)a=b時那么返回的區(qū)間為空.
3. 單側(cè)區(qū)間運(yùn)算符[2...]，一般用于數(shù)組中，例如list[2...] 即表示從list數(shù)組索引2開始一直到結(jié)束，注意這時2必須小于數(shù)據(jù)的count，否則編譯器將會報(bào)錯.
4. 當(dāng)然也可以寫成[...2]表示從0開始到2的索引，[..<2]表示從0開始到1的索引.

邏輯分支

Swift提供了多種多樣的控制流語句，是我們在日常使用中可以根據(jù)不同的情況進(jìn)行使用，除了if while之外Swift 還提供了guard語句來應(yīng)對需要對多個條件進(jìn)行判斷的情況，是代碼邏輯顯得更加清晰。

if 條件語句

Swift中的if條件語句后面的()內(nèi)容可以省略，同事需要注意的是，Swift中沒有像OC中的非0（nil）即真的判斷方式，也就是說Swift中我們必須給出明確的判斷條件.

let score = 88

if score > 0 {
    print("score > 0")
}
if score != 0 {
    print("score != 0")
}
// 這里不能像OC中 if (a) {} 即可判斷a是否為0，Swift中必須給出明確的判斷條件

if條件判斷語句同OC中一樣，只不過if后面()去掉也許會讓我們稍有些不習(xí)慣，不過很快就會熟悉

// if else
if score < 0 || score > 100 {
    print("不合理分?jǐn)?shù)")
}else if score < 60 {
    print("不及格")
}else if score >= 60{
    print("及格")
}

guard條件語句

guard 的使用與if非常相似，可以同if進(jìn)行無縫轉(zhuǎn)化，為了提高代碼的可讀性，我們可以把guard看作一個看門人，不符合條件的統(tǒng)統(tǒng)不許通過，最后通過的也就是我們想要的結(jié)果

let idCard = true
let ticket = true

func Ontrain (idCard : Bool , ticket : Bool) {
    // 判斷有沒有帶身份證
    guard idCard else {
        print("沒有帶身份證，不可以乘車")
        return
    }
    // 判斷有沒有車票
    guard ticket else {
        print("沒有車票，不可以乘車")
        return
    }
    
    print("身份證和車票都帶了，可以乘車")
    // 滿足以上所有條件才可以 使用場景：滿足所有條件才可以達(dá)成某些功能
}

Switch語句

1. switch后面的()可以省略.
2. case語句結(jié)束，可以不加break，系統(tǒng)默認(rèn)幫我們加上了break，如果希望case結(jié)束時產(chǎn)生穿透，去除break效果需要加上fallthrough.
3. 在每條case中必須包含至少一條可執(zhí)行語句，不能為空.
4. case語句后面可以判斷多個條件。每個條件之間用逗號隔開，如果任何一個條件匹配了，則會執(zhí)行case下的語句.
5. switch可以判斷多種類型，包括浮點(diǎn)型，字符串類型，區(qū)間類型，元祖
6. switch可以將匹配到的值臨時綁定為一個變量或者一個常量，來給case中的執(zhí)行語句使用
7. 同時可以在case語句后添加額外的where判斷
8. switch 可以被打傷標(biāo)簽循環(huán)使用

switch 基本使用

let sex = 0
switch sex {
case 0:
    print("M")
    break // 可省略
case 1:
    print("F")
    fallthrough // 如果想要產(chǎn)生穿透
default:
    print("?")
}

switch語句后面判斷多個條件

switch sex {
case 0,1: // 任何一個條件匹配了，就會執(zhí)行case下的語句
    print("正常")
default:
    print("???")
}

case進(jìn)行區(qū)間匹配

let score = 88
switch score {
case 0..<60:
    print("不及格")
case 60..<80:
    print("及格")
case 80...100:
    print("優(yōu)秀")
default:
    print("不合理分?jǐn)?shù)")
}

switch中也可以判斷多種類型，字符串類型，元祖，浮點(diǎn)型

// 這里用元組舉例
let point = (1,1) // 類型為(Int,Int)的元組
switch point {
case (0, 0):
    print("(0, 0) is at the origin")
case (_, 0): // 如果不想匹配元組中的某一個值，可以用_代替
    print("(\(somePoint.0), 0) is on the x-axis")
case (0, _):
    print("(0, \(somePoint.1)) is on the y-axis")
case (-2...2, -2...2): // 元組中使用區(qū)間匹配
    print("(\(somePoint.0), \(somePoint.1)) is inside the box")
default:
    print("(\(somePoint.0), \(somePoint.1)) is outside of the box")
}
// prints "(1, 1) is inside the box"

switch可以將匹配到的值臨時綁定為一個變量或者一個常量，來給case中的執(zhí)行語句使用

let personInfo = (name : "abc" , age : 20)

switch personInfo {
case (let x , 1..<18):
    print("未成年的人有\(zhòng)(x)")
case (let x , 18..<100):
    print("成年的人有\(zhòng)(x)")
default:
    print("沒有匹配的人")
}
// print 成年的人有abc

switch 在case語句后面添加額外的where判斷

let personInfo = (name : "abc" , age : 20)

switch personInfo {
case (let x , 1..<18) where x == "abc": // 只是舉例，并沒有意義
    print("未成年的人有\(zhòng)(x)")
case (let x , 18..<40) where x == "and":  // 只是舉例，并沒有意義
    print("成年的人有\(zhòng)(x)")
default:
    print("沒有匹配的人")
}
// print "沒有匹配的人\n"

給語句打標(biāo)簽

var times = 0
timeLoop : while times < 10 {
    times += 1
    switch times {
    case 6:
        break timeLoop
    case 4:
        continue timeLoop
    default:
        print("default")
    }
}
// print :  default default default default
// 這里我們給while循環(huán)打上timeLoop標(biāo)簽，可以發(fā)現(xiàn)，times等于1...3時打印了三遍defult，當(dāng)times等于4時，continue結(jié)束了當(dāng)前while循環(huán)并開始下一次循環(huán)，times等于5然后打印第四遍default，times等于6時bread timeLoop結(jié)束了while循環(huán)不在進(jìn)行打印。

循環(huán)語句

swift中循環(huán)語句與OC中的相同，for，while，repeat while 循環(huán)，使用方法也與OC中基本相同

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

// 在 Swift中如果一個變量/常量暫時不會使用，那么可以使用_來代替，_不會占用內(nèi)存空間
for _ in 0...10 {
    print("hello Swift")
}

repeat while 也就是OC中的do while循環(huán)

var m = 0

while m < 10 {
    m += 1
    print(m)
}

// repeat 無論是否成立都要先走一次
repeat {
   m -= 1
    print(m)
} while m > 0

集合

1.Swift提供了三種主要的集合類型，所謂的數(shù)組，合集還有字典，用來存儲值的集合。
數(shù)組：是有序的值的集合
合集：是唯一值的無序集合
字典：是無序的鍵值對集合
2.Swift中的集合都是泛型集合，也就是說集合需要明確存儲的值的類型，保證我們不會意外的插入一個錯誤類型的值到集合中去，同時保證我們可以從集合中取回確定類型的值

Swift中的集合.png

數(shù)組

數(shù)組以有序的方式儲存相同類型的值，相同類型的值可以在數(shù)組的不同地方多次出現(xiàn)。Swift中的數(shù)組是Array類型的，不像OC中區(qū)分NSArray 和 NSMutableArray，而是通過我們創(chuàng)建的不同來定義數(shù)組

不可變數(shù)組：let修飾
可變數(shù)組：var修飾

定義數(shù)組語法

// Array類型 <>里表示數(shù)組中存放的數(shù)據(jù)類型
let array : Array<String> = ["a","b","c"] // 不可變數(shù)組不可操作
// 數(shù)組類型簡寫 推薦使用簡寫寫法，更加簡單清晰
let array : [String] = ["a","b","c"]
// 創(chuàng)建空數(shù)組
var arrayM2 = Array<String>()
// 同樣可以進(jìn)行簡寫
var arrayM : [String] =  Array()
var arrayM1 = [String]()

/* 
* 同時數(shù)組還為我們提供了初始化方法創(chuàng)建
* repeating：表示數(shù)組存儲對應(yīng)類型的默認(rèn)值
* count：表示數(shù)組內(nèi)元素的個數(shù)
*/
var arr = Array(repeating: "a", count: 5)

對可變數(shù)組的基本操作

// 獲取數(shù)組元素個數(shù)
let count = arrayM.count
// 同時也可以使用isEmpty Bool值屬性 來對數(shù)組是否為空進(jìn)行快速判斷
if arrayM.isEmpty {
}

// 1. 添加元素
arrayM.append("abc")
// 也可以使用 +=運(yùn)算符在數(shù)組末尾添加新的同類型元素
arrayM += ["aa","bb"]
// 使用 insert方法添加元素到指定位置
arrayM.insert("js", at: 1)

// 刪除元素
arrayM.remove(at: 0) // 返回被刪除的元素
arrayM.removeAll() // 刪除所有的
arrayM.removeLast() // 刪除最后一個
arrayM.removeFirst() // 刪除第一個

// 提取元素
let name = arrayM[0]

// 修改元素
arrayM[0] = "abc"
// 也可以使用區(qū)間類型修改多個元素
arrayM[2...3] = ["haha","xixi"]

需要注意的是，同OC一樣，當(dāng)我們訪問或者修改一個超出數(shù)組元素個數(shù)的值將會引發(fā)crash.

數(shù)組的遍歷
同OC一樣，我們可以使用for in來遍歷整個數(shù)組中的值

for item in arrayM {
    print(item)
}
// 如果我們想要拿到數(shù)組中每個元組的值以及它的索引，我們可以使用enumerated()方法來返回?cái)?shù)組中每一個元素的元組，元組中包含了元素的索引和值
for (index , item) in arrayM.enumerated(){
    print(index)
    print(item)
}

集合

Swift中集合的類型是Set，同OC中的NSSet一樣，集合還將同一類型也不重復(fù)的值無序的存儲在一個集合當(dāng)中

定義集合語法

// 使用 Set<Element>創(chuàng)建并初始化一個集合
var letters = Set<Int>()
// 注意Set沒有同數(shù)組一樣對應(yīng)的簡寫方式
// 也可以通過數(shù)組來創(chuàng)建集合
var name: Set<String> = ["aa", "bb", "aabb"]

集合的訪問與修改

// 通過count來訪問集合內(nèi)元素的個數(shù)
print(name.count)
// 也可以通過 isEmpty快速判斷count屬性是否為0
if name.isEmpty {
    print("As far as music goes, I'm not picky.")
}

// 通過insert為集合新增加一個元素
name.insert("enen")

// 刪除集合中的元素
if let nameInfo = name.remove("bb") {
    print("\(nameInfo)")
}
// 如果集合中有bb這個元素那么就刪除它，并且返回被刪除的元素，如果沒有就返回nil
// 我們這里使用 if let 來對返回的值進(jìn)行判斷，如果集合中存在被刪除的參數(shù)，那么返回值不為nil，然后就會執(zhí)行大括號里面的內(nèi)容，如果集合中不存在該參數(shù)，那么就會返回nil，大括號中的內(nèi)容就不會執(zhí)行

// 使用contains()方法檢查集合中是否包含了特定的元素
if name.contains("aa") {
    print("aa is in set")
}

集合的遍歷

for nameStr in name {
    print("\(nameStr)")
}

// 可以通過使用 sorted方法將合集的元素進(jìn)行排序
for nameStr in name..sorted() {
    print("\(nameStr)")
}

集合基本操作

Swift提供了很多便捷的方式讓我們對集合進(jìn)行基本操作來獲取兩個集合相交的集合或者其他等等。

1. 使用intersection(_:)方法來創(chuàng)建一個只包含兩個集合共有值的新集合。
2. 使用symmetricDifference(_:)方法來創(chuàng)建一個只包含兩個集合各自有的非共有值的新集合。
3. 使用union(_:)方法來創(chuàng)建一個包含兩個集合所有值的集合
4. 使用subtracting(_:)方法來創(chuàng)建一個兩個集合當(dāng)中不包含某個集合值的新合集
5. 使用相等運(yùn)算符(==)來判斷兩個集合是否包含有相同的值
6. 使用isSubset(of:)方法來確定一個集合的所有值是否被某合集包含
7. 使用isSuperset(of:)方法來確定一個集合是否包含某個合集的所有值
8. 使用isStrictSubset(of:)或者isStrictSuperset(of:)方法來確定某集合是否為另一個集合的子集或者超集，但并不相等
9. 使用isDisjoint(with:)方法來判斷兩個集合是否擁有完全不同的值

示例如下：

前四種集合基本操作圖例.png

字典

Swift中字典的類型是Dictionary，同樣是泛型集合，Int Double類型均為結(jié)構(gòu)體，都可以放入數(shù)組和字典中

字典的定義

let 定義不可變字典
var定義可變字典

// 字典也用[]表示，編譯器會自動區(qū)分[]中是一個個元素（數(shù)組）還是鍵值對（字典）
let dic : Dictionary<String , Any> = ["string" : "aa", "age" : 18 , "height" : 1.88]
// 與數(shù)組一樣，同樣可以對字典進(jìn)行簡寫
let dic2 : [String : Any] = ["string" : "aa", "age" : 18 , "height" : 1.88] // 推薦 這種寫法更簡便一些

//定義可變字典 var 修飾
var dicM = Dictionary <String ,Any> ()
var dicM1 = [String : Any]()

// 與數(shù)組一樣，如果你用一致類型的字典字面量初始化字典，就不需要寫出字典的類型了
var dicName = ["key1":"bb","key2":"dd"]

字典的基本操作

// 同數(shù)組一樣字典也擁有count屬性和isEmpty屬性來得到字典的元素個數(shù)和快速判斷字典元素個數(shù)是否為0

給字典添加元素
dicM["name"] = "abc"
dicM["age"] = 18
dicM["height"] = 1.88

// 刪除元素
dicM.removeValue(forKey: "name") // 如果刪除成功則返回被刪除的值，如果字典沒有這個鍵值對則返回nil
dicM.removeAll() 
// 我們也可以使用下標(biāo)腳本語法給一個鍵賦值 nil來從字典當(dāng)中移除一個鍵值對
dicM["name"] = nil

// 修改元素 字典會自動索引字典中沒有相同的key，如果沒有就添加，如果有就修改其值
dicM["name"] = "aa"
// updateValue的功能同上，同樣會增加或修改元素的值
// 如果updateValue是更新已經(jīng)存在鍵的值，則會返回原來舊值的可選類型
// 如果updateValue為字典新增加了一個元素，則返回nil
dicM.updateValue("aa", forKey: "name")

遍歷字典

// 遍歷字典中所有的key
for key in dic.keys {
    print(key)
}
// 遍歷字典中所有的value
for value in dic.values {
    print(value)
}
// 遍歷字典中所有的key - value
for (key,value) in dic{
    print(key, value)
}
// 拿到所有key 或value組成的數(shù)組
let keyArr = [String](dict.keys)
let valueArr = [String](dict.values)

// 我們可以通過遍歷其中一個字典，為第二個字典賦值，來合并兩個字典
let dicStr : [String : Any] = ["name" : "cl" , "age" : 18]
var dicStr2 : [String : Any] = ["name":"aa","height" : 1.88 , "phone" : "110"]
for (key , value) in dicStr {
    dicStr2[key] = value
}

同樣，Swift的Dictionary類型是無序的，要以特定的順序遍歷字典的鍵或值，則需要使用sorted()方法。

元組

元組是Swift中新添加的可以將多個值合并成單一的復(fù)合型的值，并且元組內(nèi)的值可以是任何類型，且不必是同一類型。任何類型的排列都可以被用來創(chuàng)建一個元組，它可以包括任意多的類型，元組非常方便的幫助我們解決了數(shù)組和字典的缺陷

元組的創(chuàng)建

// 元組創(chuàng)建寫法一
let tuple = ("aaa",18,1.88)
// 可以通過從零開始的索引訪問元組中的單獨(dú)元素
let tupleName = tuple.0

// 寫法二 為元組中單個元素命名
let tuple1 = (name:"aaa", age:18, height:1.88)
let nameLength = tuple1.name.characters.count
// 如果只想取出元組中部分?jǐn)?shù)據(jù)，不想要取出的可以用_代替
let (tupleName2, age2, _) = tuple1
print("我叫\(zhòng)(tupleName2)今年\(age2)")

// 寫法三 一一對應(yīng)
let (name,age,height) = ("cl",18,1.88)
print(name)

可選類型

Swift中只有可選類型才能被附值為nil，其他類型都不能附值為nil
OC中當(dāng)一個值不在使用時，我們可以將它附值為0（基本數(shù)據(jù)類型）或者附值為nil（對象類型），但是在Swift中，nil時一個特殊的類型，同String，Int相同。而Swift時一門強(qiáng)類型語言，類型不匹配無法附值，所以只有可選類型才能被附值為nil，被可選類型修飾的值則表示該值有可能為nil，被可選類型修飾的值則表示該值有可能為nil。

可選類型的定義

// 首先我們嘗試給String變量賦值為nil編譯器報(bào)錯
// Nil cannot initialize specified type 'String'
// var name : String = nil

// 定義可選類型 Optional表示可選類型 泛型集合
var name : Optional<String> = nil
// 簡寫 String？表示可選類型的string 
var name1 : String? = nil
// 問號明確了它儲存的值是一個可選項(xiàng)，意思就是說它可能包含某些 String  值，或者為nil。

// 給可選類型進(jìn)行賦值
name1 = Optional("aaa") // 方式一
name1 = "aaa" // 方式二 編譯器會自動加上 Optional()

我們通過option查看name為String?可選類型

可選類型String?.png

同時當(dāng)我們在類中創(chuàng)建暫時不需要使用的變量的時候，定義為可選類型并且不提供默認(rèn)值，變量會被自動設(shè)置為nil.

對可選類型進(jìn)行取值

print(name1)
// 取出可選類型中的值 可選類型! --> 強(qiáng)制解包
print(name1!)
// print  Optional("aaa")
// print  aaa

可以發(fā)現(xiàn)直接打印name1輸出Optional("aaa")可選類型，并不是我們想要拿到的字符串，使用!對可選類型進(jìn)行強(qiáng)制解包，可以拿到可選類型中的值，
我們只有非常確定可選類型有值才可以進(jìn)行強(qiáng)制解包，一旦可選類型為nil，強(qiáng)制解包程序就會立即crash。

所以我們可以在使用的時候優(yōu)先對可選類型進(jìn)行判斷

// 判斷可選類型不為nil，然后才強(qiáng)制解包
if name1 != nil {
    print(name1!)
}

但是我們在開發(fā)中會大量的使用可選類型，如果每一個都需要進(jìn)行判斷就會非常麻煩，所以Swift推出可選綁定語法，該語法用于可選類型，是我們使用可選類型更加方便。

可選綁定語法

if let tempName = name1 {
    print(tempName)
}

可選綁定會優(yōu)先判斷name1是否有值，如果沒有值，則直接不執(zhí)行{}中的內(nèi)容，如果name有值，那么系統(tǒng)會自動對可選類型進(jìn)行解包，并且將解包后的結(jié)果附值給前面的tempName。

同時為了方便，并且避免同一個變量有多個名字，我們可以使用相同的名字進(jìn)行命名，在大括號內(nèi)直接使用相同的變量名即可。

if let name1 = name1{
    print(name1)
}

類型轉(zhuǎn)換

我們通過as 將實(shí)例轉(zhuǎn)化為一種類型

將String轉(zhuǎn)化為NSString
let str = "askkdsfjksdfffff" as NSString
str.substring(to: 6)

通過as?將實(shí)例轉(zhuǎn)化為可選類型

let dict : [String : Any] = ["name":"aaa" , "age" :18]
let tempName = dict["name"]
print(tempName!)
// 通過as?轉(zhuǎn)成可選類型 這里將 any 類型 轉(zhuǎn)成 string類型
// as? 轉(zhuǎn)成的類型是一個可選類型，系統(tǒng)會自動判斷tempName是否可以轉(zhuǎn)成String類型，如果可以轉(zhuǎn)成，那么獲取字符串，如果轉(zhuǎn)化不成功，則返回nil
let name = tempName as? String
if let name = name {
    print(name)
}
if let name = dict["name"] as? String {
    print(name)
}

通過as!轉(zhuǎn)成具體類型

// 注意：如果轉(zhuǎn)化不成功則程序會崩潰
// 建議：如果確定轉(zhuǎn)化成功再用as! 進(jìn)行轉(zhuǎn)化
let tempName1 =  dict["name"]
let name1 = tempName1 as! String

使用as?轉(zhuǎn)化的name為String?類型，使用as!轉(zhuǎn)化為name1為String類型，可選類型不僅增加了代碼的可讀性，并且使Swift代碼更加嚴(yán)謹(jǐn)和安全。

本篇先記錄這些，如有錯誤，不吝賜教！