What are Optionals in Swift? – Donny Wals

In an earlier article, I defined how variables are outlined in Swift utilizing let and var. Each constants (let) and variables (var) in Swift all the time have a kind; it is what makes Swift a strongly typed language.

For instance, we may outline a String variable like this:

// the compiler will know myString is a String
var myString = "Hiya, world"

// we're explicitly telling the compiler that myString2 is a String
var myString2: String = "Hiya, world"

This fashion of defining variables makes a whole lot of sense when it is potential to instantly assign a worth to our variable.

Nonetheless, generally you may write code the place it isn’t potential to assign a worth to your variable instantly. Otherwise you’re working with capabilities which will or could not have the ability to return a legitimate worth.

In Swift, we name values that may distiguish betwene having a worth and never having a worth an Non-obligatory. Earlier than we dig too deeply into how we work with optionals, let’s discover the distinction between “no worth” and “default” worth in order that we perceive precisely why optionals exist within the first place.

The distinction between a default worth and no worth

In programming, working with an idea known as null or as Swift calls it nil will typically imply {that a} variable or a perform’s return worth may be “nothing”. There’s a whole lot of technical baggage surrounding the terminology however as a way to set up working information, we can’t dig into that too deeply.

The vital factor to grasp right here is that defining an empty String like this: var myString = "" defines a String with a default worth. The worth is empty however the var myString is holding on to some information that can signify an empty String. Typically this can be a completely superb selection.

Now let’s take into account a distinct instance the place a default worth could be loads tougher to outline.

var theUser: Person = ???

Our Person object cannot be created with out enter from different sources. And this enter may not be current at the moment that we outline our variable. We’ll want a solution to outline this var theUser with no information moderately than a default worth.

An actual world analogy you may consider is the next. If you sit down at a restaurant for some drinks, you’ll initially haven’t any glasses or cups in your desk. Because of this, your waiter will know that you have not been served something in any respect in order that they’ll know to go over and hand you a menu, introduce themselves and see whether or not they can take any orders. As soon as you’ve got been served you might need some empty glasses in your desk. The waiter will now know to ask to refill or take a distinct order.

This can be a demonstration of how no worth (no glass on the desk) and an empty worth (empty glasses on the desk) can have important variations in that means they usually cannot all the time be used interchangeably.

In Swift, we specific the power of a property having no worth moderately than a default worth by defining an non-compulsory Person object:

var theUser: Person?

The ? after our Person tells the compiler that var theUser will both include a worth of kind Person or it’ll maintain nothing in any respect (we name this nil).

It is good to know that the ? is a extra handy to jot down the next:

var theUser: Non-obligatory

Whereas the 2 methods of defining theUser do the identical factor, it is best apply to jot down var theUser: Person?. It is simpler to learn and quicker to jot down.

Observe that each one varieties in Swift may be written as an non-compulsory. For instance, for those who’re defining a String that may should be initialized as “no worth” you might write: var theString: String?.

The primary distinction between “no worth” and “default worth” is usually whether or not there’s any semantic that means to pointing at nothing or pointing to a default worth. For instance, an non-compulsory Bool (Bool?) virtually by no means is sensible; in most eventualities it is possible for you to to select a wise default worth that is protected to make use of. In different circumstances, one thing being empty or lacking may point out that enter from the person is required, or that it’s worthwhile to fetch information from an exterior supply and it isn’t potential or affordable to offer a default worth.

Now that you know the way to jot down non-compulsory properties, let’s have a look at how optionals are utilized in Swift.

Utilizing optionals in your code

As soon as you’ve got outlined an non-compulsory worth in Swift, it is vital that we deal with the potential of a worth being nil in addition to the worth being non-nil. Swift is fairly strict about this so optionals aren’t utilized in the identical means as you’d use regular variables or constants.

For instance, if we take into account the theUser variable from earlier, we will not learn the title from this property like this:

var theUser: Person?

// Worth of non-compulsory kind 'Person?' have to be unwrapped to confer with member 'title' of wrapped base kind 'Person'
print(theUser.title)

The Swift compiler will inform us that we have to “unwrap” worth of non-compulsory kind Person? as a way to entry its member title. That is the compiler’s means of telling us that theUser could or is probably not nil so we have to deal with each eventualities.

Let’s check out severals methods by which we will “unwrap” our non-compulsory.

Unwrapping with if let

If we’re writing code the place we wish to solely execute part of our script or perform in case the worth is not nil, we will use one thing known as an if let unwrap. Here is what that appears like:

var theUser: Person?

// elsewhere within the code...
if let userValue = theUser {
  print(userValue.title)
} else {
  print("the person is nil")
}

This if let makes an attempt to learn theUser and we assign it to a relentless. This fixed is then made out there inside the if’s physique the place we all know that userValue is of kind Person. Exterior of our if physique we can’t have the ability to entry userValue; it is solely made out there inside the if. As wanted, we will present an else to deal with eventualities the place theUser is nil.

