blocks|key|2953560|text|首先，您必须了解什么是可选类型。可选类型基本上意味着变量可以是nil。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2953561|示例：|2953562|var+canBeNil+:+Int?+=+4
canBeNil+=+nil|code-block|syntax|javascript|2953563|问号表示canBeNil可以为nil。|2953564|这是行不通的：|2953565|var+cantBeNil+:+Int+=+4
cantBeNil+=+nil+//+can't+do+this|2953566|要从变量中获取值(如果它是可选的)，您必须将其解包为。这只意味着在末尾加一个感叹号。|2953567|var+canBeNil+:+Int?+=+4
println(canBeNil!)|2953568|您的代码应如下所示：|2953569|let+optionalSquare:+Square?+=+Square(sideLength:+2.5,+name:+"optional+square")+
let+sideLength+=+optionalSquare!.sideLength|2953570|附注：|2953571|您还可以通过使用感叹号而不是问号来声明要自动展开的可选参数。|2953572|2953573|var+canBeNil+:+Int!+=+4
print(canBeNil)+//+no+unwrapping+needed|2953574|因此，修复代码的另一种方法是：|2953575|let+optionalSquare:+Square!+=+Square(sideLength:+2.5,+name:+"optional+square")+
let+sideLength+=+optionalSquare.sideLength|2953576|编辑：|2953577|您所看到的不同之处正是可选值是包装的这一事实的症状。在它的上面还有另一层。未包装的版本只显示了直接的对象，因为它是未包装的。|BOLD|2953578|快速比较一下游乐场：|2953579|​|2953580|📷|atomic|2953581|2953582|在第一种和第二种情况下，对象不会自动展开，因此您会看到两个“层”({{...}})，而在第三种情况下，您只会看到一层({...})，因为对象会自动展开。|2953583|第一种情况和后两种情况的不同之处在于，如果optionalSquare设置为nil，后两种情况将产生运行时错误。使用第一种情况中的语法，您可以执行如下操作：|2953584|if+let+sideLength+=+optionalSquare?.sideLength+{
++++println("sideLength+is+not+nil")
}+else+{
++++println("sidelength+is+nil")
}|2953585|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/866f338e26c446bd224627ebde76c915.png|imageAlt^0|V|3|0|0|0|4|8|F|3|0|0|0|0|0|0|0|0|0|0|0|0|0|0|F|3|11|4|0|0|0|0|1|0|0|0|X|7|1N|5|0|L|E|12|3|0|0^^$0|@$1|2|3|4|5|6|7|23|8|@$9|24|A|25|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|26|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|27|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|28|8|@$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|2D|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|2E|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|2F|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|2G|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|2H|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|2I|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|2J|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|2K|8|@]|D|@]|E|$]]|$1|14|3|G|5|6|7|2L|8|@]|D|@]|E|$]]|$1|15|3|16|5|J|7|2M|8|@]|D|@]|E|$K|L]]|$1|17|3|18|5|6|7|2N|8|@]|D|@]|E|$]]|$1|19|3|1A|5|J|7|2O|8|@]|D|@]|E|$K|L]]|$1|1B|3|1C|5|6|7|2P|8|@]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|2Q|8|@$9|2R|A|2S|B|1F]|$9|2T|A|2U|B|1F]]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|2V|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|6|7|2W|8|@]|D|@]|E|$]]|$1|1K|3|1L|5|1M|7|2X|8|@]|D|@$9|2Y|A|2Z|1|30]]|E|$]]|$1|1N|3|1J|5|6|7|31|8|@]|D|@]|E|$]]|$1|1O|3|1P|5|6|7|32|8|@$9|33|A|34|B|C]|$9|35|A|36|B|C]]|D|@]|E|$]]|$1|1Q|3|1R|5|6|7|37|8|@$9|38|A|39|B|C]|$9|3A|A|3B|B|C]]|D|@]|E|$]]|$1|1S|3|1T|5|J|7|3C|8|@]|D|@]|E|$K|L]]|$1|1U|3|-4|5|6|7|3D|8|@]|D|@]|E|$]]]|1V|$1W|$5|1X|1Y|1Z|E|$20|21|22|-4]]]]

First, you have to understand what an Optional type is. An optional type basically means that the variable can be <code>nil</code>.

