Optional可选型

1.什么是可选型
2.为什么要有可选型
3.可选型的使用
4.可选型的本质
5.?与!与??

什么是Optional

可选型(Optional)是Swift中的一种类型,或者称之为一种类型的类别,用来指定某个实例可能没有值,即要么有值并且可用,要么没有值,即为nil.

在swift中,只有一个实例对象是可选型才可以作为空值(nil),或者对其置空.
任何一种类型都可以作为可选型,甚至是元组或者可选型本身.
swift不允许使用未进行初始化的变量,所以变量都没有默认值,而只有可选型例外,它的默认值为nil

为什么要有可选型

程序开发中,多数语言都有nil的出现,导致程序异常退出.所以我们经常会做各种各样的判断,来避免对一个空值进行非法访问.
在C语言中,经常用-1来表示一个操作失败,Objective-c中查找字符串的内容使用了NSNotFound(本质是一个最大的数)来表示未查找到.称这些值为一个哨兵也不为过(Swift进阶).
举例说明:

    NSString *string = nil;
    if( [string rangeOfString:@"a"].location != NSNotFound){
        NSLog(@"contain");
    }else{
        NSLog(@"not contain");
    }

执行打印结果为"contain"
因为在Objective-c中,我们对一个nil发送消息,是安全的什么也不会发生.如果消息返回一个对象,那么nil会被返回,如果是数值类型,那么返回0,如果是结构体,那么它的值都会被初始化为0.所以哨岗值很容易导致无法预期的错误.
Swift号称是更加安全的语言,当然一部分来自于可选型的加入,一个实例没有被声明为可空类型,它就不可能是nil;通过这种方式，编译器知道一个实例是否可能为nil 。这种显式声明可以让代码更具表达能力，也更安全.

可选型的使用

声明一个可选型使用?或者!紧跟类型后面,不可以有空格

    var option:Int?  = "abc"
    option = nil

!表示为隐式可选型,在后面会进行叙述.
使用可选型的值我们需要对其进行解包,解开的方式也有很多种

if判断
隐式解包
强制解包
可选绑定
??空合运算符

//1.
if option != nil{
   //do something
}

//2.?
//如果值为nil将什么也不发生
option?var

//3. !当为nil,会导致程序异常退出
option!

可选绑定

optional binding是一种固定模式，对于判断可空实例是否有值很有用。如果有值，就将其赋给一个临时常量或变量，并且使这个常量或变量在条件语句的第一个分支代码中可用。这样可以让代码更简洁，同时保持表达力。

if let value = optional{
    //有值  do some
    }else{
    //没有值nil
}

当然可选实例绑定可以进行嵌套,当遇到多个可选型,嵌套可空实例绑定可能会显得错综复杂。就像是金字塔一样,所以单个if let绑定就可以展开多个可空实例.
可空链式调用（optional chaining）提供了一种对可空实例进行查询以判断其是否包含值的机制。两者的一个重要区别是，可空链式调用允许程序员把多个查询串联为一个可空实例的值。如果链式调用中的每个可空实例都包含值，那么每个调用都会成功，整个查询链会返回期望类型的可空实例

if let error = errorStr{
   if let code = Int(error){
    //......
    }
}

//更优雅
if let error = errorStr,code = Int(error){
   //.....
}

当然也可以使用guard,while(不常用).guard语句的Optional绑定与if语句类似，区别有两个，一个就是guard语句与if语句本身的语义区别；还有一个是guard语句中声明的对象是处于guard语句所在的作用域的，而不仅限于guard语句块作用域。所以guard语句的Optional绑定在实际项目中可能会用得更多些，因为它更加便利。可将其声明的拆解掉Optional的对象将之前所声明的Optional对象标识给完全覆盖掉。

var a = Int?(0)
//覆盖同名变量
guard let a = a else{
   return
}
a += 10

可选型的本质

可选型实际是一个泛型枚举,遵循ExpressibleByNilLiteral协议(nil字面量),我们可以显示的声明一个Optional.

