Learn how to use optionals to work with data that might be `nil`.

Optionals

It’s common in Swift to chain properties and method calls on a variable:

```swift
let instrument = "piano"
let firstUppercasedCharacter = instrument.uppercased().first
print(firstUppercasedCharacter) // prints “p”
```

But what if the variable is an optional?  We can use the `!` operator to force unwrap the optional:

```swift
let instrument: String? = "piano"
let firstUppercasedCharacter = instrument!.uppercased().first
print(firstUppercasedCharacter) // prints p
```

But this will crash if the optional is nil:

```swift
let instrument: String? = nil
let firstUppercasedCharacter = instrument!.uppercased().first // Fatal error: Unexpectedly found nil while unwrapping an Optional value
print(firstUppercasedCharacter)
```

Fortunately Swift gives us a way to safely chain different calls on an optional using *optional chaining*.  By replacing the `!` operator with the `?` operator, our code can no longer crash.  If the optional is `nil`, then the entire expression will evaluate to `nil`.  

```swift
let instrument: String? = nil
let firstUppercasedCharacter = instrument?.uppercased().first
print(firstUppercasedCharacter) // Prints nil
```

If the optional is not `nil`, then it will be unwrapped and have the subsequent properties and methods called on it.  Note that because the entire expression can be nil, it now evaluates to an optional as well:

```swift
let instrument: String? = "piano"
let firstUppercasedCharacter = instrument?.uppercased().first
print(firstUppercasedCharacter) //Prints “Optional(“P”)"
```


Optional Chaining

Great work!  By using optionals, you can make sure to handle values that might be `nil`.  A value might be `nil` because the user didn’t provide a response.  A value might also be `nil` because we might not have a good answer to a question (e.g. what’s the biggest number in an empty list). 

In this lesson you learned how to:
- Define optionals
- Force unwrap optionals using the `!` operator
- Bind optionals using `if let` statements
- Bind optionals using `guard` statements
- Use the nil-coalescing operator `??` to provide default values
- Chain optionals using the `?` operator
- Define functions that take in and return optionals


Optionals are anything but optional for writing great Swift code!

Review

In the last exercise, we saw that force unwrapping allows us to access the underlying value of an optional, but can crash our program if the value is nil.  Wouldn’t it be great if we could access optionals without crashing our code?  We can with *optional binding*!  Using optional binding, we can check if a value is not `nil` in an if statement, then make a new constant that stores the underlying value.

```swift
var errorMessage: String? = nil

if let nonOptionalErrorMessage = errorMessage {
    print("Error: \(nonOptionalErrorMessage)")
} else {
    print("No error message")
}
```

If `errorMessage` is not `nil`, a new constant `nonOptionalErrorMessage` of type `String` is created.  Then the error message is printed.  If `errorMessage` is `nil`, `nonOptionalErrorMessage` is never declared and the code in the `else` block is executed.

It’s common practice to use the same name for the new constant as the original optional variable.

```swift
var errorMessage: String? = nil

if let errorMessage = errorMessage {
    print("Error: \(errorMessage)")
} else {
    print("No error message")
}
```

In the body of the `if let` statement, `errorMessage` refers to the newly created constant of type `String`.


Optional Binding

Sometimes when we work with data, we find that information is missing.  Let's imagine that you are writing a program that displays the first letter of a user's middle name.

```swift
let firstName = "Franklin"
let middleName = "Delano"
let lastName = "Roosevelt"
```

For this user, his middle name is "Delano", so our program should print "D".  But what about this user?

```swift
let firstName = "George"
let middleName = ""
let lastName = "Washington"
```

His middle name is an empty string that doesn't contain any characters!  How can we find the first character if there are no characters in his middle name at all?

Enter **optionals**.  An optional represents a variable that might be absent. We can say that the first letter in a user's middle name is an *optional* character.  Either it is a real character or `nil` which represents the absence of a value.  In this lesson, you'll learn how to define and handle optional values.

Question mark boxes that either contain a letter or nil.

Introduction to Optionals

Because optionals are types just like `Array`s and `String`s are, we can use them in the signature of a function.  Optionals are useful because when writing some functions, you might not have a good value to return.  

```swift
func firstOddNumber(in arr: [Int]) -> Int {
    for value in arr {
        if !value.isMultiple(of: 2) {
            return value
        }
    }
    //  Need to return something!
} // Error: Missing return in a function expected to return 'Int'
```

What number should `firstOddNumber(in:)` return if we pass in `[2,4,6]`?  In many languages, functions return `-1` if they don’t have a good answer to the question.  But here, that would be pretty confusing because in the array `[2, 8,-1, 5]`, `-1` **is** the first odd number!

Fortunately, optionals give us a good solution to this problem.  By returning an optional integer, we can make it clear that there was no good answer to the question:

```swift
func firstOddNumber(in arr: [Int]) -> Int? {
    for value in arr {
        if !value.isMultiple(of: 2) {
            return value
        }
    }
    return nil
}
```

As you write more functions, you’ll see lots of places where optionals can be used! 


Optionals and Functions