Example:

<pre><code>var canBeNil : Int? = 4
canBeNil = nil
</code></pre>

The question mark indicates the fact that <code>canBeNil</code> can be <code>nil</code>.

This would not work:

<pre><code>var cantBeNil : Int = 4
cantBeNil = nil // can't do this
</code></pre>

To get the value from your variable if it is optional, you have to unwrap it. This just means putting an exclamation point at the end.

<pre><code>var canBeNil : Int? = 4
println(canBeNil!)
</code></pre>

Your code should look like this:

<pre><code>let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square") 
let sideLength = optionalSquare!.sideLength
</code></pre>

A sidenote:

You can also declare optionals to automatically unwrap by using an exclamation mark instead of a question mark. 

Example:

<pre><code>var canBeNil : Int! = 4
print(canBeNil) // no unwrapping needed
</code></pre>

So an alternative way to fix your code is:

<pre><code>let optionalSquare: Square! = Square(sideLength: 2.5, name: "optional square") 
let sideLength = optionalSquare.sideLength
</code></pre>

<h2>EDIT:</h2>

The difference that you're seeing is exactly the symptom of the fact that the optional value is wrapped. There is another layer on top of it. The unwrapped version just shows the straight object because it is, well, unwrapped.

A quick playground comparison:

<img src="https://i.stack.imgur.com/ClB78.png" alt="playground">

In the first and second cases, the object is not being automatically unwrapped, so you see two "layers" (<code>{{...}}</code>), whereas in the third case, you see only one layer (<code>{...}</code>) because the object is being automatically unwrapped.

The difference between the first case and the second two cases is that the second two cases will give you a runtime error if <code>optionalSquare</code> is set to <code>nil</code>. Using the syntax in the first case, you can do something like this:

<pre><code>if let sideLength = optionalSquare?.sideLength {
 println("sideLength is not nil")
} else {
 println("sidelength is nil")
}
</code></pre>

blocks|key|2740857|text|现有的正确答案很好，但我发现为了完全理解这一点，我需要一个很好的类比，因为这是一个非常抽象和奇怪的概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2740858|因此，让我通过给出正确答案之外的不同观点来帮助那些“右脑”(视觉思维)开发人员。这里有一个很好的类比，它对我帮助很大。|2740859|生日礼物包装类比|offset|length|style|BOLD|2740860|把可选的东西想象成像生日礼物一样，包装得很硬、很硬、很彩色。|2740861|直到你打开礼物，你才知道包装里有没有东西--也许里面什么都没有！如果里面有什么东西，它可能是另一件礼物，也是包装好的，也可能什么也没有。你甚至可能拆开100件嵌套的礼物，最终发现除了包装什么都没有。|2740862|如果optional的值不是nil，那么现在您已经显示了一个包含某些内容的框。但是，特别是如果值不是显式类型的，并且是一个变量而不是预定义的常量，那么您可能仍然需要打开框，然后才能知道框中有什么具体内容，比如它是什么类型，或者实际值是什么。|CODE|2740863|盒子里有什么？！|2740864|即使在您解开变量之后，您仍然像last+scene+in+SE7EN中的Brad+Pitt+(警告:剧透和非常R级的粗话和暴力)，因为即使在您已经解开了礼物之后，您仍然处于以下情况：您现在有了或者一个包含__(但您不知道是什么).**的盒子|2740865|你可能知道某些东西的类型。例如，如果您将变量声明为[Int:Any?]类型，那么您就知道您有一个(可能为空的)带有整数下标的字典，它会生成任何旧类型的包装内容。|2740866|这就是为什么在Swift中处理集合类型(字典和数组)会有些麻烦。|2740867|举个例子：|2740868|typealias+presentType+=+[Int:Any?]

func+wrap(i:Int,+gift:Any?)+->+presentType?+{
++++if(i+!=+0)+{
++++++++let+box+:+presentType+=+[i:wrap(i-1,gift:gift)]
++++++++return+box
++++}
++++else+{
++++++++let+box+=+[i:gift]
++++++++return+box
++++}
}

func+getGift()+->+String?+{
++++return+"foobar"
}

let+f00+=+wrap(10,gift:getGift())

