What does Fatal error Unexpectedly found nil while unwrapping an Optional value mean

Question

My Swift program is crashing with EXC BAD INSTRUCTION and one of the following similar errors  What does this error mean  and how do I fix it      Fatal error  Unexpectedly found nil while unwrapping an Optional value     or     Fatal error  Unexpectedly found nil while implicitly unwrapping an Optional value       This post is intended to collect answers to  unexpectedly found nil  issues  so that they are not scattered and hard to find  Feel free to add your own answer or edit the existing wiki answer

User · Answer

I came across this error while making a segue from a table view controller to a view controller because I had forgotten to specify the custom class name for the view controller in the main storyboard.

Something simple that is worth checking if all else looks ok

User · Answer

TL DR answer With very few exceptions  this rule is golden  Avoid use of   Declare variable optional      not implicitly unwrapped optionals  IUO      In other words  rather use  var nameOfDaughter  String  Instead of  var nameOfDaughter  String  Unwrap optional variable using if let or guard let Either unwrap variable like this  if let nameOfDaughter   nameOfDaughter       print  quot My daughters name is    nameOfDaughter  quot      Or like this  guard let nameOfDaughter   nameOfDaughter else   return   print  quot My daughters name is    nameOfDaughter  quot    This answer was intended to be concise  for full comprehension read accepted answer  Resources  Avoiding force unwrapping

User · Answer

The errors EXC BAD INSTRUCTION and fatal error  unexpectedly found nil while implicitly unwrapping an Optional value appears the most when you have declared an  IBOutlet  but not connected to the storyboard   You should also learn about how Optionals work  mentioned in other answers  but this is the only time that mostly appears to me

User · Answer

Basically you tried to use a nil value in places where Swift allows only non-nil ones, by telling the compiler to trust you that there will never be nil value there, thus allowing your app to compile.

There are several scenarios that lead to this kind of fatal error:

forced unwraps:
```
let user = someVariable!
```
If someVariable is nil, then you'll get a crash. By doing a force unwrap you moved the nil check responsibility from the compiler to you, basically by doing a forced unwrap you're guaranteeing to the compiler that you'll never have nil values there. And guess what it happens if somehow a nil value ends in in someVariable?

Solution? Use optional binding (aka if-let), do the variable processing there:
```
if user = someVariable {
    // do your stuff
}
```
forced (down)casts:
```
let myRectangle = someShape as! Rectangle
```
Here by force casting you tell the compiler to no longer worry, as you'll always have a Rectangle instance there. And as long as that holds, you don't have to worry. The problems start when you or your colleagues from the project start circulating non-rectangle values.

Solution? Use optional binding (aka if-let), do the variable processing there:
```
if let myRectangle = someShape as? Rectangle {
    // yay, I have a rectangle
}
```
Implicitly unwrapped optionals. Let's assume you have the following class definition:
```
class User {
    var name: String!

    init() {
        name = "(unnamed)"
    }

    func nicerName() {
        return "Mr/Ms " + name
    }
}
```
Now, if no-one messes up with the name property by setting it to nil, then it works as expected, however if User is initialized from a JSON that lacks the name key, then you get the fatal error when trying to use the property.

Solution? Don't use them :) Unless you're 102% sure that the property will always have a non-nil value by the time it needs to be used. In most cases converting to an optional or non-optional will work. Making it non-optional will also result in the compiler helping you by telling the code paths you missed giving a value to that property
Unconnected, or not yet connected, outlets. This is a particular case of scenario #3. Basically you have some XIB-loaded class that you want to use.
```
class SignInViewController: UIViewController {

    @IBOutlet var emailTextField: UITextField!
}
```
Now if you missed connecting the outlet from the XIB editor, then the app will crash as soon as you'll want to use the outlet. Solution? Make sure all outlets are connected. Or use the ? operator on them: emailTextField?.text = "[email protected]". Or declare the outlet as optional, though in this case the compiler will force you to unwrap it all over the code.
Values coming from Objective-C, and that don't have nullability annotations. Let's assume we have the following Objective-C class:
```
@interface MyUser: NSObject
@property NSString *name;
@end
```
Now if no nullability annotations are specified (either explicitly or via NS_ASSUME_NONNULL_BEGIN/NS_ASSUME_NONNULL_END), then the name property will be imported in Swift as String! (an IUO - implicitly unwrapped optional). As soon as some swift code will want to use the value, it will crash if name is nil.

