基本數(shù)據(jù)類型

• 常見的數(shù)據(jù)類型：

  • 值類型（value type）
  1. 枚舉
     enum / Optional
  2. 結(jié)構(gòu)體
     Bool/Int/Float/Double/Character/String/Array/Dictionary/Set
  • 引用類型（reference type）:
    類（class）
  • 整數(shù)類型
    在32位的平臺(tái)中Int等價(jià)于Int32、64位平臺(tái)Int等價(jià)于Int64
    Int8/Int16/Int32/Int64/UInt8/UInt16/UInt32/UInt64
  • 浮點(diǎn)類型:
    Float(32位杠河，精度只有6位)
    Double(64位，精度至少15位)

 func valueFunc() {
        
        var floatDemo: Float? = 10
        var doubleDemo: Double? = 29
        
        enum TestEnum{
            case one,two,three
        }
        struct SomeStruct{
            var age = 10
            var height = 167
        }
    }

• 字面量罢维，直接賦值太抓，編譯器可以推斷其類型的內(nèi)容

        let bool = true
        let intDecimal = 17 //十進(jìn)制
        let intBinary = 0b1001010 //二進(jìn)制
        let intHexdecimal = 0x12 //十六進(jìn)制
        let intOctal = 0o21 //八進(jìn)制
        
        let doubleDecimal = 125.0 //十進(jìn)制 等價(jià)于1.25e2

• 類型轉(zhuǎn)換

func typeToChange() {
        //整數(shù)轉(zhuǎn)換
        let int1: UInt16 = 2_000
        let int2: UInt8 = 1
        let int3 = int1 + UInt16(int2)
        
        //字面量可以直接相加空闲，字面量本身沒有明確的類型
        let int4 = 123 + 12.344
    }

• 元組

func tupleDemo() {
        //如何創(chuàng)建一個(gè)404錯(cuò)誤的元組？如何取值走敌？
        let http404Error = (404,"404 error, not found")
        print("The status is \(http404Error.0)")
        
        //如何對(duì)元組取值
        var firstValue = http404Error.0
        var secondValue = http404Error.1
        
        //取到元組內(nèi)容
        let (status, message) = http404Error
        print("status code is \(status), message:\(message)")
        
        //忽略某個(gè)元組參數(shù)
        let (careStatus, _) = http404Error
        print("i only care status:\(careStatus)")
        
    }

• 條件判定(if 后面只能是Bool類型,可以省略小括號(hào)碴倾，大括號(hào)不能省略)

