A type that represents either a wrapped value or
nil, the absence of a value.
- Xcode 6.0.1+
- Swift Standard Library
You use the
Optional type whenever you use optional values, even if you never type the word
Optional. Swift’s type system usually shows the wrapped type’s name with a trailing question mark (
?) instead of showing the full type name. For example, if a variable has the type
Int?, that’s just another way of writing
Optional<Int>. The shortened form is preferred for ease of reading and writing code.
The types of
long in the following code sample are the same:
Optional type is an enumeration with two cases.
Optional is equivalent to the
Optional stores a wrapped value. For example:
You must unwrap the value of an
Optional instance before you can use it in many contexts. Because Swift provides several ways to safely unwrap optional values, you can choose the one that helps you write clear, concise code.
The following examples use this dictionary of image names and file paths:
Getting a dictionary’s value using a key returns an optional value, so
image has type
Optional<String> or, written in the preferred manner,
To conditionally bind the wrapped value of an
Optional instance to a new variable, use one of the optional binding control structures, including
guard let, and
To safely access the properties and methods of a wrapped instance, use the postfix optional chaining operator (postfix
?). The following example uses optional chaining to access the
has method on a
Using the Nil-Coalescing Operator
Use the nil-coalescing operator (
??) to supply a default value in case the
Optional instance is
nil. Here a default path is supplied for an image that is missing from
?? operator also works with another
Optional instance on the right-hand side. As a result, you can chain multiple
?? operators together.
When you’re certain that an instance of
Optional contains a value, you can unconditionally unwrap the value by using the forced unwrap operator (postfix
!). For example, the result of the failable
Int initializer is unconditionally unwrapped in the example below.
You can also perform unconditional optional chaining by using the postfix
Unconditionally unwrapping a
nil instance with
! triggers a runtime error.