Solution? Add nullability annotations to your Objective-C code. Beware though, the Objective-C compiler is a little bit permissive when it comes to nullability, you might end up with nil values, even if you explicitly marked them as nonnull.

User · Answer

This answer is community wiki  If you feel it could be made better  feel free to edit it  Background  What   s an Optional  In Swift  Optional lt Wrapped gt  is an option type  it can contain any value from the original   quot Wrapped quot   type  or no value at all  the special value nil   An optional value must be unwrapped before it can be used  Optional is a generic type  which means that Optional lt Int gt  and Optional lt String gt  are distinct types     the type inside  lt  gt  is called the Wrapped type  Under the hood  an Optional is an enum with two cases   some Wrapped  and  none  where  none is equivalent to nil  Optionals can be declared using the named type Optional lt T gt   or  most commonly  as a shorthand with a   suffix  var anInt  Int   42 var anOptionalInt  Int    42 var anotherOptionalInt  Int       nil  is the default when no value is provided var aVerboseOptionalInt  Optional lt Int gt      equivalent to  Int    anOptionalInt   nil    now this variable contains nil instead of an integer  Optionals are a simple yet powerful tool to express your assumptions while writing code  The compiler can use this information to prevent you from making mistakes  From The Swift Programming Language   Swift is a type-safe language  which means the language helps you to be clear about the types of values your code can work with  If part of your code requires a String  type safety prevents you from passing it an Int by mistake  Likewise  type safety prevents you from accidentally passing an optional String to a piece of code that requires a non-optional String  Type safety helps you catch and fix errors as early as possible in the development process   Some other programming languages also have generic option types  for example  Maybe in Haskell  option in Rust  and optional in C  17  In programming languages without option types  a particular  quot sentinel quot  value is often used to indicate the absence of a valid value  In Objective-C  for example  nil  the null pointer  represents the lack of an object  For primitive types such as int  a null pointer can t be used  so you would need either a separate variable  such as value  Int and isValid  Bool  or a designated sentinel value  such as -1 or INT MIN   These approaches are error-prone because it s easy to forget to check isValid or to check for the sentinel value  Also  if a particular value is chosen as the sentinel  that means it can no longer be treated as a valid value  Option types such as Swift s Optional solve these problems by introducing a special  separate nil value  so you don t have to designate a sentinel value   and by leveraging the strong type system so the compiler can help you remember to check for nil when necessary   Why did I get    fatal error  unexpectedly found nil while unwrapping an Optional value     In order to access an optional   s value  if it has one at all   you need to unwrap it  An optional value can be unwrapped safely or forcibly  If you force-unwrap an optional  and it didn t have a value  your program will crash with the above message  Xcode will show you the crash by highlighting a line of code  The problem occurs on this line   This crash can occur with two different kinds of force-unwrap  1  Explicit Force Unwrapping This is done with the   operator on an optional  For example  let anOptionalString  String  print anOptionalString       lt - CRASH   Fatal error  Unexpectedly found nil while unwrapping an Optional value  As anOptionalString is nil here  you will get a crash on the line where you force unwrap it  2  Implicitly Unwrapped Optionals These are defined with  a    rather than a   after the type  var optionalDouble  Double       this value is implicitly unwrapped wherever it s used  These optionals are assumed to contain a value  Therefore whenever you access an implicitly unwrapped optional  it will automatically be force unwrapped for you  If it doesn   t contain a value  it will crash  print optionalDouble      lt - CRASH   Fatal error  Unexpectedly found nil while implicitly unwrapping an Optional value  In order to work out which variable caused the crash  you can hold   while clicking to show the definition  where you might find the optional type   IBOutlets  in particular  are usually implicitly unwrapped optionals  This is because your xib or storyboard will link up the outlets at runtime  after initialization  You should therefore ensure that you   re not accessing outlets before they re loaded in  You also should check that the connections are correct in your storyboard xib file  otherwise the values will be nil at runtime  and therefore crash when they are implicitly unwrapped  When fixing connections  try deleting the lines of code that define your outlets  then reconnect them   When should I ever force unwrap an Optional  Explicit Force Unwrapping As a general rule  you should never explicitly force unwrap an optional with the   operator  There may be cases where using   is acceptable     but you should only ever be using it if you are 100  sure that the optional contains a value  While there may be an occasion where you can use force unwrapping  as you know for a fact that an optional contains a value     there is not a single place where you cannot safely unwrap that optional instead   Implicitly Unwrapped Optionals These variables are designed so that you can defer their assignment until later in your code  It is your responsibility to ensure they have a value before you access them  However  because they involve force unwrapping  they are still inherently unsafe     as they assume your value is non-nil  even though assigning nil is valid  You should only be using implicitly unwrapped optionals as a last resort  If you can use a lazy variable  or provide a default value for a variable     you should do so instead of using an implicitly unwrapped optional  However  there are a few scenarios where implicitly unwrapped optionals are beneficial  and you are still able to use various ways of safely unwrapping them as listed below     but you should always use them with due caution   How can I safely deal with Optionals  The simplest way to check whether an optional contains a value  is to compare it to nil  if anOptionalInt    nil       print  quot Contains a value  quot     else       print  quot Doesn   t contain a value  quot      However  99 9  of the time when working with optionals  you   ll actually want to access the value it contains  if it contains one at all  To do this  you can use Optional Binding  Optional Binding Optional Binding allows you to check if an optional contains a value     and allows you to assign the unwrapped value to a new variable or constant  It uses the syntax if let x   anOptional       or if var x   anOptional        depending if you need to modify the value of the new variable after binding it  For example  if let number   anOptionalInt       print  quot Contains a value  It is   number   quot     else       print  quot Doesn   t contain a number quot      What this does is first check that the optional contains a value  If it does  then the    unwrapped    value is assigned to  a new variable  number      which you can then freely use as if it were non-optional  If the optional doesn   t contain a value  then the else clause will be invoked  as you would expect  What   s neat about optional binding  is you can unwrap multiple optionals at the same time  You can just separate the statements with a comma  The statement will succeed if all the optionals were unwrapped  var anOptionalInt   Int  var anOptionalString   String   if let number   anOptionalInt  let text   anOptionalString       print  quot anOptionalInt contains a value    number   And so does anOptionalString  it   s    text  quot     else       print  quot One or more of the optionals don   t contain a value quot      Another neat trick is that you can also use commas to check for a certain condition on the value  after unwrapping it  if let number   anOptionalInt  number  gt  0       print  quot anOptionalInt contains a value    number   and it   s greater than zero  quot      The only catch with using optional binding within an if statement  is that you can only access the unwrapped value from within the scope of the statement  If you need access to the value from outside of the scope of the statement  you can use a guard statement  A guard statement allows you to define a condition for success     and the current scope will only continue executing if that condition is met  They are defined with the syntax guard condition else        So  to use them with an optional binding  you can do this  guard let number   anOptionalInt else       return     Note that within the guard body  you must use one of the control transfer statements in order to exit the scope of the currently executing code   If anOptionalInt contains a value  it will be unwrapped and assigned to the new number constant  The code after the guard will then continue executing  If it doesn   t contain a value     the guard will execute the code within the brackets  which will lead to transfer of control  so that the code immediately after will not be executed  The real neat thing about guard statements is the unwrapped value is now available to use in code that follows the statement  as we know that future code can only execute if the optional has a value   This is a great for eliminating    pyramids of doom    created by nesting multiple if statements  For example  guard let number   anOptionalInt else       return    print  quot anOptionalInt contains a value  and it   s    number   quot    Guards also support the same neat tricks that the if statement supported  such as unwrapping multiple optionals at the same time and using the where clause  Whether you use an if or guard statement completely depends on whether any future code requires the optional to contain a value  Nil Coalescing Operator The Nil Coalescing Operator is a nifty shorthand version of the ternary conditional operator  primarily designed to convert optionals to non-optionals  It has the syntax a    b  where a is an optional type and b is the same type as a  although usually non-optional   It essentially lets you say    If a contains a value  unwrap it  If it doesn   t then return b instead     For example  you could use it like this  let number   anOptionalInt    0  This will define a number constant of Int type  that will either contain the value of anOptionalInt  if it contains a value  or 0 otherwise  It   s just shorthand for  let number   anOptionalInt    nil   anOptionalInt    0  Optional Chaining You can use Optional Chaining in order to call a method or access a property on an optional  This is simply done by suffixing the variable name with a   when using it  For example  say we have a variable foo  of type an optional Foo instance  var foo   Foo   If we wanted to call a method on foo that doesn   t return anything  we can simply do  foo  doSomethingInteresting    If foo contains a value  this method will be called on it  If it doesn   t  nothing bad will happen     the code will simply continue executing   This is similar behaviour to sending messages to nil in Objective-C  This can therefore also be used to set properties as well as call methods  For example  foo  bar   Bar    Again  nothing bad will happen here if foo is nil  Your code will simply continue executing  Another neat trick that optional chaining lets you do is check whether setting a property or calling a method was successful  You can do this by comparing the return value to nil   This is because an optional value will return Void  rather than Void on a method that doesn   t return anything  For example  if  foo  bar   Bar       nil       print  quot bar was set successfully quot     else       print  quot bar wasn   t set successfully quot      However  things become a little bit more tricky when trying to access properties or call methods that return a value  Because foo is optional  anything returned from it will also be optional  To deal with this  you can either unwrap the optionals that get returned using one of the above methods     or unwrap foo itself before accessing methods or calling methods that return values  Also  as the name suggests  you can    chain    these statements together  This means that if foo has an optional property baz  which has a property qux     you could write the following  let optionalQux   foo  baz  qux  Again  because foo and baz are optional  the value returned from qux will always be an optional regardless of whether qux itself is optional  map and flatMap An often underused feature with optionals is the ability to use the map and flatMap functions  These allow you to apply non-optional transforms to optional variables  If an optional has a value  you can apply a given transformation to it  If it doesn   t have a value  it will remain nil  For example  let   s say you have an optional string  let anOptionalString String   By applying the map function to it     we can use the stringByAppendingString function in order to concatenate it to another string  Because stringByAppendingString takes a non-optional string argument  we cannot input our optional string directly  However  by using map  we can use allow stringByAppendingString to be used if anOptionalString has a value  For example  var anOptionalString String     quot bar quot   anOptionalString   anOptionalString map  unwrappedString in     return  quot foo quot  stringByAppendingString unwrappedString     print anOptionalString     Optional  quot foobar quot    However  if anOptionalString doesn   t have a value  map will return nil  For example  var anOptionalString String   anOptionalString   anOptionalString map  unwrappedString in     return  quot foo quot  stringByAppendingString unwrappedString     print anOptionalString     nil  flatMap works similarly to map  except it allows you to return another optional from within the closure body  This means you can input an optional into a process that requires a non-optional input  but can output an optional itself  try  Swift s error handling system can be safely used with Do-Try-Catch  do       let result   try someThrowingFunc      catch       print error     If someThrowingFunc   throws an error  the error will be safely caught in the catch block  The error constant you see in the catch block has not been declared by us - it s automatically generated by catch  You can also declare error yourself  it has the advantage of being able to cast it to a useful format  for example  do       let result   try someThrowingFunc         catch let error as NSError       print error debugDescription     Using try this way is the proper way to try  catch and handle errors coming from throwing functions  There s also try  which absorbs the error  if let result   try  someThrowingFunc            cool   else          handle the failure  but there s no error information available    But Swift s error handling system also provides a way to  quot force try quot  with try   let result   try  someThrowingFunc    The concepts explained in this post also apply here  if an error is thrown  the application will crash  You should only ever use try  if you can prove that its result will never fail in your context - and this is very rare  Most of the time you will use the complete Do-Try-Catch system - and the optional one  try   in the rare cases where handling the error is not important   Resources  Apple documentation on Swift Optionals When to use and when not to use implicitly unwrapped optionals Learn how to debug an iOS app crash