func loginJudge() {
        let age = 5
        if age >= 22 {
            print("ready to marry")
        }else if age > 18{
            print("just in adult")
        }else{
            print("just a child")
        }

• while的使用

 /*
     循環(huán)
     while使用
     repeat...while 相當(dāng)于OC中的do...while循環(huán)
     */
    func whileUse() {
        var num = 5
        while num > 0 {
            print("循環(huán)我...")
            num -= 1
        }
        
        var repeatTimes = 5
        repeat{
            print("look here ...")
            repeatTimes -= 1
        }while repeatTimes > 0
    }

• for循環(huán)使用

func forLoopUse() {
        let names = ["Zhang", "Lee", "Chen", "Gong"]
        //...是閉區(qū)間方法，返回閉區(qū)間
        for i in 0...3 {
            print(names[i])
        }
        //使用range遍歷
        let range = 1...3
        for j in range {
            print(names[j])
        }
        
        var a = 1
        let b = 3
        for j in a...b {
            print(names[j])
        }
        
        for _ in 0 ..< names.count {
            print("for item")
        }
    }

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

    /*
     區(qū)間運(yùn)算符
     通過創(chuàng)建區(qū)間運(yùn)算符判定指定數(shù)的范圍類型
     */
    func rangeCreatAndUse() {
        let range = ...10
        print(range.contains(20))
        print(range.contains(11))
    }

    /*
     使用區(qū)間運(yùn)算符遍歷數(shù)組掉丽，區(qū)間運(yùn)算符：[1...b]/[1...]/[...1]/[..<2]
     */
    func rangUseInArray() {
        
        let names = ["Zhang", "Lee", "Chen", "Gong"]
        for name in names[0...3] {
            print(name)
        }
        
        for name in names[...3] {
            print(name)
        }
        
        for name in names[..<4] {
            print(name)
        }
    }

• 區(qū)間類型
  1. ClosedRange<T> 閉區(qū)間
  2. Range<T> 半開區(qū)間（前閉后開）
  3. PartialRangeThrough<T> 部分區(qū)間

//練習(xí)：使用區(qū)間判斷字符是否在字母范圍跌榔，請(qǐng)利用區(qū)間特性
func rangeType() {
        let _: ClosedRange<Int> = 1...3 //閉區(qū)間
        let _: Range<Int> = 1..<3 //半開區(qū)間（前閉后開）
        let _: PartialRangeThrough<Int> = ...5 //部分區(qū)間
        
        let character: ClosedRange<Character> = "a"..."z"
        print(character.contains("B"))
        
        let charRang: ClosedRange<Character> = "\0"..."~"
        print(charRang.contains("B"))
    }

//從4開始累加2，不超過11捶障，篩選出對(duì)應(yīng)的數(shù)據(jù)值僧须，可以使用stride方法來進(jìn)行跳躍
 func rangeContainThrough() {
        let allRang:ClosedRange<Int> = 1...100
        
//        var indexValue = 0
//        switch allRang.startIndex {
//        case .inRange(let preIndex):
//            indexValue = preIndex
//        default:break
//        }
//
//        print("position [0] = \(indexValue)")
    
        for targetValue in stride(from: 4, through: 100, by: 2) {
            print(targetValue)
        }
    }

• Switch 語句
  1. case/default后面不能夠添加大括號(hào)
  2. Swift中的case不用添加break，默認(rèn)會(huì)執(zhí)行到下一個(gè)case到來

注意點(diǎn)：
1. case项炼、default 后面至少需要跟一條語句
2. 如果不想做任何事担平，可以在最后添加break語句結(jié)束

func switchUse() {
        let num = 1
        switch num {
        case 1:
            print(num)
        case 2:
            print(num)
        default:
            print(num)
        }
    }

    /*
     連續(xù)執(zhí)行多行case，如何操作?
     可以使用fallthrough操作
     */
    func mutiCaseExec() {
        let num = 1
        switch num {
        case 1:print(num); fallthrough
        case 2:print(num); fallthrough
        case 3:print(num); fallthrough
        case 4:print(num)
        case 5:print(num)
        default:break
        }
    }

    /*
     switch 自定義枚舉的時(shí)候锭部，如果保證所有的枚舉都列舉完成暂论，
     那么可以不必使用default來處理默認(rèn)情況
     */
    func associateEnumValue() {
        enum Answer{case right, wrong}
        let finishAnswer = Answer.right
        switch finishAnswer {
        case .right:print("answer result is \(finishAnswer)")
        case .wrong:print("answer result is \(finishAnswer)")
        }
    }

    /*
     switch case如何使用復(fù)合類型來判定
     */
    func moreTypeCase() {
        let string = "Jack"
        switch string {
        case "hello", "Lee", "Wang": print("rich man~")
        case "Jack": print("poor man~~")
        default: print("Not Found")
        }
    }

    /*
     Switch
     1. 使用區(qū)間Range進(jìn)行值匹配
     2. 使用元組進(jìn)行case匹配
     */
    func switchRangeCase() {
        let score = 45
        switch score {
        case 0..<60: print("Not Ok")
        case 60..<80: print("Just So So")
        case 80..<90: print("Good")
        case 90..<100: print("Woundful")
        default:print("So bad")
        }
        
        let infoMan = (84, "Good")
        switch infoMan {
        case let (cScore, cLevel): print("score\(cScore), level:\(cLevel)")
        case let (_, cLevel): print("level:\(cLevel)")
        default:break
        }
        
    }

• 值綁定

使用let = option case 進(jìn)行值綁定

    /*
     值綁定
     使用let = option case 進(jìn)行值綁定
     */
    func valueBind() {
        let point = (2, 0)
        switch point {
        case (let x, var y): print("x: \(x), y:\(y)")
        case (_, var y): print("x: -, y:\(y)")
        case (let x, _): print("x: \(x)")
        default:break
        }
    }

• 條件過濾where

    /*
     where 條件過濾
     */
    func whereFiliterUse() {
        var point = (1, 2)
        switch point {
        case (let x, let y) where x == y: print("y=x line in dicarl line")
        case (_, let y) where y==0: print("y line in dicarl line")
        case (let x, let y) where (x>0 && y>0): print("location is in first part view")
        default:break
        }
    }

• 標(biāo)簽語句 outer

    /*
     標(biāo)簽語句（通過outer標(biāo)簽語句能夠簡(jiǎn)化跳轉(zhuǎn)邏輯）
     outer：
     */
    func outerUse() {
        outer: for k in 1...4 {
                for j in 8...16 {
                    if j == 10 {
                        continue outer
                    }
                    if k == 3 {
                        break outer
                    }
                    print("k == \(k), j=\(j)")
                }
        }
    }

函數(shù)的定義

• 函數(shù)的隱式返回

對(duì)于只有一行的語句，可以省略返回return關(guān)鍵字拌禾，這種省去返回return關(guān)鍵字的操作叫做隱式返回.

    class FuncUse {
        //帶返回值
        static func pi() -> Double {
            return 3.14;
        }
        
        //加法
        static func sum(v1: Int, v2: Int) -> Int {
            return v1 + v2
        }
        
        //加法簡(jiǎn)化
        static func sumSlim(v1: Int, v2: Int) -> Int {v1+v2}
        
    }
    /*
     返回元組空另，實(shí)現(xiàn)多值返回
     */
    func tupleReturnUseTypeAlias() -> (userName: String, age: String, className: String) {
        (userName: "String", age: "String", className: "String")
    }
   

• 函數(shù)默認(rèn)參數(shù)值
  這里的方法參數(shù)設(shè)置與C++有點(diǎn)區(qū)別，
  C++中參數(shù)值有限制蹋砚，必須從右向左設(shè)置
  對(duì)于沒有設(shè)置默認(rèn)值的方法參數(shù)是不能夠省略的
  而Swift中由于存在參數(shù)標(biāo)簽扼菠，所以不用按順序進(jìn)行設(shè)置

例如下面的方法調(diào)用：
Swift：self.funcDefaultParamter(age: 28)
c++: self.funcDefaultParamter("lcc",28,"workMan")

func funcDefaultParamter(name: String = "lcc", age: Int, job: String = "none") {
        print("name:\(name), age:\(age), job:\(job)")
    }

• 可變參數(shù)(...)
  1. 可變參數(shù)在取值的時(shí)候使用遍歷取值
  2. 一個(gè)方法最多只有一個(gè)可變參數(shù)
  3. 緊跟可變參數(shù)后面的參數(shù)不能夠省略標(biāo)簽

    func moreParameterIngoreTag(_ numbers: Int..., eachItem: (Int)->()) -> Int {
        var sum = 0
        for item in numbers {
            eachItem(item)
            sum += item
        }
        return sum
    }
    
    func moreParamterUse(_ numbers: Int...) -> Int {
        var sum = 0
        for number in numbers {
            sum += number
        }
        return sum
    }

• 函數(shù)重載
  1. 返回值類型與函數(shù)重載沒有關(guān)系
  2. 默認(rèn)參數(shù)值與函數(shù)重載一起使用的時(shí)候如果產(chǎn)生歧義，編譯器不會(huì)報(bào)錯(cuò)坝咐，優(yōu)先調(diào)用匹配完全一致的方法

    func someFunc() {
        print("source func")
    }
    
    func someFunc(v1: Int, v2: Int) {
        print("change func use to sum: \(v1 + v2)")
    }
    
    func someFunc(v1: Int, v2: Int, v3 :Int = 20) {
        print("more parameter count: \(v1 + v2 + v3)")
    }

• 輸入輸出參數(shù) inout

可以在函數(shù)內(nèi)部調(diào)用外界的方法循榆，比較典型的范例就是通過元組實(shí)現(xiàn)兩個(gè)數(shù)字的交換

    //傻子方法
    func swapNum(numberOne: inout Int, numberTwo: inout Int) {
        let sourceTuple = (numberOne, numberTwo)
        let result = (sourceTuple.1, sourceTuple.0)
        numberOne = sourceTuple.1
        numberTwo = sourceTuple.0
        print("交換之前:\(sourceTuple), 交換之后\(result),numberOne:\(numberOne),numberTwo:\(numberTwo)")
    }
    
    //優(yōu)雅方法，使用元組直接能夠交互
    func swapNum(numberOne: inout Int, numberTwo: inout Int, des: String = "") {
        (numberOne, numberTwo) = (numberTwo, numberOne)
    }

• 內(nèi)聯(lián)函數(shù) @inline

在Swift編譯器中默認(rèn)是開啟自動(dòng)轉(zhuǎn)換內(nèi)聯(lián)函數(shù)的功能的實(shí)質(zhì)：將函數(shù)調(diào)用展開成函數(shù)體墨坚。
注意：
1. 函數(shù)體比較長(zhǎng)的不會(huì)被轉(zhuǎn)換成函數(shù)體
2. 遞歸調(diào)用不會(huì)轉(zhuǎn)換成函數(shù)體
3. 包含動(dòng)態(tài)派發(fā)不能夠轉(zhuǎn)換成函數(shù)體

    func buildToChange() {
        print("transform to me")
    }
    
    //關(guān)閉內(nèi)聯(lián)
    @inline(never) func inlineUse() {
        print("即使開啟編譯器優(yōu)化秧饮，也不會(huì)被內(nèi)聯(lián)")
    }
    
    //強(qiáng)制內(nèi)聯(lián)
    @inline(__always) func inlineOnAlways() {
        print("即使代碼段很長(zhǎng)，也會(huì)被內(nèi)聯(lián)泽篮，除了動(dòng)態(tài)派發(fā)的函數(shù)以及遞歸調(diào)用的函數(shù)外")
    }

• 函數(shù)類型

函數(shù)類型包含以下兩個(gè)重要組成:

1. 形式參數(shù)類型
2. 返回值類型

 func funcTest(parameter: String...) -> (String) {
        var strUnition = ""
        for str in parameter {
            strUnition.append(str)
        }
        return strUnition
    }
print(self.funcTest(parameter: "leo ", " is"," the", " best", " programmer"))

• 使用函數(shù)類型作為函數(shù)的參數(shù)進(jìn)行傳遞

1. @autoclosure的使用盗尸，對(duì)于沒有參數(shù)的函數(shù)作為參數(shù)的話可以添加@autocclosure關(guān)鍵字讓函數(shù)的調(diào)用更加簡(jiǎn)潔高效
2. 正常函數(shù)調(diào)用，如果將函數(shù)作為參數(shù)進(jìn)行傳遞的話帽撑，可以考慮使用$符獲取參數(shù)內(nèi)容

    func printSumResult(n1: Int, n2: Int, sumAdd: @autoclosure()->(Int)) {
        print(sumAdd())
    }
    
    func printSumResult(n1: Int, n2: Int, sumAdd: (Int, Int)->Int) {
        print(sumAdd(n1, n2))
    }

self.printSumResult(n1: 1, n2: 2, sumAdd: 3)
self.printSumResult(n1: 32, n2: 29) {$0+$1}
self.printSumResult(n1: 32, n2: 11) { (num1, num2) -> Int in num1 + num2}

• 使用函數(shù)作為返回值進(jìn)行傳遞操作
  返回值是函數(shù)類型的函數(shù)泼各，也叫做高階函數(shù)

    func returnFunUse() -> (Int, Int) -> Int {
        return {$0+$1}
    }

• 類型別名 typealias

typealias LCInt = Int
typealias LCFloat = Float
func typealiasUse(age: LCInt, score: LCFloat) {
    print("age:\(age), score:\(score)")
}

• 嵌套函數(shù)
  在函數(shù)中嵌套一個(gè)函數(shù)。

    func funcInFunc() -> ((String, Int) -> () , (Int, Int) -> (Int)) {
        func result(usrName: String, age: Int){
            print("I get your name:\(usrName), and your age:\(age)")
        }
        func countTwoSum(num1: Int, num2: Int) -> Int{num1 + num2}
        return (result, countTwoSum)
    }

    
     var (funcOne, funcTwo) = self.funcInFunc()
     funcOne("lcc", 25)
     print("count result:\(funcTwo(24, 64))")
     
     self.funcInFuncSignal()(1,3)

• 枚舉的基本用法

  1. 值類型枚舉
  2. 關(guān)聯(lián)值類型

將值類型成員與其他類型的值關(guān)聯(lián)在一起亏拉，可以起到關(guān)聯(lián)變量值存儲(chǔ)的作用扣蜻，在使用的枚舉逆巍，抽象表達(dá)某些功能的時(shí)候會(huì)變得異常方便

注意：值類型與關(guān)聯(lián)值類型的空間存儲(chǔ)區(qū)別
1. 如果枚舉是基本的值類型，那么枚舉在內(nèi)存空間的容量是固定的莽使，因?yàn)楸举|(zhì)存儲(chǔ)的是原始值锐极，默認(rèn)分配1個(gè)字節(jié)的空間內(nèi)容來進(jìn)行存儲(chǔ)
2. 如果枚舉是關(guān)聯(lián)類型的存儲(chǔ)，那么要根據(jù)枚舉的類型來確定其內(nèi)存空間的占用大小芳肌，通常選擇枚舉關(guān)聯(lián)值最大的為存儲(chǔ)空間灵再，還要加上原始值的存儲(chǔ)（1個(gè)字節(jié)），最終算出來的是其真實(shí)占用的空間大小

