How do you unwrap Swift optionals?

How do you properly unwrap both normal and implicit optionals?

There seems to be confusion in this topic and I would just like to have a reference for all of the ways and how they are useful.

There are currently two ways to create optionals:

var optionalString: String?

var implicitOptionalString: String!

What are all the ways to unwrap both? Also, what is the difference between using ! and ? during the unwrapping?

There are many similarities and just a handful of differences.

(Regular) Optionals

• Declaration: var opt: Type?

• Unsafely unwrapping: let x = opt!.property // error if opt is nil

• Safely testing existence : if opt != nil { ... someFunc(opt!) ... } // no error

• Safely unwrapping via binding: if let x = opt { ... someFunc(x) ... } // no error

  • Using new shorthand: if let opt { ... someFunc(opt) ... } // no error

• Safely chaining: var x = opt?.property // x is also Optional, by extension

• Safely coalescing nil values: var x = opt ?? nonOpt

Implicitly Unwrapped Optionals

• Declaration: var opt: Type!

• Unsafely unwrapping (implicit): let x = opt.property // error if opt is nil

  • Unsafely unwrapping via assignment:
    let nonOpt: Type = opt // error if opt is nil

  • Unsafely unwrapping via parameter passing:
    func someFunc(nonOpt: Type) ... someFunc(opt) // error if opt is nil

• Safely testing existence: if opt != nil { ... someFunc(opt) ... } // no error

• Safely chaining: var x = opt?.property // x is also Optional, by extension

• Safely coalescing nil values: var x = opt ?? nonOpt