Why would I use if and let together, instead of just checking if the original variable is nil? (Swift)

Question

In “The Swift Programming Language.” book, Apple mentions using if and let together when accessing an optional variable.

The book gives the following code for example:

var optionalString: String? = "Hello"
optionalString == nil

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

What is the advantage of using if let name = optionalName, rather than if optionalName != nil (and always referring to it as, optionalName)? Is there any difference, or is it simply convention?

Answer 1

Because it also unwraps the optional value, so this code:

if let name = optionalName {
    greeting = "Hello, \(name)"
}

is equivalent to:

if optionalName != nil {
    let name:String = optionalName!
    greeting = "Hello, \(name)"
}

This language sugar is known as Optional Binding in Swift.

Optional Types

In Swift T and T? are not the same types, but the underlying value of an optional T? type can easily be realized by using the ! postfix operator, e.g:

let name:String = optionalName!

Which now can be used where a String is expected, e.g:

func greet(name:String) -> String {
    return "Hello, \(name)"
}

greet(name)

Although as its safe to do so, Swift does let you implicitly cast to an optional type:

let name = "World"
let optionalName: String? = name

func greet(optionalName:String?) -> String? {
    if optionalName != nil {
        return "Hello, \(optionalName)"
    }
    return nil
}

//Can call with either String or String?
greet(optionalName)
greet(name)