占用空間大小與實(shí)際內(nèi)存分配的大小區(qū)別

占用空間大小是通過當(dāng)前數(shù)據(jù)類型占用的空間大小累加的總和亿笤，而在實(shí)際分配過程中由于iOS系統(tǒng)通常會(huì)采用內(nèi)存對(duì)齊的方式去分配真實(shí)的空間翎迁，通常是8個(gè)字節(jié)的整數(shù)倍。所以由于內(nèi)存對(duì)齊的原因责嚷，在實(shí)際分配內(nèi)存上鸳兽，可能分配的空間大于實(shí)際所占用的內(nèi)存空間

    //以下實(shí)際占用了 32+1 = 33 個(gè)字節(jié)的空間大小掂铐，實(shí)際分配了40個(gè)字節(jié)的空間大小
    enum Password {
        case number(Int, Int, Int, Int)
        case other
    }
    
    //值類型罕拂，僅分配1個(gè)字節(jié)存儲(chǔ)原始值內(nèi)容
    enum Direction {
        case top, left, bottom, right
    }
    
    //關(guān)聯(lián)值類型
    enum LoadServerMethod {
        case LoadFirst(url: String)
        case LoadSecond(url: String)
        case LoadFinish(finish: (Any)->())
    }
    
    func testEnum() {
        let gogoUp = Direction.top
//        let requestServer = LoadServerMethod.LoadFirst(url: "http://www.baidu.com")
        let finishClosure = LoadServerMethod.LoadFinish { (data) in
            print("server data:\(data)")
        }
        
        switch gogoUp {
        
        case .top: print("top")
        case .left: print("left")
        case .bottom: print("bottom")
        case .right: print("right")
        }
        
        switch finishClosure{
        case .LoadFirst(let url): print("請(qǐng)求的地址:\(url)")
        case .LoadSecond(let url): print("請(qǐng)求的地址:\(url)")
        case .LoadFinish(let finish): finish(["data":"nil"]);
        }
    }
    

