Странное использование необязательных значений в Swift

Это потому, что вы можете объявить необязательную переменную рекурсивно необязательной, например:

var x: Int?? = 5
// LLDB: p x.dynamicType returns (Int??)

Вы можете пойти еще дальше:

var y: Int????????? = 6
// LLDB: p x.dynamicType returns (Int?????????)

Что делает конструкция if let, так это проверяет, можете ли вы развернуть необязательное значение, и бывает, что вы можете развернуть необязательное необязательное значение, даже если его окончательное значение равно nil. Думайте об этом так, как будто необязательное значение — это не nil, а некий объект, обертывающий nil.

Чтобы проверить это в коде, вы можете сделать следующее:

var a: Int? = nil;
// LLDB: p a! returns fatal error: Can't unwrap Optional.None

var b: Int?? = nil;
// LLDB: p b! returns (Int?) $R2 = nil

Итак, вот что произошло в случае вашего условия z2: конструкция if let проверяет, может ли она развернуть y2, и это было так, поэтому блок if был выполнен.

Необязательная привязка работает следующим образом: if проверяет успешность объявления let. В вашем первом операторе это не удается, потому что вы не можете присвоить nil Int, но во втором операторе он успешен и входит в тело, потому что вам разрешено присваивать nil IntOptional.

Для меня z2 ложно, а z3 верно:

println(z1)   // false
println(z2)   // false
println(z3)   // true

Напоминая, что if let A = optB { ... } означает, по сути, «если optB не является nil, назначьте его A и выполните следующий блок», причина, по которой z3 истинно, заключается в том, что x является Optional(nil), а не nil. Вы можете увидеть это, попробовав

var x: Int? = 5
if let y3: Int? = x {
    println(x) // Optional(5)
    z3 = true
}
println(z3)    // true

и сравнивая эту и оригинальную версию с

var x: Int? = nil
if let y3: Int? = x? {
    z3 = true
}
println(z3)   // false!

В первом случае вы можете видеть, что x завернуто (поэтому исходная версия была не nil, а Optional(nil)); во втором вы можете увидеть, как x можно развернуть, чтобы получить nil.

Swift (особенно при просмотре на игровой площадке Xcode) затрудняет просмотр этого из-за того, как он отображает nil (вероятно, потому, что его нельзя развернуть, он показывает Optional(nil) и nil как nil).

Кроме того, вариации этого можно также использовать для изучения некоторых тонкостей того, что происходит в левой части присваивания, что является единственной разницей между случаями z1 и z2. Например, вы можете видеть, что в случае z3, как и в случае z2, y3 является необязательным.

var x: Int? = 5
if let y3: Int? = x {
    println(x) // Optional(5)
    println(y3) // Optional(5)
    z3 = true
}
println(z3)   // true

в то время как удаление ? из типа для y3 делает его похожим на случай z1, где y1 не является необязательным

var x: Int? = 5
if let y3: Int = x {
    println(x) // Optional(5)
    println(y3) // 5
    z3 = true
}
println(z3)   // true

Потому что вам не хватает "?" в z1

Я попытаюсь объяснить это, добавляя комментарии к блокам, чтобы вы могли видеть предполагаемые типы и значения.

var z1 = false  
var z2 = false  
var z3 = false  


if let y1: Int = nil /* nil : Optional<T>   instantiated to Optional<Int>, value is .None */ 
{
    z1 = true
}

if let y2: Int? = nil /* nil : Optional<T>   instantiated to Optional<Optional<Int>>, value is .Some(.None) */ 
{
    z2 = true
}

var x: Int? = nil   /* nil : Optional<T>   instantiated to Optional<Int>, value is .None */ 
if let y3: Int? = x /* x : Optional<Int>   value is .None */ 
{
    z3 = true
}

println(z1)   // false
println(z2)   // ture
println(z3)   // false