//Now+we+have+to+unwrap+f00,+unwrap+its+entry,+then+force+cast+it+into+the+type+we+hope+it+is,+and+then+repeat+this+in+nested+fashion+until+we+get+to+the+final+value.

var+b4r+=+(((((((((((f00![10]!+as!+[Int:Any?])[9]!+as!+[Int:Any?])[8]!+as!+[Int:Any?])[7]!+as!+[Int:Any?])[6]!+as!+[Int:Any?])[5]!+as!+[Int:Any?])[4]!+as!+[Int:Any?])[3]!+as!+[Int:Any?])[2]!+as!+[Int:Any?])[1]!+as!+[Int:Any?])[0])

//Now+we+have+to+DOUBLE+UNWRAP+the+final+value+(because,+remember,+getGift+returns+an+optional)+AND+force+cast+it+to+the+type+we+hope+it+is

let+asdf+:+String+=+b4r!!+as!+String

print(asdf)|code-block|syntax|javascript|2740869|entityMap|0|LINK|mutability|MUTABLE|url|https://m.youtube.com/watch?v=1giVzxyoclE^0|0|0|0|8|0|0|0|E|3|0|0|8|0|0|3C|F|J|0|0|0|28|P|A|0|0|W|0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1E|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1F|8|@$F|1G|G|1H|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1I|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1J|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1K|8|@$F|1L|G|1M|H|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1N|8|@$F|1O|G|1P|H|I]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1Q|8|@$F|1R|G|1S|H|I]]|9|@$F|1T|G|1U|1|1V]]|A|$]]|$1|U|3|V|5|6|7|1W|8|@$F|1X|G|1Y|H|I]|$F|1Z|G|20|H|P]]|9|@]|A|$]]|$1|W|3|X|5|6|7|21|8|@$F|22|G|23|H|I]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|24|8|@$F|25|G|26|H|I]]|9|@]|A|$]]|$1|10|3|11|5|12|7|27|8|@]|9|@]|A|$13|14]]|$1|15|3|-4|5|6|7|28|8|@]|9|@]|A|$]]]|16|$17|$5|18|19|1A|A|$1B|1C]]]]

The existing correct answer is great, but I found that for me to understand this fully, I needed a good analogy, since this is a very abstract and weird concept.

So, let me help those fellow "right-brained" (visual thinking) developers out by giving a different perspective in addition to the correct answer. Here is a good analogy that helped me a lot.

Birthday Present Wrapping Analogy

Think of optionals as being like birthday presents that come in stiff, hard, colored wrapping. 

You don't know if there's anything inside the wrapping until you unwrap the present — maybe there is nothing at all inside! If there is something inside, it could be yet another present, which is also wrapped, and which also might contain nothing. You might even unwrap 100 nested presents to finally discover there was nothing but wrapping. 

If the value of the optional is not <code>nil</code>, now you have revealed a box containing something. But, especially if the value is not explicitly typed and is a variable and not a predefined constant, then you may still need to open the box before you can know anything specific about what's in the box, like what type it is, or what the actual value is. 

What's In The Box?! Analogy

Even after you unwrap the variable, you are still like Brad Pitt in the <a href="https://m.youtube.com/watch?v=1giVzxyoclE" rel="noreferrer">last scene in SE7EN</a> (warning: spoilers and very R-rated foul language and violence), because even after you have unwrapped the present, you are in the following situation: you now have <code>nil</code>, or a box containing something (but you don't know what). 

You might know the type of the something. For example, if you declared the variable as being type, <code>[Int:Any?]</code>, then you'd know you had a (potentially empty) Dictionary with integer subscripts that yield wrapped contents of any old type.

That is why dealing with collection types (Dictionaries and Arrays) in Swift can get kind of hairy.

Case in point: 

<pre><code>typealias presentType = [Int:Any?]

func wrap(i:Int, gift:Any?) -&gt; presentType? {
 if(i != 0) {
 let box : presentType = [i:wrap(i-1,gift:gift)]
 return box
 }
 else {
 let box = [i:gift]
 return box
 }
}

func getGift() -&gt; String? {
 return "foobar"
}

let f00 = wrap(10,gift:getGift())

//Now we have to unwrap f00, unwrap its entry, then force cast it into the type we hope it is, and then repeat this in nested fashion until we get to the final value.

var b4r = (((((((((((f00![10]! as! [Int:Any?])[9]! as! [Int:Any?])[8]! as! [Int:Any?])[7]! as! [Int:Any?])[6]! as! [Int:Any?])[5]! as! [Int:Any?])[4]! as! [Int:Any?])[3]! as! [Int:Any?])[2]! as! [Int:Any?])[1]! as! [Int:Any?])[0])

//Now we have to DOUBLE UNWRAP the final value (because, remember, getGift returns an optional) AND force cast it to the type we hope it is

let asdf : String = b4r!! as! String

print(asdf)
</code></pre>

blocks|key|2740911|text|“？”表示可选的链式表达式|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2740912|‘！’表示的是force-value|2740913|📷|atomic|offset|length|2740914|​|2740915|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/afd4505c58fface4ac7ac9a241e0841b.png|imageAlt^0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@$G|W|H|X|1|Y]]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R|S|-4]]]]