• 枚舉的用法
  枚舉成員可以使用相同的類型的默認(rèn)值進(jìn)行預(yù)先關(guān)聯(lián)，默認(rèn)設(shè)置的值叫做原始值全陨，枚舉原始值類型如果是Int爆班、String，Swift會(huì)默認(rèn)分配其原始值

func enmuSourceValue() {
        
        enum DefaultIntEnum: String{
            case top, left, bottom, right
        }
        
        enum TypeSource: Int{
            case age = 18
            case birth = 19701010
            case idCard = 00000000000
        }
        //打印出原始值
        print(DefaultIntEnum.top.rawValue)
        print(DefaultIntEnum.top)
    }

• 枚舉遞歸

1. 遞歸枚舉類似于函數(shù)的遞歸辱姨，是枚舉內(nèi)容本身調(diào)用枚舉本身
2. 遞歸枚舉可以用來按層級(jí)存儲(chǔ)關(guān)聯(lián)數(shù)值柿菩，在使用的時(shí)候結(jié)合業(yè)務(wù)
3. 一般使用遞歸函數(shù)配合來進(jìn)行switch..case的判定

func indirectEnum() {
        enum AirthExpr {
        case number(Int)
        indirect case sum(AirthExpr, AirthExpr)
        indirect case difference(AirthExpr, AirthExpr)
        }
        
        func traverseEnum(airthNum: AirthExpr) -> Int {
            switch airthNum {
            case .number(let num): return num
            case let .sum(airthExpOne, airthExpTwo): return traverseEnum(airthNum: airthExpOne) + traverseEnum(airthNum: airthExpTwo)
            case let .difference(airthExpOne, airthExpTwo): return traverseEnum(airthNum: airthExpOne) - traverseEnum(airthNum: airthExpTwo)
            }
        }
        
        let five = AirthExpr.number(5)
        let four = AirthExpr.number(4)
        let sumAdd = AirthExpr.sum(five, four)
        let diffEnum = AirthExpr.difference(five, four)
        print("add result :\(traverseEnum(airthNum: sumAdd))")
        print("different result :\(traverseEnum(airthNum: diffEnum))")
    }

