隐式可选项的基本原理很容易解释，首先看一下强制展开的基本原理。

强制展开可选对象(隐式或非隐式)，使用!操作符，意味着您确定您的代码没有错误，并且可选选项已经在它被打开的地方有一个值。没有!运算符，你可能只需要断言一个可选的绑定:

 if let value = optionalWhichTotallyHasAValue {
     println("\(value)")
 } else {
     assert(false)
 }

哪个不如

println("\(value!)")

现在，隐式可选项允许您表示拥有一个可选项，您希望在所有可能的流中，该可选项在展开时始终具有一个值。因此，它只是进一步帮助您-通过放松编写!每次打开，并确保运行时仍然会出错，以防您对流的假设是错误的。

隐式可选项的基本原理很容易解释，首先看一下强制展开的基本原理。

强制展开可选对象(隐式或非隐式)，使用!操作符，意味着您确定您的代码没有错误，并且可选选项已经在它被打开的地方有一个值。没有!运算符，你可能只需要断言一个可选的绑定:

 if let value = optionalWhichTotallyHasAValue {
     println("\(value)")
 } else {
     assert(false)
 }

哪个不如

println("\(value!)")

现在，隐式可选项允许您表示拥有一个可选项，您希望在所有可能的流中，该可选项在展开时始终具有一个值。因此，它只是进一步帮助您-通过放松编写!每次打开，并确保运行时仍然会出错，以防您对流的假设是错误的。

Apple在Swift编程语言中给出了一个很好的例子——>自动引用计数——>在类实例之间解决强引用循环——>无主引用和隐式未包装可选属性

class Country {
    let name: String
    var capitalCity: City! // Apple finally correct this line until 2.0 Prerelease (let -> var)
    init(name: String, capitalName: String) {
        self.name = name
        self.capitalCity = City(name: capitalName, country: self)
    }
}

class City {
    let name: String
    unowned let country: Country
    init(name: String, country: Country) {
        self.name = name
        self.country = country
    }
}

City的初始化式是从Country的初始化式中调用的。但是，Country的初始化式不能将self传递给City初始化式，直到一个新的Country实例完全初始化，如两阶段初始化中所述。 为了满足这一要求，您将Country的capitalCity属性声明为隐式展开的可选属性。

隐式打开可选选项对于将属性表示为非可选属性非常有用，而实际上它需要是可选的。这通常是在两个相关对象(每个对象都需要对另一个对象的引用)之间“打结”所必需的。当两个引用实际上都不是可选的，但在初始化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。

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

隐式解包装可选(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