1.2、【Swift】基础语法（元祖、可选类型、nil、强制解析、可选绑定、隐式解包）

元组（tuples）

• 场景：可将不同数据类型，但同一个功能业务接口的数据，集合在一起

• 元组内的值可以是任意类型，并不要求是相同类型。

  let http404Error = (404, "Not Found")
  // http404Error 的类型是 (Int, String)，值是 (404, "Not Found")
  

• 将一个元组的内容分解（decompose）成单独的常量和变量

let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// 输出“The status code is 404”
print("The status message is \(statusMessage)")
// 输出“The status message is Not Found”

• 用下划线（_）,忽略不需要的值

  let (justTheStatusCode, _) = http404Error
  print("The status code is \(justTheStatusCode)")
  // 输出“The status code is 404”
  

• 下标访问（下标从零开始）

  print("The status code is \(http404Error.0)")
  // 输出“The status code is 404”
  print("The status message is \(http404Error.1)")
  // 输出“The status message is Not Found”
  

• 定义元祖-给元素命名

let http200Status = (statusCode: 200, description: "OK")

• 命名后的访问

print("The status code is \(http200Status.statusCode)")
// 输出“The status code is 200”
print("The status message is \(http200Status.description)")
// 输出“The status message is OK”

• 使用场景：函数的 多个返回值。[ 函数参数与返回值]（#函数参数与返回值）

元组不适合创建复杂数据结构, 可用类或结构体去建模。

---

可选类型

• 场景：表示该变量/常量，可能有值，可能没值

• 可选类型（optionals）处理值可能缺失

• C 和 Objective-C 没有可选类型这个概念, OC对象用nil，基本数据类型用特殊值（比如 NSNotFound）
• Swift 的可选类型，适用于任意类型

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"

• 因构造器可能会失败，所以返回可选类型（optional）Int，而不是 Int。
• 问号暗示表示值为可选类型，可能包含 Int 值，可能不包含值。（不能包含其他类型值，如 Bool 值或 String 值。只能是 Int ，或什么都没有。）

nil

• 场景：可选类型的一个值，表示没有值/值缺失

• 可以给可选变量赋值为 nil 来表示它没有值：

var serverResponseCode: Int? = 404
// serverResponseCode 包含一个可选的 Int 值 404
serverResponseCode = nil
// serverResponseCode 现在不包含值

非可选类型的常量和变量，不能赋值nil。

• 声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil：

var surveyAnswer: String?
// surveyAnswer 被自动设置为 nil

Swift和OC的nil的区别：

• OC ，nil为指针, 指向不存在的对象（只能用于对象类型，不能基本数据类型）
• Swift，nil是一个值（能用于任意类型）

if 语句 + 强制解析

• 场景：只判断可选项是否为空值，不解包

• if 语句和 nil 比较来判断一个可选值是否包含值

• 使用“相等”(==)或“不等”(!=)来执行比较

• 可选类型有值，它将不等于 nil：

  if convertedNumber != nil {
      print("convertedNumber contains some integer value.")
  }
  // 输出“convertedNumber contains some integer value.”

• 强制解析/解包（forced unwrapping）：确定有值，可在后面加一个感叹号（!）取值。

如果没有值，强制解包会报运行时错误.

if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
}
// 输出“convertedNumber has an integer value of 123.”

可选绑定（optional binding）

• 场景：判断可选类型是否有值，并解包使用

• 可选绑定：判断是否有值 --> 有值 --> 解包 + 赋值到常量/变量

• if 和 while 都可以

// MARK:- 可选绑定 - if
if let atualNumber = Int(possibleNumber) {
    print("if - Int()转换成功, \(atualNumber)")
} else {
    print("if - Int()转换失败")
}
// MARK:- 可选绑定 - while
while let atualNumber = Int(possibleNumber1) {
    print("while - Int()转换成功, \(atualNumber)")
}

• 一个 if 语句，可包含多个可选绑定或多个布尔条件，用逗号隔开
• 任一可选绑定的值为 nil，或任一布尔条件为 false，整个 if 条件判断为 false

// MARK:- 可选绑定和布尔条件混用
if let firstNumber = Int("4"),
   let secondNumber = Int("42"),
   firstNumber < secondNumber && secondNumber < 100  {
     
    print("--------------------")
    print("\(firstNumber) < \(secondNumber) < 100")
    print("--------------------")
}

// MARK:- 等价于上面
if let firstNumber = Int("4") {
    if let secondNumber = Int("42") {
        if firstNumber < secondNumber && secondNumber < 100 {
            
            print("--------------------")
            print("\(firstNumber) < \(secondNumber) < 100")
            print("--------------------")
        }
    }
}

• if 条件语句创建可选绑定，if 语句中（body）中才能获取到值
• guard 语句中创建一个可选绑定，在 guard 语句外且在语句后才能获取到值

隐式解析可选类型/隐式解包（implicitly unwrapped optionals）

• 场景：保留可为 nil，变量/常量明确有值时，减少判断，自动强制解包/解析
• 声明方式：可选的类型的后面的问号（String?）改成感叹号（String!）（相当于把强制解包操作，提前使用）
• 隐式解析可选类型，主要被用在 Swift 中类的构造过程中，请参考 无主引用以及隐式解析可选属性。

// MARK:- 可选类型 String 和隐式解析可选类型 String 之间的区别
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号来获取值
let possibleString1: String! = "An optional string."
// possibleString1 = nil  // 保留可选类型,可以为nil的特性
let forcedString1: String = possibleString1 // 不需要感叹号

// MARK:- 隐式可选项 -  判断是否有值(跟普通可选类型一样)
if possibleString1  !=  nil {
    print(possibleString1!)
}

// MARK:- 隐式可选项 -  可选项绑定 (跟普通可选类型一样)
if let definiteString =  possibleString1 {
    print(definiteString)
}