• 可選類型
  聲明某個(gè)變量為可選，直接在變量的類型后面添加?即可
  對(duì)于可選類型的變量或者常量雨涛，有兩種方式可以拿到其原始值：
  1. 強(qiáng)制解包
  2. 可選鏈操作

可選可以理解為一層包裝盒子枢舶，盒子里裝的是真實(shí)數(shù)據(jù)

1. 如果為nil，那么它是一個(gè)空盒子
2. 如果非nil替久，那么盒子裝的就是被包裝的數(shù)據(jù)

!是強(qiáng)制解包的標(biāo)識(shí)符凉泄，如果對(duì)nil的可選類型進(jìn)行強(qiáng)制解包，將會(huì)產(chǎn)生運(yùn)行時(shí)錯(cuò)誤（Fatal error：...）

注意：
數(shù)組返回的數(shù)值不是可選類型的數(shù)值蚯根，因?yàn)楫?dāng)數(shù)組越界的時(shí)候就已經(jīng)發(fā)生崩潰后众，并不能拿到帶有歧義的數(shù)值（nil或者有數(shù)值)，而字典獲取的數(shù)值為可選數(shù)值

    func unwrappTypeUse() {
        var age: Int?
        //直接相加由于age是可選類型所以會(huì)報(bào)錯(cuò)
//        age+=10
        //通過!來進(jìn)行強(qiáng)制解包
        print(age!+=10)
    }