var website: Optional<String> = Optional.some("www.baidu.com")
print(website)

website = Optional.none
print(website)

当然也可以点击查看其声明

public enum Optional<Wrapped> : ExpressibleByNilLiteral {
    case none
    case some(Wrapped)
.....
}

?与!与??

?

?语法糖其实就是简化了声明和赋值

var optional:Optional<Int>
//等同于var optional:Int?
//赋值时 等同于optional = nil
optional = Optional<Int>.none
optional = Optional<Int>.some(5)
//等同于optional = 5

在声明或者赋值一个Optional的变量时，?语法糖做的事情就是声明一个Optional<T>，然后查看等号右边是不是nil这个标记值。如果不是，则使用 init(_ some: T)用等号右边的类型T的值生成一个 .some枚举并赋值给这个Optional 变量,如果是nil，将其赋为none枚举。
? 放在某个Optional 变量后面，表示对这个变量进行判断，并且隐式地unwrap

optional?.distance(to: 10)
//相当于
if let value = optional{
value.distance(to: 10)
}

更存在价值的地方在于可以链式调用，也就是所谓的 Optional Chaining，这样可以避免一大堆的条件分支，而使代码变得易读简洁。
? 放在某个 optional 的 protocol (Objective-C)方法的括号前面，以表示询问是否可以对该方法调用

!

! 放在Optional变量的后面，表示强制的 unwrap 转换：
使一个 Optional<T> 的量被转换为 T。特别注意，如果这个 Optional 的量是 nil 的话，这种转换会在运行时让程序崩溃.

func !<T>(value:Optional<T>) -> T{
switch value{
     case .none:
     fatalError("error:nil")
     case .some(v):
     return v
   }
}

!放在类型后面,隐式解析可选类型,表示强制的隐式转换。是一个类型声明的语法糖。?声明的是Optional，而!其实声明的是一个ImplicitlyUnwrappedOptional(deprecated)类型。会在使用的时候自动地去unwrap，继续之后的操作调用，而不必去增加一次手动的显示/隐式操作。隐式解析可选类型依然是一个可选类型，可选类型的特性它同样适用，只是注意，当隐式解析可选项值为 nil 的时候解析取值，会运行出错。如果一个变量之后可能变成nil的话请不要使用隐式解析可选类型。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。

??nil-coalescing operation 空和运算符

??提供一个默认值,当一个可选型为nil时,使用该值,否则就是其解包后的值

var optional:Int? = nil
optional ?? 5

觉得似曾相识,跟三目运算符差不多,用三目运算符可以对其改写即optional != nil ? optional! : 5,那么他和三目运算一样吗?肯定不一样,如果?前面后面是一个比较耗时繁琐的操作,那么效率就会很差.
我们可以在可选型的定义中查看该操作符的定义.

public func ??<T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T

至于这里为什么使用了自动闭包,我们可以大致实现其逻辑,使用了闭包我们就可以达到短路的效果,当值不是nil时,避免不必要的计算.

public func ??<T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T{
if let value = optional{
       return value
   }else{
       return defaultValue()
   }
}

??用于声明类型或者更多个???....

当声明一个变量做类型标注时可能会遇到多个??,其实就是嵌套可选型,需要我们进行多次解包,就好像盒子里面又是一个盒子..

let number: Int??? = 10
print(number)
// Optional(Optional(Optional(10)))

解包也有多种方式


let number: Int??? = 10

//暴力拆解型
print(number!!!)

//嵌套地狱型
if let number = number {
if let number = number {
if let number = number {
print(number)
}
}
}

//可选绑定
if let n1 = number,
let n2 = n1,
let n3 = n2 {
print(n3)
}

func printNumber(_ number: Int???) {
guard let n1 = number, let n2 = n1, let n3 = n2 else {
return
}
print(n3)
}

参考链接

聊聊swift语言中的“??”
行走于 Swift 的世界中

可选型Optional