我的主力博客:半亩方塘
Optionals
1、Optionals are Swift's solution to the problem of representing both a value and the absence of a value. An optional type is allowed to reference either a value or nil
.
Think of an optional as a box: it either contains a value, or it doesn't. When it doesn't contain a value, it's said to contain nil
. The box itself always exists; it's always there for you to open and look inside.
Non-optional types are guaranteed to have an actual value.
You declare an optional type by using the following syntax:
var errorCode: Int?
Setting the value is simple. You can either set it to an
Int
, like so:
errorCode = 100
var authorName: String? = "Matt Galloway"
There are two different methods you can use to unwrap this optional. The first is known as force unwrapping, and you perform it like so:
var unwrappedAuthorName = authorName! print("Author is \(unwrappedAuthorName)")
The exclamation mark after the variable name tells the compiler that you want to look inside the box and take out the value. Here's the result:
Author is Matt Galloway
You should use force unwrapping sparingly. To see why, consider what happens when the optional doesn't contain a value:
authorName = nil var unwrappedAuthorName = authorName! print("Author is \(unwrappedAuthorName)")
The code produces the following runtime error:
fatal error: unexpectedly found nil while unwrapping an Optional value
The error happens because the variable contains no value when you try to unwrap it.
Fortunately, Swift includes a feature known as if let binding, which lets you safely access the value inside an optional. You use it like so:
if let unwrappedAuthorName: String = authorName { print("Author is \(unwrappedAuthorName)") } else { print("No author.") }
This special syntax rids the type of the optional. If the optional contains a value, then the code executes the
if
side of theif
statement, within which you automatically unwrap theunwrappedAuthorName
variable because you know it's safe to do so. If the optional doesn't contain a value, then the code executes theelse
side of theif
statement. In that case, theunwrappedAuthorName
variable doesn't even exist.You can see how
if let
binding is much safer than force unwrapping, and you should opt for it whenever possible.You can even unwrap multiple values at the same time, like so:
let authorName: String? = "Matt Galloway" let authorAge: Int? = 30 if let name: String = authorName, age: Int = authorAge { print("The author is \(name) who is \(age) years old.") } else { print("No author or no age.") }
This code unwraps two values. It will only execute the
if
part of the statement when both optionals contain a value.There's one final and rather handy way to unwrap an optional. You use it when you want to get a value out of the optional no matter what-and in the case of
nil
, you'll use a default value. This is called nil coalescing. Here is how it works:var optionalInt: Int? = 10 var result: Int = optionalInt ?? 0
Thenil
coalescing happens on the second line, with the double question mark (??). This line meansresult
will equal either the value insideoptionalInt
, or 0 ifoptionalInt
containsnil
.