• 解包之可選綁定

1. 如果包含內(nèi)容就自動(dòng)解包颅拦，把可選內(nèi)部包裝的值賦值給一個(gè)臨時(shí)變量 var 或者常量 let蒂誉，并返回 true， 否則返回false
2. 如果存在多個(gè)值距帅，可選綁定可以通過逗號(hào)分開右锨，注意不能使用&&分割

func unwrappingBindUse() {
        let num: Int? = 10
        let addTo: Int? = nil
        if let tmpNum = num,
           let _ = addTo{
            print("含有內(nèi)容:\(tmpNum)")
        }   
    }

• while 使用可選綁定

    /*
     while中使用可選綁定
     遍歷數(shù)組，將遇到的整數(shù)都加起來碌秸，如果遇到復(fù)數(shù)或者非數(shù)字陡蝇，停止遍歷
     */
    func bindLetWhileLoop() {
        let strs = ["10", "20", "abc", "-20", "30"]
        var index = 0
        var sum = 0
        
        while let num = Int(strs[index]), num > 0 {
            sum += num
            index += 1
        }
        
        print("運(yùn)算結(jié)果:\(sum)")
    }

• 合并空運(yùn)算符 ??

1. 被修飾的是可選類型
2. 合并的備選常量或者變量與被修飾的類型要保持一致
3. 如果備選不是可選類型痊臭，返回的時(shí)候會(huì)自動(dòng)進(jìn)行解包操作

