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

This error is very frequent as you can see many times while writing code. Don't worry, you will understand this error in detail in this article.

Before jumping to the cause of this error, let's understand what is optional in Swift.

Optional

Initially, when we receive a value from another source, such as the backend server, it might contain a valid value or nothing at all. In that case, you use optionals that represent a variable with two possible situations: either a value or no value at all.

var possibleNumber = "450"
var convertedNumber = Int(possibleNumber)

In the above example, there is an input string that we are converting into an Int. However, this string might or might not be a valid integer number. In that case, once we convert this string into an integer using the Int() function, it will return an optional integer value. This means the output can be nil or a valid integer value.

In Swift, an optional value is a type that can either hold a value or nil, which indicates the absence of a value. Optionals are used to handle cases where a value may be absent.

Cause of this Error?

To access the value of an optional, you can unwrap it using the exclamation (!) operator. However, if you try to unwrap an optional that is nil, it will trigger a runtime error. This error is usually caused by a bug in the code. This bug is attempting to unwrap an optional value that has not been properly initialized or that has been set to nil.

What is the Fix?

To fix this error, you need to find the source of the nil optional value and make sure that it is properly initialized with a non-nil value before you try to unwrap it. Alternatively, you can use optional binding or the nil-coalescing operator (??) to safely unwrap the optional and provide a default value if it is nil.

Example

var optionalMessage: String?

// This will trigger the "Unexpectedly found nil" error

// let unwrappedMessage = optionalMessage!

// Use optional binding to safely unwrap the optional and assign its
value to a constant
if let message = optionalMessage {
   print("message found: \(message)")
} else {
   print("message not found as it might be nil")
}

// Use the nil-coalescing operator to provide a default value if optionalMessage is nil
let unwrappedMessage = optionalMessage ?? "NA"
print(unwrappedMessage)

Output

message not found as it might be nil
unwrappedMessage: NA

Conclusion

This error is very easy to handle. However, it is always recommended to unwrap the value from an optional variable using optional binding to retrieve the value safely.

Make it a habit to avoid the use of force unwrapping in your code. When you are damn sure about the optional variable, you can use force unwrapping. In any case, optional binding or nil-coalescing operators are always good choices.