An optional is a variable or constant that can hold either a value or “nil”, which represents the absence of a value. This means that when you declare a variable or constant as an optional, you are telling Swift that there may or may not be a value.

Anything or nothing

• An optional is like having a box to hold something, but sometimes there might not be anything in the box.
• It’s like you tell Swift that you might have something, but you also might have nothing.
• Just like how sometimes you might have a toy to play with, but sometimes you might not have any toy to play with.

Let’s take a look to a few examples of using optionals in Swift:

Declaring an optional variable

var age: Int? = nil        
var name: String? = "Bob"

• var age: Int? = nil
  • This line declares and initializes an optional variable called age of type Int.
  • The question mark after the type indicates that age can be “nil”, which means it may or may not have a value.
  • “= nil” initializes the age variable to nil.
  • age is an optional that (in this case) has no value
• var name: String? = “Bob”
  • This line declares and initializes another optional variable called “name” of type “String”.
  • The question mark “?” after the type again indicates that name can be “nil”, which means it may or may not have a value.
  • “= “Bob”” initializes the name variable with the value “Bob”.
  • name is an optional that (in this case) has a value of “Bob”

Unwrapping an optional using optional binding

In programming, sometimes we have special boxes that may or may not have something inside them. We call these boxes “optional”.

• Optional binding is like checking if there’s something inside the box, and if there is, we take it out and put it in a new box that we know has something in it.
• This helps us make sure we only use boxes that have something in them, and not boxes that are empty.

var age: Int? = 30
if let ageValue = age {
  print("Age is: \(ageValue)")
} else {
  print("No age value")
}

// Output: "Age is: 30"

• var age: Int? = 30
  • This line declares and initializes an optional variable called age of type Int.
  • The question mark “?” after the type indicates that age can be “nil”, which means it may or may not have a value.
  • ” = 30″ initializes the age variable with the value 30.
• if let ageValue = age
  • This is the “optional binding” statement treated in our example
  • It tests whether “age” has a value, and if it does, it assigns that value to a new constant called “ageValue”.
  • The “let” keyword is used to create a new constant, and the optional variable “age” is unwrapped to get its underlying value.
  • If the unwrapping is successful (meaning, if age has a value), the code inside the if block will be executed.
• print(“Age is: \(ageValue)”)
  • This line prints the value of the new constant “ageValue” inside a string making use of string interpolation.
  • The output is: “Age is: 30”.
• } else {
  • If the optional binding in line 2 fails (meaning age is nil), then the code inside the else block will be executed.
• print(“No age value”)
  • This line simply prints the string “No age value” to the console.

Implicitly unwrapped optionals

“Implicitly unwrapped optionals” are a type of optional that are like special boxes that we tell the computer to open automatically, without us having to do it every time.

• It’s like having a present that’s wrapped up, but you already know what’s inside, so you don’t have to unwrap it every time you want to see.

var name: String! = "Bob"
print("Name is: \(name)")

// Output: "Name is: Bob"

• var name: String! = “Bob”
  • This line is like having a box called “name” that can only hold text. We put the name “Bob” inside the box.
  • The “!” symbol means that we are telling the computer to automatically open the box and show us what’s inside (even though it might be empty).
  • It’s like having a secret code that tells the computer to not worry about checking if there’s anything inside the box before it opens it.
  • But we have to be careful with this because there might not be anything inside the box after all!
• print(“Name is: \(name)”)
  • This line shows us what’s inside the “name” box.
  • It prints out the text “Name is: Bob” on the screen.

Quick notes

• Optionals are a way to represent a value that may or may not be present. It’s like having a box that may or may not have something inside it.
• The main benefit of using optionals is to prevent runtime errors when trying to access a value that is not there.
• Optionals can be declared with either a question mark “?” or an exclamation mark “!”.
  • The question mark “?”creates a regular optional
  • while the exclamation mark “!” creates an implicitly unwrapped optional.
• Implicitly unwrapped optionals are like regular optionals, but they automatically unwrap when accessed, which can lead to runtime errors if the value is nil.
• Using if-let statements to unwrap an optional allows us to check whether the optional has a value or not before accessing it.