注意：
空合并運(yùn)算符（??）是如何實(shí)現(xiàn)的？為什么在返回默認(rèn)值的時(shí)候要使用閉包來實(shí)現(xiàn)登夫，直接返回默認(rèn)內(nèi)容不可以嗎广匙？
1. 包裝了一個(gè)函數(shù)里面實(shí)現(xiàn)的public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T
2. 內(nèi)部實(shí)現(xiàn)使用了switch判定類似于以下的操作，使用運(yùn)算符重載操作

運(yùn)算符重載??實(shí)現(xiàn)可能如下:

    func ??<T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T{
        switch optional {
        case .some(let optional): return optional
        case .none: return try!defaultValue()
        }
    }

• 多個(gè)空合并運(yùn)算符??一起使用

    /*
     多個(gè) ?? 一起使用
     */
    func mutiDefaultValueUse() {
        let a: Int? = 1
        let b: Int? = 2
        let c = a ?? b ?? 3 //c是Int恼策，1
        
        let d: Int? = nil
        let e: Int? = 2
        let f = d ?? e ?? 3 //f是Int鸦致， 2
    }

• ??與if let配合使用

    /*
     ?? 與 if let 配合使用
     等同于 if a! = nil || n != nil
     */
    func defaultWithChooseBind() {
        let a: Int? = nil
        let b: Int? = 2
        if let c = a ?? b {
            print("result--->\(c)")
        }
    }

• guard 語句

1. 當(dāng)guard語句條件為false時(shí)，會(huì)執(zhí)行大括號(hào)里面的內(nèi)容涣楷，否則正常執(zhí)行
2. guard時(shí)候提前過濾不滿足當(dāng)前方法或者函數(shù)執(zhí)行的條件
3. 當(dāng)使用guard語句進(jìn)行可選綁定的時(shí)候分唾，綁定的常量let、變量var也會(huì)在外層作用域使用

    func guardUseStatement(age: Int, level: Int) {
        guard age > 18, level > 50 else {
            print("未成年人禁止瀏覽")
            return
        }
        print("一起看動(dòng)畫片啊~")
    }

• 隱式解包

1. 某些情況下狮斗，有些可選類型變量一開始設(shè)定就直接有值
2. 在確定可選類型內(nèi)容一直有值的情況下绽乔，可以通過在變量后面添加！的方法去除類型檢查
3. 去除類型檢查之后碳褒，每次獲取的可選類型變量將會(huì)隱式進(jìn)行解包取出其中包含的數(shù)值

    func unwrappingValueUse() {
        var num: Int! = 10
        var choose: Int? = 20
        print("隱式解包\(num)")
        print("強(qiáng)制解包\(choose!)")
    }

• 字符串查值

 func strDesprint() {
        let age: Int? = 10
        print("age:\(age ?? 0)") //這樣打出來的內(nèi)容是可選類型
        print("ageDes:\(String(describing: age))")
    }

• 多重可選項(xiàng)
  多重可選項(xiàng)可以理解為多重可選的包裝折砸，在取值的時(shí)候需要格外注意，要分層取值沙峻。

    func moreUnwrappingValue() {
        let num: Int? = 10
        let userone: Int?? = 20 //被包裝了兩次睦授，解包的時(shí)候需要解包兩次才行
        let userTwo: Int??? = 30 //道理同上
        
        let numValue = num!
        let userOneValue = userone!!
        let userTwoValue = userTwo!!!
        print("當(dāng)前內(nèi)容:\(numValue), \(userOneValue), \(userTwoValue)")
        
    }