Swift学习笔记(元组/可选类型)

元组

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

//创建一个元组
let http = (404,"not Found",true,"prf")
print(http)//输出结果是:(404, "not Found", true, "prf")

//元组的的内容还可以被分解
let (a,b,c,d) = http
print(a)
print(b)
print(c)
print(d)

//如果在分解的时候,只需要用到其中一部分元组的值,则不需要的用到的部分用`_`来代替
let (x,y,_,_) = http
print(x,y)

/*还可以通过下标来访问元组中的指定位置的元素,
原理有点像OC中的数组,例如我要访问元组http中第二位元素*/
print(http.1)

//在定义元组的时候,还可以为它其的元素命名
let dog = (name:"泰迪",age:2)
print(dog.name,dog.age)//然后还可以通过元组的元素名字来访问它,这又有点像访问一个对象的属性一样

元组的使用场景

作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个 (Int, String) 元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考函数参数与返回值。

注意：
元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考类和结构体。

可选类型

在Swift中,可选值是用来处理值可能缺失的情况,在C和OC中都没有这种概念,不过它又和OC中的函数返回值概念有点像,例如一个函数要不返回一个值,要不返回一个nil,然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。

//定义一个常量字符串
let possibleNumber = "123"
/*通过Int构造器将其转化成Int类型,并不是每一个字符串都可以转化成Int类型
字符串 "123" 可以被转换成数字 123 ，但是字符串 "hello, world" 不行。*/
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"

以上代码,因为构造器返回的结果可能失败,所以它返回一个可选类型（optional）Int 或者Int?，而不是一个 Int。一个可选的 Int 被写作 Int? 而不是 Int。问号暗示包含的值是可选类型，也就是说可能包含 Int 值也可能不包含值。（不能包含其他任何值比如 Bool 值或者 String 值。只能是 Int 或者什么都没有。）

//1).原始的可选值定义
//  Optional是一个枚举,里面有两个值,none:没有值,some 某一类值
let x:Optional = 10
//输出结果:Optional(10) ,提示程序员这是一个可选值
print(x)  

//2).简单定义
//Int? 用来表示 y 是一个可选的Int类型,可能是没有,可能是一个Int类型
let y:Int? = 20
//输出结果:Optional(20)
print(y)

print(x + y)//这种写法会报错
print(x! + y!)//正确写法

//1>不同类型之间不能直接运算,如果没有值不能参与运算所以不能直接( x + y)
//2>`!`强行解包-从可选值中,强行获取非空值(非nil,如果最后只能得到nil运行会崩溃);

//可以给可选值变量赋值为nil
var  name : String? = "prf"
name  = nil //这个时候,name里就不包含值了
/*注意：nil不能用于非可选的常量和变量。
如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。*/

常见错误

//常见错误1
let y:Int?
print(y)//这是编译会报错,提示常量y,没有初始化

//常见错误2
let x: Optional = 10
let y: Int? = 20
print(x! +y!)
//运行会崩溃
//原因:Unexpectedly found nil while unwrapping an Optional value
//在强行解包可选值时,发现值为nil

if 语句以及强制解析

//可以使用 if 语句和 nil 比较来判断一个可选值是否包含值
let x:Optional = 10
 if  x != nil {
       print("x is contains some integer value")
     }
        
let y:Int? = nil
if y == nil {
       print("y is nil")
     }

可选绑定(Optional binding)

可选绑定可以用来判断可选类型是否包含值,如果包含就把值赋给一个临时常量或者变量。

let possibleNumber = "123"
if let actualNumber = Int(possibleNumber) {
    print("\'\(possibleNumber)\' has an integer value of \(actualNumber)")
} else {
    print("\'\(possibleNumber)\' could not be converted to an integer")
}
// 输出 "'123' has an integer value of 123"

隐式解析可选类型

可选类型暗示了常量或者变量可以“没有值”。可选可以通过 if 语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。

有时候(并不总是)在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。

这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选类型。

当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考无主引用以及隐式解析可选属性。

一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型 String 和隐式解析可选类型 String 之间的区别：

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号来获取值

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString  // 不需要感叹号
//是在不能理解苹果为什么会推出一个这样的东西有点多余
//从书写上仅仅感觉是为了后面不用不断地写!而已