'?' means optional chaining expression 
the'!'means is force-value 
<a href="https://i.stack.imgur.com/QPjq3.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/QPjq3.png" alt="enter image description here"></a>

blocks|key|154478|text|Swift非常重视类型安全。整个Swift语言在设计时都考虑到了安全性。这是Swift的标志之一，您应该张开双臂欢迎它。它将有助于开发干净、可读的代码，并帮助防止应用程序崩溃。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|154479|Swift中的所有可选项都以?符号为界。通过在声明为可选的类型名称之后设置?，实质上不是将其转换为?之前的类型，而是将其转换为可选类型。|offset|length|style|CODE|154480|154481|注意:变量或类型Int+is++|154482|++as+Int?。它们是两种不同的类型，不能相互操作。|blockquote|154483|154484|154485|154486|使用可选的|154487|var+myString:+String?

myString+=+"foobar"|code-block|syntax|javascript|154488|这并不意味着你正在使用的是一种类型的String。这意味着您正在使用一种类型的字符串(+String?+Optional或Optional+String)。事实上，每当你尝试|BOLD|154489|print(myString)|154490|在运行时，调试控制台将打印Optional("foobar")。"Optional()“部分表明此变量在运行时可能有值，也可能没有值，但恰好当前包含字符串"foobar”。此"Optional()“指示将保持不变，除非您执行所谓的”解包“可选值。|154491|将类型解包为意味着您现在将该类型转换为非可选类型。这将生成一个新类型，并将驻留在该可选类型中的值分配给新的非可选类型。通过这种方式，您可以对该变量执行操作，因为编译器已保证该变量具有实值。|154492|154493|有条件地展开将检查optional中的值是否为nil。如果它不是nil，将有一个新创建的常量变量，该常量变量将被赋值并展开为非可选常量。然后，您就可以在if块中安全地使用非可选的了。|154494|154495|注意:您可以为有条件取消包装的常量提供与要取消包装的可选变量相同的名称。|154496|154497|154498|if+let+myString+=+myString+{
++++print(myString)
++++//+will+print+"foobar"
}|154499|有条件地展开optionals是访问optional的值的最干净的方式，因为如果它包含nil值，那么if+let块中的所有内容都将不会执行。当然，与任何if语句一样，您可以包含一个else块|154500|if+let+myString+=+myString+{
++++print(myString)
++++//+will+print+"foobar"
}
else+{
++++print("No+value")
}|154501|154502|强制解包是通过使用所谓的!+(“”)运算符来完成的。这不太安全，但仍然允许您的代码编译。然而，无论何时使用bang运算符，在强制展开之前，您必须1000%25确定您的变量确实包含实值。|154503|var+myString:+String?

myString+=+"foobar"

print(myString!)|154504|上面的代码是完全有效的Swift代码。它会打印出设置为"foobar“的myString的值。用户将在控制台中看到打印的foobar，仅此而已。但是让我们假设这个值从未被设置过：|154505|var+myString:+String?

