“致命错误：在解开可选值时意外发现nil”是什么意思？

时间 2020-02-13

标签致命错误解开可选意外发现 nil 什么意思繁體版

原文原文链接

个人Swift程序因EXC_BAD_INSTRUCTION和如下错误而崩溃。这是什么意思，我该如何解决？ html

致命错误：解开Optional值时意外发现nil ios

^{该帖子旨在收集“意外发现的零”问题的答案，以使它们不会分散且很难找到。} ^{随意添加您本身的答案或编辑现有的Wiki答案。} 程序员

#1楼

^{这个答案是社区维基。} ^{若是您认为它能够作得更好，请随时对其进行编辑！} 编程

背景：什么是可选的？

在Swift中， Optional是一个泛型类型，能够包含一个值（任何类型），或者根本不包含任何值。 swift

在许多其余编程语言中，一般使用特定的“前哨”值来指示缺乏值 。例如，在Objective-C中， nil （空指针）指示缺乏对象。但这在处理原始类型时变得更加棘手-应该使用-1来指示缺乏整数，或者可能INT_MIN或其余某个整数吗？若是选择任何特定值表示“无整数”，则意味着它再也不能够视为有效值 。 api

Swift是一种类型安全的语言，这意味着该语言可帮助您弄清代码可使用的值的类型。若是代码的一部分须要一个字符串，则类型安全性可防止您误将其传递给Int。安全

在Swift中， 任何类型均可以设为optional 。可选的值能够从原始类型，任何值或特殊值nil 。闭包

可选用?定义? 类型的后缀： app

var anInt: Int = 42
var anOptionalInt: Int? = 42
var anotherOptionalInt: Int?    // `nil` is the default when no value is provided

nil表示可选项中缺乏值：编程语言

anOptionalInt = nil

^{（请注意，此nil与Objective-C中的nil 。在Objective-C中， nil是缺乏有效的对象指针；在Swift中，Optionals不限于对象/引用类型。Optional的行为相似于Haskell的行为也许。）}

为何会出现“ 致命错误：在展开可选值时意外发现nil ”？

为了访问可选值（若是它有一个值），您须要将其拆开。能够安全或强制打开可选值。若是强行解开一个可选值，但它没有值，则程序将崩溃，并显示以上消息。

Xcode将经过突出显示一行代码来向您显示崩溃。在这条线上发生问题。

两种不一样类型的强制展开会发生此崩溃：

1.显式展开力

这是用! 可选的运算符。例如：

let anOptionalString: String?
print(anOptionalString!) // <- CRASH

因为anOptionalString在此处nil ，所以您在强制展开它的行上会发生崩溃。

2.隐式展开的可选

这些用!定义! ，而不是? 类型以后。

var optionalDouble: Double!   // this value is implicitly unwrapped wherever it's used

假定这些可选参数包含一个值。所以，每当您访问隐式展开的可选内容时，它将自动为您强制展开。若是不包含值，它将崩溃。

print(optionalDouble) // <- CRASH

为了找出致使崩溃的变量，您能够在单击以显示定义时按住⌥ ，在这里能够找到可选类型。

特别是IBOutlet，一般是隐式解包的可选。这是由于您的xib或情节提要在初始化后将在运行时链接出口。所以，您应该确保在装入插座以前不要访问插座。还应该检查故事板/ xib文件中的链接是否正确，不然值在运行时将为nil ，所以在隐式包含它们时会崩溃解开。固定链接时，请尝试删除定义插座的代码行，而后从新链接它们。

我何时应该强制解开Optional？

显式展开力

一般，永远不要用!强制强行打开可选项! 操做员。在某些状况下，可能会使用! 是能够接受的，但只有在100％肯定可选值包含一个值的状况下，才应使用它。

虽然可能有某种状况下可使用武力展开，你也知道对于一个可选包含一个值一个事实 -没有一个单一的地方，你不能安全地打开那可选替代。

隐式展开的可选

设计这些变量是为了使您能够将它们的分配推迟到之后的代码中。您有责任在访问它们以前确保它们具备价值。可是，因为它们涉及强制展开，所以它们本质上仍然是不安全的，由于即便您指定nil有效，它们也会假定您的值不为nil。

您应仅将隐式解包的可选内容用做最后的选择 。若是您可使用惰性变量或为变量提供默认值，则应这样作，而不要使用隐式展开的可选变量。

可是，在某些状况下，隐式展开的可选内容是有好处的，而且您仍然可使用下面列出的各类方式来安全地展开它们-但始终应谨慎使用。

