10.1 Declaring optionals

var name1 = "Jill"
var name2: String? = "Jack"
name1 // "Jill"
name2 // {Some "Jack"}

We can declare an value as optional by adding a ? to the type declaration. In the above example, setting the type to String? indicates that name2 is an optional string which we’ve initialized to the value “Jack” (if we didn’t initialize its value, its initial value is nil). name1 is a string which is not optional. Note that when name1 is evaluated in the playground we get its value back (“Jill”). But when name2 is evaluated, instead of getting the value we get an optional containing the value ({Some "Jack"}).

There are a couple of ways for us to get the value from the optional. We can unwrap it or we can use if let.

10.2 Forced unwrapping

When we access an optional value, we get an optional back. We can force Swift to retrieve an optional value by adding a ! to the variable name. This is known as forced unwrapping and you shouldn’t do this unless you know there is a value present. But when you do this you get the value back instead of the optional. In the above example we can unwrap the value of name2 like this:

name2! // "Jack"

When we do this we get the value of the optional back instead of the optional itself.

If we try to unwrap an optional that has no value we’ll get a runtime error. E.g. we can remove a value from an optional by setting it to nil. Once we’ve done that we’ll get an error if we try to unwrap it.

name2 = nil
name2 // nil
name2! // Error (Runtime)

10.3 Conditional unwrapping

We can also use if or if let to conditionally do something with an optional value.

if name2 == "Jack"{
    println("Hello Jack")
}
else{
    println("Hello there")
}

 1 var i:Int? = 10
 2 var j:Int?
 3 
 4 i // {Some 10}
 5 j // nil
 6 
 7 i == 10  // true
 8 i == 8   // false
 9 i > 0    // true
10 i == nil // false
11 i != nil // true
12 
13 j == 10  // false
14 j > 0    // false
15 j == nil // true

1 if let n = name2 {
2     println("Hello \(n)")
3 }else{
4     println("Hello person with no name")
5 }

10.4 Using optionals

Here are a few things to think about when using optionals:

• We’ve covered how to declare optionals, unwrap their values and use their values with conditionals.
• You can use optionals in comparison operators.
• You remove a value from an optional by assigning it nil.
• You can only assign nil to an optional. If you try to assign nil to a variable that is not an optional you’ll get an error.
• you can only use an optional in places where an optional is expected. If you try to use an optional value where an optional isn’t expected or allowed you’ll get an error.

Now that we understand optionals, let’s look at using them. Swift assumes by default that all variables have a value. Unless you tell it otherwise by declaring an optional you can’t have a nil value in a place where your program expects there to be a value. In this example, our function expects its name parameter to have a value. If we pass nil as an argument we get an error (line 12). Even though our program isn’t doing anything other than printing the value of the parameter, the fact that we see nil in a place where we expect the parameter to have a value is enough to raise an error.

 1 var name1 = "Jill"
 2 var name2: String? = "Jack"
 3 
 4 func hello(name: String) -> String {
 5     return "Hello \(name)"
 6 }
 7 
 8 hello(name1) // Hello Jill
 9 hello(name2) // Error
10 hello(name2!) // Hello Jack
11 name2 = nil
12 hello(name2!) // Error (Runtime)

Here we declare name2 as an optional and name1 is not optional. Our hello function takes a string as an argument. In this example this argument is not an optional. Note that if we try to pass an optional as a function argument we get an error (line 9). This error gets picked up by the compiler because we tried to pass an optional as an argument to a function which didn’t expect an optional. We can still use that optional as an argument to the function if we unwrap its value (line 10) but if we are doing this we should be sure that it has a value. If we try to unwrap it when it doesn’t have a value we get a runtime error (line 12).

Let’s look at a similar function that takes an optional as an argument.

 1 var name1 = "Jill"
 2 var name2: String? = "Jack"
 3 
 4 func optionalHello(name: String?) -> String {
 5     if let n = name {
 6         return "Hello \(n)"
 7     }
 8     else {
 9         return "Hello"
10     }
11 }
12 
13 optionalHello(nil) // Hello
14 optionalHello(name2) // Hello Jack
15 optionalHello(name1) // Hello Jill

In this example the optionalHello function takes an optional string argument called name. It uses an if let statement to append the name to the greeting if name has a value and return a default greeting otherwise. Since this is an optional, we can call it with a nil value (line 13). We can also call it with our optional name2 (line 14) and it will work whether this optional has a value or is nil. We can also call it with our non-optional name1 (since it’s not an optional name1 will always have a value).

10.5 Dictionaries

We’ve already encountered optionals in chapter 7 when we looked at dictionaries. Let’s revisit that example now that we’ve discussed optionals in more detail.

You may have noticed in our dictionary example from chapter 7 (when you enter it in a playground) that when we access a value using a key we get a result like {Some "dog"}. That’s because dictionaries return an optional. Lets take a closer look.

1 var pets = ["Polly" : "dog", "Joey" : "goldfish"]
2 
3 pets["Polly"] // {Some "dog"}
4 
5 pets["Polly"]! // "dog"

The reason for this is that we’re not certain that a dictionary key exists when we try to access it - it may be nil. Returning an optional allows us to handle the case when the key is blank. In the above example we see that when we access an element of the pets dictionary we get an optional back (line 3) and when we forcibly unwrap an element of the pets array we get the value for that element back (line 5). Dictionaries return optionals as we don’t always know if there is a value present for a certain key. Thus we can process dictionary keys the same way as we did the optionals in the above example. E.g. when we’re not certain if a key is present we can use if or if let to do something with the key and we can force unwrapping of keys that we know to be present.

 1 var preferences = [
 2     "receiveEmail" : true,
 3     "showAds" : true
 4 ]
 5 
 6 if let subscribed = preferences["receiveEmail"]{
 7     if subscribed {
 8         println("Send them an email")
 9     }else{
10         println("User has unsubscribed")
11     }
12 
13 }
14 
15 if preferences["showAds"]!{
16     println("Show them an Ad")
17 }
18 
19 if preferences["showAds"] == true {
20     println("Show them an Ad")
21 }

In this example we use both if and if let to do something depending on the value of a key in the preferences dictionary. At line 6 we use if let to check if a key is present and do something if that value is present. Note that we have an if statement inside the if let to process the value. The if let statement body runs if the subscribed variable has a value - it doesn’t check that value to determine whether or not to run. It will run whether subscribed is true or false - all that is needed for the if let body to run is that subscribed has a value. Since subscribed is boolean we have a further if statement within the if let to check whether it is true or false.

This showcases a subtle difference in Swift that can be confusing coming from other languages that don’t make the distinction between having no value and having a falsey value - there is a difference between something having no value and having a value that is false. In this example subscribed has a value but that value is true (but line would still run even if subscribed has value false). So the if let checks if there is a value present, and then the if within that checks if that value is true or false.

We can also process the values in the array by unwrapping them - this assumes that the value is always present. E.g. If we know that preferences["showAds"] is always present we can unwrap it and use it as a condition to an if statement (line 13). Note that we need to unwrap it here as the if statements requires a boolean for its condition, whereas if we didn’t unwrap it we would get an optional which would result in a compiler error.

Finally, we can also use if to check if the value is both present and true. The statement at line 17 will only run if preferences["showAds"] is both present and true.