print(myString!)+|154506|现在我们有了一个不同的情况。与Objective-C不同的是，每当试图强行解包optional，而optional尚未设置且为nil时，当您试图解包optional以查看应用程序内部的内容时，应用程序将崩溃。|154507|154508|使用类型转换进行解包。正如我们前面所说的，当您unwrapping可选类型时，您实际上是在将其强制转换为非可选类型，您也可以将非可选类型强制转换为其他类型。例如：|154509|var+something:+Any?|154510|在我们的代码中的某个地方，变量something将被设置为某个值。也许我们正在使用泛型，或者可能有一些其他的逻辑正在进行，这将导致这一点发生变化。因此，在稍后的代码中，我们希望使用something，但如果它是不同的类型，则仍然能够以不同的方式处理它。在这种情况下，您需要使用as关键字来确定这一点：|154511|154512|注意：as运算符是您在Swift中键入cast的方式。|154513|154514|154515|//+Conditionally
if+let+thing+=+something+as?+Int+{
++++print(thing)+//+0
}

//+Optionally
let+thing+=+something+as?+Int
print(thing)+//+Optional(0)

//+Forcibly
let+thing+=+something+as!+Int
print(thing)+//+0,+if+no+exception+is+raised|154516|注意两个as关键字之间的区别。就像以前一样，当我们强行打开一个可选的时，我们使用了!+bang操作符。在这里，您将执行相同的操作，但不是将其强制转换为非可选类型，而是将其强制转换为Int。并且它必须能够向下转换为Int，否则，就像当值为nil时使用bang操作符一样，您的应用程序将崩溃。|154517|为了在某种类型或数学运算中使用这些变量，必须将它们展开。|154518|例如，在Swift中，只有相同类型的有效数字数据类型才能相互操作。当你使用as!转换一个类型时，你是在强制该变量的向下转换，就好像你是某个，它就是那个类型，因此可以安全地操作而不会使你的应用程序崩溃。这是可以的，只要变量确实是您要将其强制转换为的类型，否则会弄得一团糟。|154519|尽管如此，使用as!进行类型转换将允许编译您的代码。通过使用as?进行转换则是另一回事。实际上，as?将您的Int声明为完全不同的数据类型。|154520|现在是+Optional(0)了|154521|如果你曾经尝试做作业，写一些像这样的东西|154522|1+%2B+Optional(1)+=+2|154523|你的数学老师可能会给你一个"F“。斯威夫特也是如此。除了Swift宁愿根本不编译也不给你评分。，因为在一天结束的时候，可选项实际上可能是nil。|154524|安全第一的孩子。|154525|entityMap^0|0|E|1|11|1|1D|1|0|0|8|3|0|5|4|0|0|0|0|0|0|0|2F|I|6|18|7|0|0|0|3F|D|I|X|A|2G|A|0|0|1|6|2G|0|0|0|2J|N|3|W|3|24|2|0|0|0|10|0|0|0|0|0|2N|0|0|0|0|4|G|22|C|1|0|0|0|2H|10|8|1O|6|0|0|0|2W|1R|3|0|0|0|6|8|21|N|A|0|0|0|46|F|9|2I|9|3U|2|0|0|0|R|3|2|0|0|0|0|0|40|4|2|15|1|2I|3|2Y|3|3A|3|0|0|S|0|0|3R|11|3|0|0|1Y|7|3|U|3|1C|3|1I|3|0|0|3|4|B|4|B|0|0|0|1B|O|0|0^^$0|@$1|2|3|4|5|6|7|2T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2U|8|@$D|2V|E|2W|F|G]|$D|2X|E|2Y|F|G]|$D|2Z|E|30|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|31|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|32|8|@$D|33|E|34|F|G]]|9|@]|A|$]]|$1|K|3|L|5|M|7|35|8|@$D|36|E|37|F|G]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|38|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|39|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|3A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|3B|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|3C|8|@]|9|@]|A|$V|W]]|$1|X|3|Y|5|6|7|3D|8|@$D|3E|E|3F|F|Z]|$D|3G|E|3H|F|G]|$D|3I|E|3J|F|G]]|9|@]|A|$]]|$1|10|3|11|5|U|7|3K|8|@]|9|@]|A|$V|W]]|$1|12|3|13|5|6|7|3L|8|@$D|3M|E|3N|F|Z]|$D|3O|E|3P|F|G]|$D|3Q|E|3R|F|G]|$D|3S|E|3T|F|G]]|9|@]|A|$]]|$1|14|3|15|5|6|7|3U|8|@$D|3V|E|3W|F|Z]|$D|3X|E|3Y|F|Z]]|9|@]|A|$]]|$1|16|3|-4|5|6|7|3Z|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|40|8|@$D|41|E|42|F|Z]|$D|43|E|44|F|G]|$D|45|E|46|F|G]|$D|47|E|48|F|G]]|9|@]|A|$]]|$1|19|3|-4|5|6|7|49|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|M|7|4A|8|@$D|4B|E|4C|F|Z]]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|4D|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|4E|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|U|7|4F|8|@]|9|@]|A|$V|W]]|$1|1G|3|1H|5|6|7|4G|8|@$D|4H|E|4I|F|Z]]|9|@]|A|$]]|$1|1I|3|1J|5|U|7|4J|8|@]|9|@]|A|$V|W]]|$1|1K|3|-4|5|6|7|4K|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|4L|8|@$D|4M|E|4N|F|Z]|$D|4O|E|4P|F|Z]|$D|4Q|E|4R|F|G]]|9|@]|A|$]]|$1|1N|3|1O|5|U|7|4S|8|@]|9|@]|A|$V|W]]|$1|1P|3|1Q|5|6|7|4T|8|@$D|4U|E|4V|F|Z]|$D|4W|E|4X|F|G]|$D|4Y|E|4Z|F|G]]|9|@]|A|$]]|$1|1R|3|1S|5|U|7|50|8|@]|9|@]|A|$V|W]]|$1|1T|3|1U|5|6|7|51|8|@$D|52|E|53|F|Z]|$D|54|E|55|F|G]]|9|@]|A|$]]|$1|1V|3|-4|5|6|7|56|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|6|7|57|8|@$D|58|E|59|F|Z]|$D|5A|E|5B|F|Z]|$D|5C|E|5D|F|G]]|9|@]|A|$]]|$1|1Y|3|1Z|5|U|7|5E|8|@]|9|@]|A|$V|W]]|$1|20|3|21|5|6|7|5F|8|@$D|5G|E|5H|F|Z]|$D|5I|E|5J|F|G]|$D|5K|E|5L|F|G]|$D|5M|E|5N|F|G]]|9|@]|A|$]]|$1|22|3|-4|5|6|7|5O|8|@]|9|@]|A|$]]|$1|23|3|24|5|M|7|5P|8|@$D|5Q|E|5R|F|Z]|$D|5S|E|5T|F|G]]|9|@]|A|$]]|$1|25|3|-4|5|6|7|5U|8|@]|9|@]|A|$]]|$1|26|3|-4|5|6|7|5V|8|@]|9|@]|A|$]]|$1|27|3|28|5|U|7|5W|8|@]|9|@]|A|$V|W]]|$1|29|3|2A|5|6|7|5X|8|@$D|5Y|E|5Z|F|Z]|$D|60|E|61|F|G]|$D|62|E|63|F|G]|$D|64|E|65|F|G]|$D|66|E|67|F|G]|$D|68|E|69|F|G]]|9|@]|A|$]]|$1|2B|3|2C|5|6|7|6A|8|@$D|6B|E|6C|F|Z]]|9|@]|A|$]]|$1|2D|3|2E|5|6|7|6D|8|@$D|6E|E|6F|F|Z]|$D|6G|E|6H|F|G]]|9|@]|A|$]]|$1|2F|3|2G|5|6|7|6I|8|@$D|6J|E|6K|F|Z]|$D|6L|E|6M|F|G]|$D|6N|E|6O|F|G]|$D|6P|E|6Q|F|G]|$D|6R|E|6S|F|G]]|9|@]|A|$]]|$1|2H|3|2I|5|6|7|6T|8|@$D|6U|E|6V|F|Z]|$D|6W|E|6X|F|Z]|$D|6Y|E|6Z|F|G]]|9|@]|A|$]]|$1|2J|3|2K|5|6|7|70|8|@]|9|@]|A|$]]|$1|2L|3|2M|5|U|7|71|8|@]|9|@]|A|$V|W]]|$1|2N|3|2O|5|6|7|72|8|@$D|73|E|74|F|Z]]|9|@]|A|$]]|$1|2P|3|2Q|5|6|7|75|8|@]|9|@]|A|$]]|$1|2R|3|-4|5|6|7|76|8|@]|9|@]|A|$]]]|2S|$]]