我如何安全地处理可选项目？

检查可选变量是否包含值的最简单方法是将其与nil比较。

if anOptionalInt != nil {
    print("Contains a value!")
} else {
    print("Doesn’t contain a value.")
}

可是，使用可选参数时，实际上99.9％的时间都须要访问它包含的值（若是它包含一个值）。为此，您可使用Optional Binding 。

可选装订

可选绑定容许您检查可选项是否包含值–并容许您将展开的值分配给新变量或常量。 if let x = anOptional {...}或if var x = anOptional {...} ，则使用语法，具体取决于绑定后是否须要修改新变量的值。

例如：

if let number = anOptionalInt {
    print("Contains a value! It is \(number)!")
} else {
    print("Doesn’t contain a number")
}

首先，请检查可选内容是否包含值。若是是，则将“ unwrapped”值分配给新变量（ number ）–而后您能够自由使用它，就像它是非可选的同样。若是可选参数不包含值，则将按照您的指望调用else子句。

关于可选绑定的巧妙之处在于，您能够同时解开多个可选对象。您能够只用逗号分隔语句。若是全部可选选项均未包装，则该语句将成功。

var anOptionalInt : Int?
var anOptionalString : String?

if let number = anOptionalInt, let text = anOptionalString {
    print("anOptionalInt contains a value: \(number). And so does anOptionalString, it’s: \(text)")
} else {
    print("One or more of the optionals don’t contain a value")
}

另外一个巧妙的技巧是，在展开值后，您还可使用逗号来检查该值的特定条件。

if let number = anOptionalInt, number > 0 {
    print("anOptionalInt contains a value: \(number), and it’s greater than zero!")
}

在if语句中使用可选绑定的惟一陷阱是，您只能从该语句的范围内访问未包装的值。若是须要从语句范围以外访问该值，则可使用guard语句 。

保护性语句使您能够定义成功的条件–只有知足该条件，当前做用域才会继续执行。它们用语法guard condition else {...} 。

所以，要将它们与可选绑定一块儿使用，能够执行如下操做：

guard let number = anOptionalInt else {
    return
}

^{（请注意，在防御体内，必须使用控制传递语句之一才能退出当前正在执行的代码的范围）。}

若是anOptionalInt包含一个值，则将其解开并分配给新的number常量。保护后的代码将继续执行。若是它不包含值，则保护程序将执行方括号内的代码，这将致使控制权的转移，所以紧随其后的代码将不会执行。

关于保护语句的真正精妙之处在于，展开后的值如今能够在该语句后的代码中使用（由于咱们知道，未来的代码只能在可选值具备值的状况下执行）。这对于消除经过嵌套多个if语句而建立的“厄运金字塔”很是有用。

例如：

guard let number = anOptionalInt else {
    return
}

print("anOptionalInt contains a value, and it’s: \(number)!")

警卫队还支持if语句支持的相同技巧，例如同时展开多个可选对象并使用where子句。

是否使用if或guard语句彻底取决于未来的任何代码是否要求可选变量包含值。

无合并运算符

Nil合并运算符是三元条件运算符的精简版本，主要用于将可选选项转换为非可选选项。它具备语法a ?? b a ?? b ，其中a是一个可选的类型和b是相同的类型a （尽管一般非可选）。

从本质上讲，您能够说“若是a包含一个值，则将其取消包装。若是没有，则返回b ”。例如，您能够这样使用它：

let number = anOptionalInt ?? 0

这将定义一个Int类型的number常量，若是包含一个值，则将包含anOptionalInt的值，不然将包含0 。

它只是如下方面的简写：

let number = anOptionalInt != nil ? anOptionalInt! : 0

可选连接

您可使用可选连接来调用方法或访问可选属性。只需在变量名后加上?便可完成此操做? 使用时。

例如，假设咱们有一个变量foo ，其类型为可选的Foo实例。

var foo : Foo?

若是咱们想在foo上调用不返回任何内容的方法，则能够简单地执行如下操做：

foo?.doSomethingInteresting()

若是foo包含一个值，则将在其上调用此方法。若是没有，则不会发生任何很差的事情-代码将继续继续执行。

^{（这相似于在Objective-C中将消息发送到nil行为）}

所以，这也能够用于设置属性以及调用方法。例如：

foo?.bar = Bar()

一样，若是foo为nil那么这里也不会发生任何很差的事情。您的代码将继续执行。

可选连接容许您执行的另外一种巧妙技巧是检查设置属性或调用方法是否成功。您能够经过将返回值与nil进行比较来作到这一点。

