{infiniteZest}
// Articles. Tutorials. Utilities.
Home  |   Search  |   Login  
Categories Skip Navigation Links
New / All
AJAX
Apple
ASP.NET
.NET
Git
Google / Android
Python / IronPython
Miscellaneous
SQL Server
Swift - Summary of ?, !, and ?? in Optionals
Summary
Summary of three operators (?, !, ??) used in optionals in Swift.
 
Table of Contents

Summary of Optionals Operators

? with Type - Optional

? with variable/constant - Optional Chaining

! with Type: Implicit Unwrapping

! with variable/constant - Forced Unwrapping

?? between variables - Nil Coalescing Operator

 
Article Series
Previous Article:
Test Your Knowledge: Swift - Optional Chaining
This article is part of the Series:
Swift - Optionals
Next Article:
Test Your Knowledge: Swift - Summary of ?, !, and ?? in Optionals

Summary of Optionals Operators

Both ? and ! can be used with Type and variable/constant — so that gives us 4 possibilities. ?? is used between variables. Following is a quick summary of three operators used in the context of optionals in Swift:

  • ? with Type: variable is an optional, can take nil value
  • ? with variable/constant: Optional Chaining
  • ! with Type: Implicit Unwrapping
  • ! with variable/constant: Forced Unwrapping
  • ?? between variables: Nil Coalescing Operator

Sections below provide quick summary of these operators. Previous articles in this series has went into this in a lot more detail.

? with Type - Optional

Using ? with Type is essence of declaring an Optional.

var city: String?

// Can contain a String value
city = “San Francisco”

// Can contain a nil value
city = nil

As the code above shows a type of String? means Optional<String> - it can contain a String value or a no-value (nil).

? with variable/constant - Optional Chaining

To safely get the value of an entire chain where some of the values are optional and might contain a no-value(nil), you would use ? with the optional variable.

let count = cities[“SF”]?.nickname?.characters.count

In the above code, cities is a dictionary. When you get a value out of dictionary, it will return an optional (for the possibility of not finding the key used. So, if the city you are looking for is not there in the dictionary, it will return nil. And since ? (for optional chaining) is used, rest of the expression will not be evaluated and nil will be returned as a value for count.

Similarly, nickname is an optional property. It can have a nil value. To not execute rest of the statement and return a nil value the ? is used next to nickname.

This optional chaining (?) can be used on methods and subscripts in the chain if they return optionals.

! with Type: Implicit Unwrapping

You can use ! on the type to return unwrapped value to the caller. This is used infrequently in the regular code, but used when UI controls are declared in the code and connected with the controls in the storyboard.

@IBOutlet var saveButton: UIButton!

In this case saveButton cannot initialized to a proper UIButton object at the time of creation. But once the button object created in the storyboard is ready, it can be assigned to this. Until then it will be have be nil (or have no-value). But wherever you are using it, it must be ready there — there is no point in using nil user interface objects. So, saveButton will need to be unwrapped and returned to the using place automatically.

This pattern can be used in situations where a value for some variable is nil at some point, but will be obtained from somewhere and when it’s time for using it, it cannot be nil.

! with variable/constant - Forced Unwrapping

If you have declared a variable as an optional and you want to get the value inside it, then you can use ! to force unwrap it.

var city: String?
city = “San Francisco”

var display = “City is “ + city!

If there is no value (nil) in the optional you are trying to unwrap forcibly with !, then there will be a crash. So, this needs to be used only if you are very sure that there is a non-nil value in the optional that you are trying to unwrap.

Safer ways of unwrapping include explicitly checking for nil, optional binding, nil coalescing operator, and optional chaining.

You can also use this to forcibly unwrap at the places where optional is returned, including dictionaries, methods that return an optional, subscripts that return an optional, etc.

?? between variables - Nil Coalescing Operator

A quick way of returning a default value when the original optional has no-value (nil) in it is by using the Nil Coalescing Operator (??)

let defaultLinesToShow = 4
var userLinesToShow: Int?

let linesToShow = userLinesToShow ?? defaultLinesToShow

By default, in our app, we show 4 lines (lets say). However, we also give the user to change it (perhaps 3 or 6). So, the number of lines show will be set to whatever the user sets it to be. However, if the user doesn’t bother to set it, that value will be nil (no-value). With ?? (Nil Coalescing Operator), we can return the default value as expressed succinctly above.

So, ?? returns the value of the left variable if it is not nil. If it is nil, then the right variable (default) is returned. This can, of course, be used with Strings, custom types, etc. And it is useful as long as the first variable is an optional.

Take a Quick Quiz on this Article

1. Which operator is used force unwrap an optional in Swift?



: Unwrap
Question 1 of 5
Article Series
Previous Article:
Test Your Knowledge: Swift - Optional Chaining
This article is part of the Series:
Swift - Optionals
Next Article:
Test Your Knowledge: Swift - Summary of ?, !, and ?? in Optionals
Bookmark and Share This

More Articles With Similar Tags
icon-swift-article.jpg
This article discusses the safer ways of unwrapping an optional in Swift that includes Optional Binding.
icon-swift-test.jpg
Test on using Optional Binding in Swift.
icon-swift-article.jpg
This article talks about unwrapping the optionals in Swift implicitly and the circumstances where you would use this functionality.
icon-swift-article.jpg
This article talks about the Nil Coalescing Operator (??) in Swift.
icon-swift-article.jpg
This article talks about optional chaining in swift where multiple optionals can be chained together and fail gracefully by returning nil when one of them is nil.
About  Contact  Privacy Policy  Site Map