Swift places a high premium on type safety. The entire Swift language was designed with safety in mind. It is one of the hallmarks of Swift and one that you should welcome with open arms. It will assist in the development of clean, readable code and help keep your application from crashing.

All optionals in Swift are demarcated with the <code>?</code> symbol. By setting the <code>?</code> after the name of the type in which you are declaring as optional you are essentially casting this not as the type in which is before the <code>?</code>, but instead as the optional type.

<hr>

<blockquote>
 Note: A variable or type <code>Int</code> is not the same as <code>Int?</code>. They are two different types that can not be operated on each other.
</blockquote>

<hr>

Using Optional

<pre><code>var myString: String?

myString = "foobar"
</code></pre>

This does not mean that you are working with a type of <code>String</code>. This means that you are working with a type of <code>String?</code> (String Optional, or Optional String). In fact, whenever you attempt to 

<pre><code>print(myString)
</code></pre>

at runtime, the debug console will print <code>Optional("foobar")</code>. The "<code>Optional()</code>" part indicates that this variable may or may not have a value at runtime, but just so happens to currently be containing the string "foobar". This "<code>Optional()</code>" indication will remain unless you do what is called "unwrapping" the optional value.

Unwrapping an optional means that you are now casting that type as non-optional. This will generate a new type and assign the value that resided within that optional to the new non-optional type. This way you can perform operations on that variable as it has been guaranteed by the compiler to have a solid value.