User · Answer

I had this error once when I was trying to set my Outlets values from the prepare for segue method as follows:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let destination = segue.destination as? DestinationVC{

        if let item = sender as? DataItem{
            // This line pops up the error
            destination.nameLabel.text = item.name
        }
    }
}

Then I found out that I can't set the values of the destination controller outlets because the controller hasn't been loaded or initialized yet.

So I solved it this way:

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let destination = segue.destination as? DestinationVC{

        if let item = sender as? DataItem{
            // Created this method in the destination Controller to update its outlets after it's being initialized and loaded
            destination.updateView(itemData:  item)
        }
    }
}

Destination Controller:

// This variable to hold the data received to update the Label text after the VIEW DID LOAD
var name = ""

// Outlets
@IBOutlet weak var nameLabel: UILabel!

override func viewDidLoad() {
    super.viewDidLoad()

    // Do any additional setup after loading the view.
    nameLabel.text = name
}

func updateView(itemDate: ObjectModel) {
    name = itemDate.name
}

I hope this answer helps anyone out there with the same issue as I found the marked answer is great resource to the understanding of optionals and how they work but hasn't addressed the issue itself directly.

User · Answer

Since the above answers clearly explains how to play safely with Optionals. I will try explain what Optionals are really in swift.

Another way to declare an optional variable is

