隐式解包装可选(IUO)

它是Optional的一种语法糖，不会强制程序员打开变量。它可以用于在两阶段初始化过程中不能初始化的变量，并暗示非nil。这个变量本身表现为非nil，但实际上是一个可选变量。一个很好的例子是- Interface Builder的outlet

可选的通常更可取

var implicitlyUnwrappedOptional: String! //<- Implicitly Unwrapped Optional
var nonNil: String = ""
var optional: String?

func foo() {
    //get a value
    nonNil.count
    optional?.count
    
    //Danderour - makes a force unwrapping which can throw a runtime error
    implicitlyUnwrappedOptional.count
    
    //assign to nil
//        nonNil = nil //Compile error - 'nil' cannot be assigned to type 'String'
    optional = nil
    implicitlyUnwrappedOptional = nil
}

如果你确定从可选对象返回值而不是nil，隐式解包装可选对象用于直接从可选对象捕获这些值，而非可选对象则不能。

//Optional string with a value
let optionalString: String? = "This is an optional String"

//Declaration of an Implicitly Unwrapped Optional String
let implicitlyUnwrappedOptionalString: String!

//Declaration of a non Optional String
let nonOptionalString: String

//Here you can catch the value of an optional
implicitlyUnwrappedOptionalString = optionalString

//Here you can't catch the value of an optional and this will cause an error
nonOptionalString = optionalString

这就是使用的区别

let someString:字符串!然后让someString: String

考虑一个对象在构造和配置时可能具有nil属性，但在构造和配置后是不可变的且非nil的情况(NSImage通常是这样处理的，尽管在这种情况下，有时改变仍然是有用的)。隐式地打开可选选项可以很好地清理代码，而且安全性损失相对较低(只要有一个保证，它就是安全的)。

(编辑)需要明确的是:常规的可选选项几乎总是更可取的。

一行(或几行)简单的示例并不能很好地涵盖可选项的行为——是的，如果你声明一个变量并立即为它提供一个值，那么可选项就没有意义了。

到目前为止我见过的最好的情况是在对象初始化之后发生的设置，然后是“保证”在该设置之后的使用，例如在视图控制器中:

class MyViewController: UIViewController {

    var screenSize: CGSize?

    override func viewDidLoad {
        super.viewDidLoad()
        screenSize = view.frame.size
    }

    @IBAction printSize(sender: UIButton) {
        println("Screen size: \(screenSize!)")
    }
}

我们知道printSize将在视图加载后被调用——它是一个连接到视图内控件的操作方法，并且我们确保不会以其他方式调用它。因此，我们可以使用!来节省一些可选的检查/绑定。Swift不能识别这个保证(至少在Apple解决停止问题之前)，所以你告诉编译器它存在。

不过，这在一定程度上破坏了类型安全。如果你的“保证”并不总是有效，那么任何你拥有隐式展开可选选项的地方都可能导致应用崩溃，所以这是一个需要谨慎使用的功能。此外，使用!总是让人觉得你在大喊大叫，没人喜欢这样。

隐式打开可选选项对于将属性表示为非可选属性非常有用，而实际上它需要是可选的。这通常是在两个相关对象(每个对象都需要对另一个对象的引用)之间“打结”所必需的。当两个引用实际上都不是可选的，但在初始化pair时，其中一个引用需要为nil时，这是有意义的。

例如:

// These classes are buddies that never go anywhere without each other
class B {
    var name : String
    weak var myBuddyA : A!
    init(name : String) {
        self.name = name
    }
}

class A {
    var name : String
    var myBuddyB : B
    init(name : String) {
        self.name = name
        myBuddyB = B(name:"\(name)'s buddy B")
        myBuddyB.myBuddyA = self
    }
}

var a = A(name:"Big A")
println(a.myBuddyB.name)   // prints "Big A's buddy B"

任何B实例都应该有一个有效的myBuddyA引用，所以我们不想让用户把它当作可选的，但是我们需要它是可选的，这样我们就可以在有a引用之前构造一个B。

然而!这种相互引用需求通常是紧耦合和糟糕设计的标志。如果您发现自己依赖于隐式展开的可选项，那么您可能应该考虑重构以消除交叉依赖。

我认为Optional是这个结构的一个不好的名字，它会让很多初学者感到困惑。

其他语言(例如Kotlin和c#)使用术语Nullable，这使它更容易理解。

Nullable意味着可以将空值分配给这种类型的变量。如果它是Nullable<SomeClassType>，你可以给它赋空值，如果它只是SomeClassType，你不能。这就是Swift的工作方式。

为什么要使用它们?有时候你需要空值，这就是原因。例如，当您知道希望在类中有一个字段时，但是在创建该类的实例时不能将其分配给任何东西，但稍后会这样做。我就不举例子了，因为人们已经在这里提供了例子。我写这些只是为了表达我的意见。

顺便说一句，我建议你看看这在其他语言中是如何工作的，比如Kotlin和c#。

下面是Kotlin中解释这一特性的链接: https://kotlinlang.org/docs/reference/null-safety.html

其他语言，如Java和Scala确实有可选选项，但它们的工作方式与Swift中的可选选项不同，因为Java和Scala的类型默认都是可空的。

总而言之，我认为这个功能应该在Swift中被命名为Nullable，而不是Optional…