Observe that the code above might be simplified a bit. Swift permits us to make use of one thing known as a shadow variable (variable of the identical title) for theUser which might change the if let as follows:

var theUser: Person?

// elsewhere within the code...
if let theUser {
  print(theUser.title)
} else {
  print("the person is nil")
}

Observe that theUser inside the if physique is just not the identical variable as theUser exterior of the if physique; it is a totally different property with the identical title. For that cause, theUser inside the if physique is of kind Person and out of doors of the if physique it is Person?. This function of Swift is good while you’re aware of optionals however I discover that generally it is higher to offer a distinct title in order that it is clear while you’re utilizing your unwrapped property or while you’re utilizing your non-compulsory property.

Unwrapping optionals with guard let

Whereas if let is nice for utilization inside code the place it does not matter that a lot whether or not a worth is or is not nil, you generally wish to guarantee that a worth is not nil at first of a perform. With if let this is able to typically imply that you just write an if let at first of your perform after which write the entire perform physique inside your if let:

func performWork() {
  if let unwrappedUser = theUser {
    // do the work
  }
}

This works however it could result in a whole lot of nested code. For eventualities the place you solely want to proceed in your perform if a worth is just not nil, you need to use guard let as a substitute:

func performWork() {
  guard let unwrappedUser = theUser else {
    return
  }

// do the work
// unwrappedUser is accessible to all code that comes after the guard
}

A guard permits us to make sure that our person has a worth and that the unwrapped worth is accessible to all code that comes after the guard. Once we’re utilizing a guard we should present an else clause that exits the present scope. Often which means that we put a return there as a way to bail out of the perform early.

Unwrapping a number of properties

Each if let and guard let permit us to unwrap a number of properties without delay. That is finished utilizing a comma separated record:

if let unwrappedUser = theUser, let file = getFile() {
  // now we have entry to `unwrappedUser` and `file`
}

The syntax for guard let is identical however requires the else:

guard let unwrappedUser = theUser, let file = getFile() else {
  return
}

  // now we have entry to `unwrappedUser` and `file`

Observe that writing your code like it will require all unwraps to succeed. If both our person or file could be nil within the instance above, the if physique would not be executed and our guard would enter its else situation.

Studying by means of non-compulsory chaining

If you’re working with an non-compulsory and also you’d prefer to get entry to a property that is outlined in your object, you might write an if let after which entry the property you are keen on. You noticed this earlier with Person and its title property:

if let theUser {
  print(theUser.title)
}

If we all know that we’re solely within the title property we will use a way known as non-compulsory chaining to instantly entry the title property and assign that to the property we’re writing the if let for as a substitute.

Here is what that appears like

if let userName = theUser?.title {
  print(userName)
}

That is very handy after we’re in a state of affairs the place we actually solely care a few single property. If both theUser is nil or (if title is non-compulsory) title is nil the if physique will not be executed.

We will use this method to entry bigger chains of optionals, for instance:

if let division = theUser?.division?.title {

}

Each theUser and division are optionals and we will write a series of entry utilizing ? after every non-compulsory property. As soon as any of the properties within the chain is discovered to be nil the chain ends and the result’s nil.

For instance, if we simply assign the chain from above to a property that property is a String?

// division is String?
let division = theUser?.division?.title

The title on the division property does not need to be a String? however as a result of we’re utilizing non-compulsory chaining we’ll get a nil worth if both theUser or division is nil.

This leads me to at least one final technique that I would advocate for working with and that is utilizing the nil coalescing operator.

Unwrapping optionals utilizing nil coalescing

For any non-compulsory in Swift, we will present a default worth inline of the place we entry it. For instance:

let username: String?

let displayName = username ?? ""

The ?? operator within the instance above is named the nil coalescing operator and we will use it to offer a default worth that is utilized in case the worth we’re attempting to entry is nil.

That is notably helpful when it’s worthwhile to present values to render in a person interface for instance.

You can too use this method together with non-compulsory chaining:

// division is String
let division = theUser?.division?.title ?? "No division"

Now, let’s check out one final technique to unwrapping that I am solely together with for completeness; this method ought to solely be used as a final resort for my part.

Power unwrapping optionals

In the event you’re 100% completely positive that an non-compulsory worth that you just’re about to entry can by no means be nil, you’ll be able to pressure unwrap the non-compulsory when accessing it:

print(theUser!.title)

By writing an ! after my non-compulsory variable I am telling the compiler to deal with that property as non-optional. Which means that I can simply work together with the property with out writing an if let, guard let, with out non-compulsory chaining or with out utilizing nil coaslescing. The foremost draw back right here is that if my assumptions are mistaken and the worth is nil in any case my program will crash.

For that cause it is virtually all the time most well-liked to make use of one of many 4 protected approaches to unwrapping your optionals as a substitute.