^{（这是由于可选值将返回Void?而不是不返回任何内容的方法上的Void ）}

例如：

if (foo?.bar = Bar()) != nil {
    print("bar was set successfully")
} else {
    print("bar wasn’t set successfully")
}

可是，在尝试访问属性或调用返回值的方法时，事情变得有些棘手。由于foo是可选的，因此从它返回的任何内容也将是可选的。为了解决这个问题，您能够解开使用上述方法之一返回的可选选项–或在访问返回值的方法或调用返回值的方法以前解开foo自己。

一样，顾名思义，您能够将这些语句“连接”在一块儿。这意味着，若是foo具备可选属性baz ，而该属性具备属性qux ，则能够编写如下代码：

let optionalQux = foo?.baz?.qux

一样，因为foo和baz是可选的，所以不管qux自己是否可选，从qux返回的值将始终是可选的。

`map`和`flatMap`

可选功能常用不足的功能是可使用map和flatMap函数。这些容许您将非可选转换应用于可选变量。若是可选值具备值，则能够对其应用给定的转换。若是没有值，它将保持nil 。

例如，假设您有一个可选的字符串：

let anOptionalString:String?

经过对其应用map函数–咱们可使用stringByAppendingString函数将其链接到另外一个字符串。

因为stringByAppendingString采用非可选字符串参数，所以咱们没法直接输入可选字符串。可是，经过使用map ，若是anOptionalString具备值，咱们可使用allow stringByAppendingString 。

例如：

var anOptionalString:String? = "bar"

anOptionalString = anOptionalString.map {unwrappedString in
    return "foo".stringByAppendingString(unwrappedString)
}

print(anOptionalString) // Optional("foobar")

可是，若是anOptionalString没有值，则map将返回nil 。例如：

var anOptionalString:String?

anOptionalString = anOptionalString.map {unwrappedString in
    return "foo".stringByAppendingString(unwrappedString)
}

print(anOptionalString) // nil

flatMap工做方式与map类似，不一样之处在于，它容许您从闭包体内返回另外一个可选内容。这意味着您能够将可选项输入到须要非可选输入的过程当中，但能够输出可选项自己。

`try!`

Swift的错误处理系统能够与Do-Try-Catch一块儿安全使用：

do {
    let result = try someThrowingFunc() 
} catch {
    print(error)
}

若是someThrowingFunc()引起错误，该错误将被安全地捕获在catch块中。

您没有在catch块中看到的error常量已经由咱们声明，它是catch自动生成的。

您也能够本身声明error ，它具备将其转换为有用格式的优势，例如：

do {
    let result = try someThrowingFunc()    
} catch let error as NSError {
    print(error.debugDescription)
}

以这种方式使用try是尝试，捕获和处理来自throwing函数的错误的正确方法。

还有try? 吸取错误：

if let result = try? someThrowingFunc() {
    // cool
} else {
    // handle the failure, but there's no error information available
}

可是Swift的错误处理系统还提供了一种经过try来“强制尝试”的方法try! ：

let result = try! someThrowingFunc()

这篇文章中解释的概念也适用于此：若是引起错误，则应用程序将崩溃。

您只能使用try! 若是您能够证实其结果在您的状况下永远不会失败-这是很是罕见的。

大多数时候，您将使用完整的Do-Try-Catch系统-可选系统，请try? ，在极少数状况下，处理错误并不重要。

资源资源

#2楼

这个问题出如今SO 全部的时间 。这是新的Swift开发人员面临的第一件事。

背景：

Swift使用“可选”的概念来处理可能包含值或不包含值的值。在其余语言（例如C）中，您可能会在变量中存储值0，以指示该变量不包含任何值。可是，若是0是有效值怎么办？而后，您可使用-1。若是-1是有效值怎么办？等等。

使用Swift可选控件，您能够设置任何类型的变量以包含有效值或不包含任何值。

当您声明要表示的变量（类型x，或没有值）时，您会在类型以后加上问号。

可选其实是一个容器，它包含给定类型的变量或不包含任何变量。

一个可选的须要被“解开”，以获取内部的值。

“！” 运算符是“强制展开”运算符。它说：“相信我。我知道我在作什么。我保证在这段代码运行时，变量将不包含nil。” 若是输入错误，则会崩溃。

除非你真的知道你在作什么，避免“！” 强制解开操做符。对于新手Swift程序员来讲，这多是最大的崩溃源。

如何处理可选项：

还有不少其余处理可选选项更安全的方法。这里有一些（不是详尽的清单）