<hr>

Conditionally Unwrapping will check if the value in the optional is <code>nil</code> or not. If it is not <code>nil</code>, there will be a newly created constant variable that will be assigned the value and unwrapped into the non-optional constant. And from there you may safely use the non-optional in the <code>if</code> block.

<blockquote>
 Note: You can give your conditionally unwrapped constant the same name as the optional variable you are unwrapping. 
</blockquote>

<pre><code>if let myString = myString {
 print(myString)
 // will print "foobar"
}
</code></pre>

Conditionally unwrapping optionals is the cleanest way to access an optional's value because if it contains a nil value then everything within the if let block will not execute. Of course, like any if statement, you may include an else block

<pre><code>if let myString = myString {
 print(myString)
 // will print "foobar"
}
else {
 print("No value")
}
</code></pre>

<hr>

Forcibly Unwrapping is done by employing what is known as the <code>!</code> ("bang") operator. This is less safe but still allows your code to compile. However whenever you use the bang operator you must be 1000% certain that your variable does in fact contain a solid value before forcibly unwrapping.

<pre><code>var myString: String?

myString = "foobar"

print(myString!)
</code></pre>

This above is entirely valid Swift code. It prints out the value of <code>myString</code> that was set as "foobar". The user would see <code>foobar</code> printed in the console and that's about it. But let's assume the value was never set:

<pre><code>var myString: String?

print(myString!) 
</code></pre>

Now we have a different situation on our hands. Unlike Objective-C, whenever an attempt is made to forcibly unwrap an optional, and the optional has not been set and is <code>nil</code>, when you try to unwrap the optional to see what's inside your application will crash.

<hr>

Unwrapping w/ Type Casting. As we said earlier that while you are <code>unwrapping</code> the optional you are actually casting to a non-optional type, you can also cast the non-optional to a different type. For example:

<pre><code>var something: Any?
</code></pre>

Somewhere in our code the variable <code>something</code> will get set with some value. Maybe we are using generics or maybe there is some other logic that is going on that will cause this to change. So later in our code we want to use <code>something</code> but still be able to treat it differently if it is a different type. In this case you will want to use the <code>as</code> keyword to determine this:

<blockquote>
 Note: The <code>as</code> operator is how you type cast in Swift.
</blockquote>

<pre><code>// Conditionally
if let thing = something as? Int {
 print(thing) // 0
}

// Optionally
let thing = something as? Int
print(thing) // Optional(0)

// Forcibly
let thing = something as! Int
print(thing) // 0, if no exception is raised
</code></pre>