var i : Optional<Int>

And Optional type is nothing but an enumeration with two cases, i.e

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

So to assign a nil to our variable 'i'. We can do var i = Optional<Int>.none or to assign a value, we will pass some value var i = Optional<Int>.some(28)

According to swift, 'nil' is the absence of value. And to create an instance initialized with nil We have to conform to a protocol called ExpressibleByNilLiteral and great if you guessed it, only Optionals conform to ExpressibleByNilLiteral and conforming to other types is discouraged.

ExpressibleByNilLiteral has a single method called init(nilLiteral:) which initializes an instace with nil. You usually wont call this method and according to swift documentation it is discouraged to call this initializer directly as the compiler calls it whenever you initialize an Optional type with nil literal.

Even myself has to wrap (no pun intended) my head around Optionals :D Happy Swfting All.

User · Answer

This is more of a important comment and that why implicitly unwrapped optionals can be deceptive when it comes to debugging nil values.

Think of the following code: It compiles with no errors/warnings:

c1.address.city = c3.address.city

Yet at runtime it gives the following error: Fatal error: Unexpectedly found nil while unwrapping an Optional value

Can you tell me which object is nil?

You can't!

The full code would be:

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        var c1 = NormalContact()
        let c3 = BadContact()

        c1.address.city = c3.address.city // compiler hides the truth from you and then you sudden get a crash
    }
}

