与赋值不同的可选链接的dynamicType

Question

可选链接始终返回一个可选值。

为了反映可选链接可以在零值上调用这一事实，可选链接调用的结果始终是一个可选值，即使您正在查询的属性、方法或下标返回一个非可选值。 Swift编程语言

为什么他妈的在操场上做的类型不是可选的？

let stringOptEmpty: String? = ""
stringOptEmpty?.isEmpty // is true
stringOptEmpty?.isEmpty.dynamicType // Bool.Type

但是下面的代码是

let isOk = stringOptEmpty?.isEmpty.dynamicType
isOk.dynamicType // Optional<Bool.Type>.Type

Answer 1

TLDR；

操场边栏/列将动态解析操场中的表达式，无论是分配给变量(可变值/不变值)的值，还是“自由浮动”的非赋值值。

第一个示例将dynamicType应用于一个值，该值将解析为该特定值的类型(true.dynamicType：Bool.Type)。

另一方面，您的第二个示例将dynamicType应用于变量(不可变，但我将在这里使用变量与值不同)，该变量必须具有具体类型，因此将解析为可以容纳任何类型的包装值(true或false)的类型，以及nil (此处，nil是Optional<Bool.Type>.None)，无论变量实际持有什么值。因此，在第二个示例中，dynamicType将解析为Optional<Bool.Type>.Type。

详细信息

在操场边栏/列中显示的值通常遵循以下显示规则：

• 对于赋值表达式，侧栏中显示的值是赋值。 变量a=4 //显示'4‘a =2 //显示'2’让b：() = (a = 3) /*显示'()'：分配给'b‘的_value_是赋值’a= 3‘的_result_，_side effect_是将'a’赋给'3‘。*/
• 对于不包含赋值的表达式，侧栏中显示的值通常是表达式的结果。 真//显示‘真’1>3 //显示‘假’让c=3c //显示'3‘c.dynamicType //显示'Int.Type’

在第一个示例(第2-3行)中，我们没有赋值，操场将在解析该值的/result之前动态解析表达式的值( dynamicType )。由于我们处理的是选项，值要么只是包装类型的值(在本例中是true)，要么是特定于类型的.None。即使操场显示的结果(例如，let a: Int? = nil作为nil在侧栏中显示的结果)，所显示的值实际上与例如let b: String = nil的.None (nil)不同。

• 对于let a: Int? = nil，值 of a实际上是Optional<Int.Type>.None，
• 而对于let b: String? = nil，值 of b是Optional<String.Type>.None。

考虑到这一点，很自然，非nil值的解析nil将是具体的包装类型(在您的示例中，Bool.Type自然是true的类型)，而nil值的解析dynamicType将包括一般的可选信息和包装的类型信息。

struct Foo {
    let bar: Bool = true
}

var foo: Foo? = Foo()

/* .Some<T> case (non-nil) */
foo?.bar             // true <-- _expression_ resolves to (results in) the _value_ 'true'
foo?.bar.dynamicType // Bool.Type <-- dynamic type of the _result of expression_
true.dynamicType     // Bool.Type <-- compare with this

/* .None case (nil) */
foo = nil
foo?.bar.dynamicType // nil <-- _expression_ resolves to the _value_ 'Optional<Foo.Type>.None'
Optional<Foo.Type>.None.dynamicType
                     // Optional<Foo.Type>.Type <-- compare with this

现在，如果将值赋值给一个变量，那么自然该变量必须有一个具体的类型。因为我们在运行时分配的值可以是.None或.Some<T>，所以变量的类型必须是能够保存这两种情况的值的类型，因此，Optional<T.Type> (不考虑变量是持有nil值还是非nil值)。这就是您在第二个示例中所显示的情况:变量的dynamicType (在这里是不可变的，但使用变量与值不同) isOk是一种可以同时容纳.None和.Some<T>的类型，不管变量的实际值是什么，因此dynamicType解析为这种类型；Optional<Bool.Type>.Type。

用parantheses包装表达式逃避了Swift游乐场运行时的自省？

有趣的是，如果一个表达式在应用.dynamicType之前是用parantheses包装的，那么操场边栏将包装表达式的.dynamicType解析为表达式的类型，就好像它的实际值未知一样。例如，(...)在(...).dynamicType中被视为具有具体类型而不是运行时解析值的变量。

/* .Some case (non-nil) */
foo?.bar               // true
(foo?.bar).dynamicType /* Optional<Bool>.Type <-- as if (...) 
                          is a _variable_ of unknown value         */

/* .None case (nil) */
foo = nil
(foo?.bar).dynamicType /* Optional<Bool>.Type <-- as if (...) 
                          is a _variable_ of unknown value         */

我们还可以进一步注意到，在操场上封装在parantheses中的任何单独表达式都不会解决任何问题(在侧栏中)。这就好像我们避开了侧栏:s运行时内省，如果用parantheses包装表达式(这将解释为什么用parantheses包装的表达式的dynamicType会解析，就好像操场不能使用这些表达式的运行时信息一样)。

var a = 4 // shows '4'
(a = 2)   // shows nothing; can't expand or get details in sidebar

Tbh，我无法解释这是为什么，并将其归类为斯威夫特游乐场的特点。