The *nil-coalescing operator* gives us another way to handle optional values by allowing us to provide a default value if the optional is nil.  *nil-coalescing* uses the syntax `optionalVal ?? defaultValue` where `optionalVal` is some optional and `defaultValue` is the same type as the optional’s underlying type.  If `optionalVal` is non-nil, this expression evaluates to `optionalVal!`.

```swift
var userLocation: String? = "Home"
let displayedLocation = userLocation ?? "Unknown"
print(displayedLocation) // Prints "Home"
```

If `optionalVal` is nil, this expression instead evaluates to `defaultValue`

```swift
var secondUserLocation: String?
let secondDisplayedLocation = secondUserLocation ?? "Unknown"
print(secondDisplayedLocation) // Prints "Unknown"
```

The nil-coalescing operator is great for giving a quick default value to an optional!


The Nil-Coalescing Operator

Once you’ve created an optional, you’ll want to be able to access the value inside.  However, if you just try to use the optional, you will get a compile-time error:

```swift
var a = 4
var b: Int? = 3
let sum = a + b // ERROR: Value of optional type 'Int?' must be unwrapped to a value of type 'Int'
```

The easiest way to wrap an optional is using the `!` operator.  This process is called **force unwrapping** and will break open the optional and let you use the underlying value:

```swift
var a = 4
var b: Int? = 3
let sum = a + b!
print(sum) // Prints 7
```

But be careful!  If the underlying value is `nil`, your program will crash:

```swift
var a = 4
var b: Int? = nil
let sum = a + b! // Fatal error: Unexpectedly found nil while unwrapping an Optional value
print(sum)
```

Make sure to only use the `!` operator if you are absolutely sure that the value isn’t nil.  To be safe, you can check using an if statement:

```swift
var a = 4
var b: Int? = nil
if b != nil {
    let sum = a + b!
    print(sum) Prints 7
}
```


Force Unwrapping Optionals

Optional types either contain a value or `nil`.  An optional type is defined with a question mark:

```swift
var firstLetter: Character?
```

Optionals can be assigned to either `nil` or an instance of the optional type.  Its initial value will be nil unless you assign a value yourself:

```swift
var firstLetter: Character?
print(firstLetter) // prints nil
firstLetter = "a"
print(firstLetter) // prints Optional("a")
```

Only optional types can be assigned to nil.  If you attempt to assign a non-optional type to nil, you will get a compile-time error.

```swift
var firstLetter: Character = "a"
firstLetter = nil // ERROR: nil' cannot be assigned to type 'Character'
```


Defining Optionals

`if let` statements are a great way to safely handle optional values.  Sometimes, we might have a lot of optionals we need to unwrap!  This can get very indented:

```swift
var a: Int? = 1
var b: Int? = 2
var c: Int? = 3
var shouldPrintSum = true
 
if let a = a {
    if let b = b {
        if let c = c {
            if shouldPrintSum {
                print(a + b + c)
            }
        }
    }
}
```

Developers sometimes call this nested structure a [Pyramid of Doom](https://en.wikipedia.org/wiki/Pyramid_of_doom_(programming)) because it looks kind of like a sideways pyramid.  To avoid these, Swift allows us to bind multiple variables with a single `if let` statement.  

```swift
if let a = a, let b = b, let c = c, shouldPrintSum {
    print(a + b + c)
}
```

Much easier to read!  If all of the optionals are not `nil` and all of the bools are true, then the body is entered.  Otherwise, that block is skipped.  If the `if let` line becomes too long, you can break it up into multiple lines:


```swift
if let a = a, 
   let b = b, 
   let c = c, 
   shouldPrintSum {
     print(a + b + c)
}
```


Let’s implement a similar optimization to the code here.


Multiple Optional Bindings

*Guard statements* give us another way to avoid overly nested code.  A guard statement has the following form:

```swift
func greetUser(isAuthenticated: Bool) {
    guard isAuthenticated else {
        print("Error: user is not authenticated")
        return
    }
    print("Hello user!")
}
```

One way to read this guard statement is: “Make sure that `userAuthenticated` is true.  If it’s false, print "Error: user is not authenticated" and return.  If it’s true, continue executing the rest of the code.”

Unlike if statements, a guard statement **must** have an else statement. The else statement after a `guard` has to exit the current scope.  Guard statements can be used to exit the scope of loops as well:

```swift
var nums = [3,1,0,6]
 
for num in nums {
    guard num != 0 else {
        print("Can't divide by zero!")
        continue
    }
    print("10 / \(num) = \(10 / num)")
}
 
// prints
// 10 / 3 = 3
// 10 / 1 = 10
// Can't divide by zero!
// 10 / 6 = 1
```

Guard statements can also be used to bind optionals just like with `if let` statements.  They also support multiple assignments:

```swift
func addOptionals(shouldPrintSum: Bool) {
    let a: Int? = 1
    let b: Int? = 2
    let c: Int? = 3
    
    guard let unwrappedA = a, let unwappedB = b, let unwrappedC = c, shouldPrintSum else {
        return
    }
    print(unwrappedA + unwappedB + unwrappedC)
}
```