struct NormalContact {
    var address : Address = Address(city: "defaultCity")
}

struct BadContact {
    var address : Address!
}

struct Address {
    var city : String
}

Long story short by using var address : Address! you're hiding the possibility that a variable can be nil from other readers. And when it crashes you're like "what the hell?! my address isn't an optional, so why am I crashing?!.

Hence it's better to write as such:

c1.address.city = c2.address!.city  // ERROR:  Fatal error: Unexpectedly found nil while unwrapping an Optional value

Can you now tell me which object it is that was nil?

This time the code has been made more clear to you. You can rationalize and think that likely it's the address parameter that was forcefully unwrapped.

The full code would be :

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        var c1 = NormalContact()
        let c2 = GoodContact()

        c1.address.city = c2.address!.city
        c1.address.city = c2.address?.city // not compile-able. No deceiving by the compiler
        c1.address.city = c2.address.city // not compile-able. No deceiving by the compiler
        if let city = c2.address?.city {  // safest approach. But that's not what I'm talking about here. 
            c1.address.city = city
        }

    }
}

struct NormalContact {
    var address : Address = Address(city: "defaultCity")
}

struct GoodContact {
    var address : Address?
}

struct Address {
    var city : String
}

User · Answer

First  you should know what an Optional value is  You can step to The Swift Programming Language for detail   Second  you should know the optional value has two statuses  One is the full value  and the other is a nil value  So before you implement an optional value  you should check which state it is   You can use if let     or guard let     else and so on   One other way  if you don t want to check the variable state before your implementation  you can also use var buildingName   buildingName     buildingName  instead

