{
//        可选项，一般也叫可选类型，它允许将值设置为nil n在类型名称后面加个问号? 来定义一个可选项
        var name: String? = "Jack"
        name = nil
        var age: Int? // 默认就是nil age = 10
        age = nil
        var array = [1, 15, 40, 29]
        func get(_ index: Int) -> Int? {
            if index < 0 || index >= array.count {
                return nil
        }
            return array[index]
        }
        print(get(1)) // Optional(15)
        print(get(-1)) // nil
        print(get(4)) // nil

        
//        强制解包(Forced Unwrapping)
//        可选项是对其他类型的一层包装，可以将它理解为一个盒子 p如果为nil，那么它是个空盒子 p如果不为nil，那么盒子里装的是:被包装类型的数据
        var age1 : Int? // 默认就是nil
        age = 10
        age1 = nil
//        n如果要从可选项中取出被包装的数据(将盒子里装的东西取出来)，需要使用感叹号! 进行强制解包
        var age2 : Int? = 10
        let ageInt : Int = age!
                
//        如果对值为nil的可选项(空盒子)进行强制解包，将会产生运行时错误 Fatal error: Unexpectedly found nil while unwrapping an Optional value
        
        var age3 : Int?
//        age3! //Fatal error: Unexpectedly found nil while unwrapping an Optional value
          
         
//        判断可选项是否包含值
         let number = Int("123")
        if number != nil {
            print("字符串转换整数成功:\(number!)")
            
        } else {
            print("字符串转换整数失败")
            
        }
        // 字符串转换整数成功:123

//        可选项绑定(Optional Binding)
//        可以使用可选项绑定来判断可选项是否包含值 p如果包含就自动解包，把值赋给一个临时的常量(let)或者变量(var)，并返回true，否则返回false
        if let number = Int("123") {
            print("字符串转换整数成功:\(number)") // number是强制解包之后的Int值
        // number作用域仅限于这个大括号
        } else {
            print("字符串转换整数失败")
        }
        
        // 字符串转换整数成功:123
        enum Season : Int {
            case spring = 1, summer, autumn, winter
        }
        
        if let season = Season(rawValue: 6) {
            switch season {
                case .spring:
                    print("the season is spring")
                default:
                    print("the season is other")
            }
        } else {
            print("no such season")
        }// no such season
         
         
//        等价写法
         if let first = Int("4") {
            if let second = Int("42") {
                if first < second && second < 100 {
                    print("\(first) < \(second) < 100")
                }
            }
        }
        // 4 < 42 < 100
         if let first = Int("4"),
            let second = Int("42"),
            first < second && second < 100 {
            print("\(second) < \(second) < 100")
        }
        // 4 < 42 < 100
        
//        while循环中使用可选项绑定
         // 遍历数组，将遇到的正数都加起来，如果遇到负数或者非数字，停止遍历
        var 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(sum)

//        空合并运算符 ??(Nil-Coalescing Operator)
//         public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?
//         public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T
//        a ?? b
//        a 是可选项
//        b 是可选项 或者 不是可选项
//        b 跟 a 的存储类型必须相同
//        如果 a 不为nil，就返回 a
//        如果 a 为nil，就返回 b
//        如果 b 不是可选项，返回 a 时会自动解包
        func ppf_test1() {
            let a: Int? = 1
            let b: Int? = 2
            let c = a ?? b // c是Int? , Optional(1)
        }
        
        func ppf_test2() {
            let a: Int? = 1
            let b: Int = 2
            let c = a ?? b // c是Int , 1
        }
        
        func ppf_test3() {
            let a: Int? = nil
            let b: Int = 2
            let c = a ?? b // c是Int , 2
        }
        
        func ppf_test4() {
            let a: Int? = nil
            let b: Int? = 2
            let c = a ?? b // c是Int? , Optional(2)
        }
        
        func ppf_test5() {
             let a: Int? = nil
            let b: Int = 2
            // 如果不使用??运算符
            let c: Int
            if let tmp = a {
                c = tmp
            } else {
                c=b
            }
            
            let a1: Int? = nil
            let b1: Int? = nil
            let d = a1 ?? b1 // d是Int? , nil
            print(d)
        }
        
        // 多个 ??
        func ppf_test6() {
            let a: Int? = 1
           let b: Int? = 2
           let c = a ?? b ?? 3 // c是Int , 1
        }
        
        func ppf_test7() {
            let a: Int? = nil
            let b: Int? = 2
            let c = a ?? b ?? 3 // c是Int , 2
        }
        
        func ppf_test8() {
            let a: Int? = nil
            let b: Int? = nil
            let c = a ?? b ?? 3 // c是Int , 3
        }

//        ??跟if let配合使用
        func ppf_test9() {
            let a: Int? = nil
            let b: Int? = 2
            if let c = a ?? b {
                print(c)
            }// 类似于if a != nil || b != nil
            
            if let c = a, let d = b
            {
                print(c)
                print(d)
            }// 类似于if a != nil && b != nil
        }
        
//        guard语句
//        当guard语句的条件为false时，就会执行大括号里面的代码 当guard语句的条件为true时，就会跳过guard语句
//        guard语句特别适合用来“提前退出”
//        当使用guard语句进行可选项绑定时，绑定的常量(let)、变量(var)也能在外层作用域中使用
        func login(_ info: [String : String]) {
            guard let username = info["username"] else {
                print("请输入用户名")
                return
            }
            guard let password = info["password"] else {
                print("请输入密码")
                return
            }
        // if username ....
        // if password ....
            print("用户名:\(username)", "密码:\(password)", "登陆ing")
        }
        
//        guard 条件 else {
        // do something....
//        退出当前作用域
        // return、break、continue、throw error
//        }
        
//        隐式解包(Implicitly Unwrapped Optional)
//        在某些情况下，可选项一旦被设定值之后，就会一直拥有值
//        在这种情况下，可以去掉检查，也不必每次访问的时候都进行解包，因为它能确定每次访问的时候都有值 n 可以在类型后面加个感叹号 ! 定义一个隐式解包的可选项
        let num1: Int! = 10
        let num2: Int = num1
        if num1 != nil {
            print(num1 + 6) // 16
        }
        if let num3 = num1 {
            print(num3)
        }
         let num3: Int! = nil
        // Fatal error: Unexpectedly found nil while implicitly unwrapping an Optional value
        let num4: Int = num3
         
        
//        字符串插值
//        n 可选项在字符串插值或者直接打印时，编译器会发出警告
         var age4 : Int? = 10
        print("My age is \(age4)")
//        n 至少有3种方法消除警告
         print("My age is \(age4!)")
        // My age is 10
         print("My age is \(String(describing: age4))")
        // My age is Optional(10)
         print("My age is \(age4 ?? 0)")
        // My age is 10
        

    }