Notice the difference between the two <code>as</code> keywords. Like before when we forcibly unwrapped an optional we used the <code>!</code> bang operator to do so. Here you will do the same thing but instead of casting as just a non-optional you are casting it also as <code>Int</code>. And it must be able to be downcast as <code>Int</code>, otherwise, like using the bang operator when the value is <code>nil</code> your application will crash.

And in order to use these variables at all in some sort or mathematical operation they must be unwrapped in order to do so.

For instance, in Swift only valid number data types of the same kind may be operated on each other. When you cast a type with the <code>as!</code> you are forcing the downcast of that variable as though you are certain it is of that type, therefore safe to operate on and not crash your application. This is ok as long as the variable indeed is of the type you are casting it to, otherwise you'll have a mess on your hands.

Nonetheless casting with <code>as!</code> will allow your code to compile. By casting with an <code>as?</code> is a different story. In fact, <code>as?</code> declares your <code>Int</code> as a completely different data type all together. 

Now it is <code>Optional(0)</code>

And if you ever tried to do your homework writing something like 

<pre><code>1 + Optional(1) = 2
</code></pre>

Your math teacher would have likely given you an "F". Same with Swift. Except Swift would rather not compile at all rather than give you a grade. Because at the end of the day the optional may in fact be nil.

Safety First Kids.

blocks|key|154542|text|有7种方法可以在Swift中展开可选值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|154543|154544|可选绑定-Safe|ordered-list-item|154545|可选链-Safe|154546|可选模式-+Safe|154547|Nil合并-Safe|154548|154549|语句-Safe|154550|强制展开-Safe解包-Safe解包-不安全|154551|154552|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|Y|8|@]|9|@]|A|$]]|$1|L|3|-4|5|E|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|E|7|11|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|S|$]]

There are 7 ways to unwrapping optional value in Swift.
<ol>
<li>Optional Binding - Safe</li>
<li>Optional Chaining - Safe</li>
<li>Optional Pattern - Safe</li>
<li>Nil Coalescing - Safe</li>
<li>Guard Statement - Safe</li>
<li>Force Unwrapping - Unsafe</li>
<li>Implicit Unwrapping - Unsafe</li>
</ol>

I'm learning Swift for iOS 8 / OSX 10.10 by following <a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GuidedTour.html#//apple_ref/doc/uid/TP40014097-CH2" rel="noreferrer">this tutorial</a>, and the term &quot;unwrapped value&quot; is used several times, as in this paragraph (under Objects and Class):
<blockquote>
When working with optional values, you can write ? before operations
like methods, properties, and subscripting. If the value before the ?
is nil, everything after the ? is ignored and the value of the whole
expression is nil. Otherwise, the optional value is unwrapped, and
everything after the ? acts on the unwrapped value. In both cases, the
value of the whole expression is an optional value.
</blockquote>
<pre><code>let optionalSquare: Square? = Square(sideLength: 2.5, name: &quot;optional square&quot;) 
let sideLength = optionalSquare?.sideLength
</code></pre>
I don't get it, and searched on the web without luck.
What does this means?
<hr />
<h2>Edit</h2>
From Cezary's answer, there's a slight difference between the output of the original code and the final solution (tested on playground) :
<h3>Original code</h3>
<img src="https://i.stack.imgur.com/Ns3my.png" alt="Original code" />
<h3>Cezary's solution</h3>
<img src="https://i.stack.imgur.com/RsvFp.png" alt="Cezary's solution" />
The superclass' properties are shown in the output in the second case, while there's an empty object in the first case.
Isn't the result supposed to be identical in both case?
Related Q&amp;A : <a href="https://stackoverflow.com/a/24026093/1437016">What is an optional value in Swift?</a>

What is an "unwrapped value" in Swift?

Objective-C

编译器

Swift

我正在学习适用于iOS 8/OSX10.10的Swift，遵循，术语“解包值”被多次使用，就像下面这段(在对象和类下面)：当使用可选值时，您可以写？在方法、属性和下标等操作之前。如果前面的值？是不是零，后面的都是？被忽略，并且整个表达式的值为nil。否则，取消包装可选值，以及?之后的所有内容。对未包装的值执行操作。在这...

问什么是Swift中的“解包值”？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是Swift中的“解包值”？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是Swift中的“解包值”？
EN