User · Answer

If you get this error in CollectionView try to create CustomCell file and Custom xib also.

add this code in ViewDidLoad() at mainVC.

    let nib = UINib(nibName: "CustomnibName", bundle: nil)
    self.collectionView.register(nib, forCellWithReuseIdentifier: "cell")

User · Answer

This question comes up ALL THE TIME on SO  It s one of the first things that new Swift developers struggle with  Background  Swift uses the concept of  quot Optionals quot  to deal with values that could contain a value  or not  In other languages like C  you might store a value of 0 in a variable to indicate that it contains no value  However  what if 0 is a valid value  Then you might use -1  What if -1 is a valid value  And so on  Swift optionals let you set up a variable of any type to contain either a valid value  or no value  You put a question mark after the type when you declare a variable to mean  type x  or no value   An optional is actually a container than contains either a variable of a given type  or nothing  An optional needs to be  quot unwrapped quot  in order to fetch the value inside  The  quot   quot  operator is a  quot force unwrap quot  operator  It says  quot trust me  I know what I am doing  I guarantee that when this code runs  the variable will not contain nil  quot  If you are wrong  you crash  Unless you really do know what you are doing  avoid the  quot   quot  force unwrap operator  It is probably the largest source of crashes for beginning Swift programmers  How to deal with optionals  There are lots of other ways of dealing with optionals that are safer  Here are some  not an exhaustive list  You can use  quot optional binding quot  or  quot if let quot  to say  quot if this optional contains a value  save that value into a new  non-optional variable  If the optional does not contain a value  skip the body of this if statement quot   Here is an example of optional binding with our foo optional  if let newFoo   foo   If let is called optional binding      print  quot foo is not nil quot     else     print  quot foo is nil quot      Note that the variable you define when you use optional biding only exists  is only  quot in scope quot   in the body of the if statement  Alternately  you could use a guard statement  which lets you exit your function if the variable is nil  func aFunc foo  Int       guard let newFoo   input else   return       For the rest of the function newFoo is a non-optional var    Guard statements were added in Swift 2  Guard lets you preserve the  quot golden path quot  through your code  and avoid ever-increasing levels of nested ifs that sometimes result from using  quot if let quot  optional binding  There is also a construct called the  quot nil coalescing operator quot   It takes the form  quot optional var    replacement val quot   It returns a non-optional variable with the same type as the data contained in the optional  If the optional contains nil  it returns the value of the expression after the  quot    quot  symbol  So you could use code like this  let newFoo   foo     quot nil quot      quot    quot  is the nil coalescing operator print  quot foo     newFoo  quot    You could also use try catch or guard error handling  but generally one of the other techniques above is cleaner  EDIT  Another  slightly more subtle gotcha with optionals is  quot implicitly unwrapped optionals  When we declare foo  we could say  var foo  String   In that case foo is still an optional  but you don t have to unwrap it to reference it   That means any time you try to reference foo  you crash if it s nil  So this code  var foo  String    let upperFoo   foo capitalizedString  Will crash on reference to foo s capitalizedString property even though we re not force-unwrapping foo  the print looks fine  but it s not  Thus you want to be really careful with implicitly unwrapped optionals    and perhaps even avoid them completely until you have a solid understanding of optionals   Bottom line  When you are first learning Swift  pretend the  quot   quot  character is not part of the language  It s likely to get you into trouble

[swift] What does "Fatal error: Unexpectedly found nil while unwrapping an Optional value" mean?

The answer is

TL;DR answer

Avoid use of `!`

Declare variable optional (`?`), not implicitly unwrapped optionals (IUO) (`!`)

Unwrap optional variable using `if let` or `guard let`

Resources

Background:

How to deal with optionals:

EDIT:

Examples related to swift

Examples related to exception

Examples related to error-handling

Tags