用于Swift可选类型的'Rosetta Stone'？

Question

我掌握（我认为）optional types in Swift的基础知识，粗略地理解?和!之间的区别，但我仍然对我得到的一些结果感到困惑使用这些功能 - 特别是Some <T>的作用，以及它与<T>本身的区别;我在某些情况下得到的一些特定错误消息;以及在我期望Some <T>的情况下，<T>似乎如何弹出。

但我也觉得，即使我理解个别情况，我对图片的掌握也远离我，我觉得这里有一个代码，如果我完全理解一个简单示例 - 如果您愿意，可以使用Rosetta Stone - !，?，可选值和解包。

例如，这里是一个简单的（我认为）基本案例的详尽目录：

class Foo {
    var one:String = "";
    var two:String?
    var three:String!
}

let test = Foo()        // {one "" nil nil}

test.one
//test.one?             //  ERROR: ? requires optional type
//test.one!             //  ERROR: ! requires optional type

// ?, unassigned
test.two                // nil
test.two?               // nil
//test.two!             // ERROR: EXEC_BAD_INSTRUCTION

test.two == nil         // true
test.two? == nil        // true
//test.two! == nil      // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

//test.two.isEmpty      // ERROR: String? does not have .isEmpty
test.two?.isEmpty       // nil
//test.two!.isEmpty     // ERROR: EXEC_BAD_INSTRUCTION

// !, unassigned
test.three              // nil
test.three?             // nil
//test.three!           // ERROR: EXEC_BAD_INSTRUCTION

test.three == nil       // true
test.three? == nil      // true
//test.three! == nil    // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

//test.three.isEmpty    // ERROR: EXEC_BAD_INSTRUCTION
test.three?.isEmpty     // nil
//test.three!.isEmpty   // ERROR: EXEC_BAD_INSTRUCTION


test.two = "???"        // {one "" {Some "???"} nil}
test.three = "!!!"      // {one "" {Some "???"} three "!!!"}

// ?, assigned
test.two                // {Some "???"}
test.two?               // {Some "???"}
test.two!               // "???"

test.two == nil         // false
test.two? == nil        // false
//test.two! == nil      // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

//test.two.isEmpty      // ERROR: String? does not have .isEmpty
test.two?.isEmpty       // {Some false}
test.two!.isEmpty       // false

// !, assigned
test.three              // "!!!"
test.three?             // {Some "!!!"}
test.three!             // "!!!"

test.three == nil       // false
test.three? == nil      // false
//test.three! == nil    // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

test.three.isEmpty      // false
test.three?.isEmpty     // {Some false}
test.three!.isEmpty     // false

如果有人可以对此进行注释，并解释每个案例的内容，我认为这个答案可以作为Swift的这些功能如何运作的可靠参考。

Answer 1

好吧，我将尝试回答这一切。可能没有领带来完成所有事情：

注意：如有错误，请随时与我联系。这需要一段时间，所以我肯定做了一些。

快速说明：Optional实际上是一个枚举。它有两种状态：.None和.Some(T)，其中T是值的类型（在您的情况下为String）。

test.one

Foo有一个名为one的属性，返回String。一个明确的String，而不是一个可选的，意味着它肯定有一个值。您对此的处理方式与在代码中编写"HI!"的方式类似。这个值实际上是""

//test.one?             //  ERROR: ? requires optional type

这是一个错误，因为如上所述，test.one会返回一个明确的String，因此它不可能是零。您可以保证返回值存在。

//test.one!             //  ERROR: ! requires optional type

与？相同。的！是一个强制解包运算符，意味着有一个机会 test.one可能是nil，但是你想要强制取出值（如果不是则崩溃）那里）。但是，没有机会它是零，所以你不能拥有？还是一个！。

test.two                // nil

test.two是String?，可以为零。因为它是可选的，所以允许您像在代码中一样返回nil。这个的真正价值是.None，所以你看到的值实际上是一个字符串？不是字符串。

test.two?               // nil

这基本上与上面的相同，除非您明确说明该值可能为零。

//test.two!             // ERROR: EXEC_BAD_INSTRUCTION

您永远不能在!值上使用nil而不会让它崩溃。当你使用这个操作符时，它会强制一个值（所以你有一个String，而不是String？）。但是，如果值为nil，则强制输出 no 值，因此最终导致程序崩溃。

test.two == nil         // true

test.two显然返回nil，或.None（它们是等效的）。因此，如果您比较nil == nil或.None == .None，则确实如此。

test.two? == nil        // true

与上面相同。

//test.two! == nil      // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

强制解包nil值每次都会使程序崩溃。它也没有意义，因为强制解包会返回String，而不是String?。 String不能是nil。

//test.two.isEmpty      // ERROR: String? does not have .isEmpty

基本上，无论何时想要在可选项上调用方法，都需要使用可选绑定或可选链接（两个单独的东西）确保它具有值。串？等于Optional.Some（String），你需要通过可选层来获得你想要的字符串。

test.two?.isEmpty       // nil