您可使用“可选绑定”或“ if let”来表示“若是此可选包含值，则将该值保存到一个新的非可选变量中。若是可选不包含值，请跳过此if语句的主体”。

这是使用foo可选的可选绑定的示例：

if let newFoo = foo //If let is called optional binding. {
  print("foo is not nil")
} else {
  print("foo is nil")
}

请注意，您在使用可选出价时定义的变量仅在if语句的主体中存在（仅在“范围内”）。

或者，您可使用保护语句，若是变量为nil，则能够退出函数：

func aFunc(foo: Int?) {
  guard let newFoo = input else { return }
  //For the rest of the function newFoo is a non-optional var
}

在Swift 2中添加了Guard语句。Guard使您能够保留代码中的“黄金路径”，并避免嵌套的ifs级别不断提升，而嵌套的ifs有时是因为使用“ if let”可选绑定而致使的。

还有一个称为“零合并运算符”的构造。它采用“ optional_var ?? replace_val”的形式。它返回一个非可选变量，其类型与可选变量中包含的数据相同。若是可选包含nil，则返回“ ??”以后的表达式的值符号。

所以，您可使用以下代码：

let newFoo = foo ?? "nil" // "??" is the nil coalescing operator
print("foo = \(newFoo)")

您也可使用try / catch或guard错误处理，可是一般，上述其余技术之一更干净。

编辑：

另外一个带有可选内容的微妙陷阱是“隐式展开的可选内容。当咱们声明foo时，咱们能够说：

var foo: String!

在这种状况下，foo仍然是可选的，可是您没必要解开它便可引用它。这意味着您每次尝试引用foo时，若是nil为零，就会崩溃。

因此这段代码：

var foo: String!


let upperFoo = foo.capitalizedString

即便咱们不强制展开foo，引用foo的capitalizedString属性也会崩溃。打印看起来不错，但事实并不是如此。

所以，您要很是谨慎地使用隐式展开的可选内容。（甚至可能彻底避免使用它们，直到您对可选项有了深入的了解。）

底线：当您第一次学习Swift时，请伪装“！” 字符不是语言的一部分。可能会惹上您的麻烦。

#3楼

首先，您应该知道什么是可选值。您能够进入The Swift Programming Launage

有关详细信息。

其次，您应该知道可选值具备两个状态。一个是全值，另外一个是零值。所以，在实现可选值以前，应检查它的状态。

您可使用if let ...或guard let ... else等等。

另外一种方式，若是您不想在实现以前检查其状态，则还可使用var buildingName = buildingName ?? "buildingName" 改成使用var buildingName = buildingName ?? "buildingName" 。

#4楼

TL; DR答案

除了极少数例外，此规则是黄金：

避免使用`!`

声明变量optional（ `?` ），而不是隐式解包的optional（IUO）（ `!` ）

换句话说，请使用：
var nameOfDaughter: String?

代替：
var nameOfDaughter: String!

使用`if let`或`guard let`解开可选变量

像这样解开变量：

if let nameOfDaughter = nameOfDaughter {
    print("My daughters name is: \(nameOfDaughter)")
}

或像这样：

guard let nameOfDaughter = nameOfDaughter else { return }
print("My daughters name is: \(nameOfDaughter)")

该答案旨在简明扼要，以便全面理解已接受的答案

#5楼

因为以上答案清楚地说明了如何使用Optionals安全演奏。我将尽速解释什么是Optional。

声明可选变量的另外一种方法是

var i : Optional<Int>

可选类型不过是带有两种状况的枚举，即

enum Optional<Wrapped> : ExpressibleByNilLiteral {
    case none 
    case some(Wrapped)
    .
    .
    .
}

所以，给变量“ i”分配零。咱们能够作var i = Optional<Int>.none或分配一个值，咱们将传递一些值var i = Optional<Int>.some(28)

斯威夫特认为，“零”是价值的缺失。并建立一个以nil初始化的实例，咱们必须遵照一个称为ExpressibleByNilLiteral的协议，若是您猜对了，那就太好了，只有Optionals符合ExpressibleByNilLiteral而且不鼓励与其余类型兼容。

ExpressibleByNilLiteral具备一个称为init(nilLiteral:)的单一方法，该方法用nil初始化一个实例。一般，您不会调用此方法，而且根据swift文档，建议您每当使用nil文字量初始化Optional类型时，就不建议直接调用此初始化方法，由于编译器会调用它。

即便本身有包（没有双关语意）个人头周围选配：d 快乐Swfting全部 。