这里使用可选链接。基本上，这种方式的工作方式是test.two被评估。如果值为.Some(String)，则在字符串上调用isEmpty。否则，如果是.None，则没有任何反应。这些可选链可以在每个语句中出现多行，例如test.two?.firstEmoji?（假设已经实现了这样的方法。

//test.two!.isEmpty     // ERROR: EXEC_BAD_INSTRUCTION

同样，强制展开零选项是不好的。如果没有先检查该值是否为.Some，请不要这样做。

test.three              // nil

由于three被隐式展开，并且它已初始化为nil（未被设置为其他内容），因此这不应该令人惊讶。

test.three?             // nil

这不是你可能在实际代码中使用的东西，因为它本质上是可选的链接，但在它之后没有任何东西。但是在这里，由于.three被隐式展开?具有＆＃34;重新包装＆＃34;它：结果的类型现在是String?。这在这里没什么区别，但是在test.three分配了String值之后，请查看下面的内容。

//test.three!           // ERROR: EXEC_BAD_INSTRUCTION

如上所述无法解开nil。这可能看起来令人困惑，因为声明通常被描述为产生一个隐含地展开的变量＆＃34 ;;但是如果它不是 nil＆＃34;那么它应该被理解为＆＃34;隐式解包。

test.three == nil       // true
test.three? == nil      // true
//test.three! == nil    // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

与上述2相同。如果你有一个强制解包的变量，一个？似乎没有强行打开它，这是我不建议的行为。尝试不经常使用强制解包的选项，如果你真的需要，主要是与部分UI有关。很多时候，当你不期待它时它会崩溃。

//test.three.isEmpty    // ERROR: EXEC_BAD_INSTRUCTION
test.three?.isEmpty     // nil
//test.three!.isEmpty   // ERROR: EXEC_BAD_INSTRUCTION

如果未指定可选项，则默认为nil。如果你然后试着强行打开它...我想你明白了。第一行和第三行尝试从nil上的String调用方法（在ObjC中工作，而不是Swift）。第二个使用可选链接在调用方法之前检查它是否为零，因为它知道它是零，所以它不能。

test.two = "???"        // {one "" {Some "???"} nil}
test.three = "!!!"      // {one "" {Some "???"} three "!!!"}

这会将test.two设为.Some("???")，test.three等于.Some("!!!")您看到的输出只会显示该类中保存的所有变量，以及它们的变化方式。< / p>

test.two                // {Some "???"}
test.two?               // {Some "???"}
test.two!               // "???"

test.two现在是.Some("???")，所以当你调用它时，返回的是：一个字符串？有价值的。强制解包时，它现在返回.Some中保存的值而不会崩溃，因为其中确实存在一个字符串。

test.two == nil         // false
test.two? == nil        // false

test.two仍然是可选的，所以在前两个中，当它将它们与nil进行比较时，它意识到，＆＃34;嘿，有.Some值，所以不是 nil。＆＃34;

//test.two! == nil      // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

强制解包值会从字符串中转换test.two的值？到一个字符串。字符串永远不会是零，因为如果它们是，它们将需要是可选的。将一个绝对是String的值与nil进行比较是没有意义的，因为你知道一个事实它不是nil;否则，程序会崩溃之前！

//test.two.isEmpty      // ERROR: String? does not have .isEmpty

test.two是String ?,而不是String。为了访问字符串本身，您需要确保它可以访问，使用？还是一个！

test.two?.isEmpty       // {Some false}

这说，＆＃34;如果test.two包含一个字符串（不是nil），则查找它是否为空。＆＃34;它说{Some false}因为你正在访问一个Optional的成员，而不是一个直接的String。

test.two!.isEmpty       // false

！，另一方面， 返回一个字符串。在字符串上调用.isEmpty可以是true或false，在这种情况下是false，因为您将其设置为非空字符串。

test.three              // "!!!"

test.three强制 - 从中​​解包String，在这种情况下，因为它有一个值，所以它可以工作。

test.three?             // {Some "!!!"}

您将此视为普通可选（不强制解包），因此您获得的是Some（String）而不仅仅是String。

test.three!             // "!!!"

由于你在声明中强行打开它，所以它在这里被强行打开。

test.three == nil       // false

这是另一种奇怪的行为，因为它应该是一个错误。它应该是一个String，无法与nil进行比较，但这里有一些古怪的东西。当我发现这件事时，我会回复你。

test.three? == nil      // false

将test.three视为普通可选项，并检查其状态是.None还是无。

//test.three! == nil    // ERROR: Cannot invoke == with an argument list of type (@lvalue String, NilLiteralConvertable)

上面的那两个应该是什么样的。无法将String与nil进行比较，因此会抛出错误。

test.three.isEmpty      // false

查看被强制输出的字符串值（存在;否则，它会崩溃）。该字符串不为空，因此它是错误的。

test.three?.isEmpty     // {Some false}

将其视为字符串？如果test.three不是nil，则它从.Some（一个String）获取值，并计算它是否为空，而不是。

test.three!.isEmpty     // false

String被强制退出可选项，isEmpty直接调用它。它不是空的，因此返回false。

我希望我能帮助澄清事情，我会告诉你为什么一个案例就是我自己找到的方式：]