Introduction
Swift is a very safe language, by which I mean it works hard to ensure your code never fails in surprising ways.
One of the most common ways that code fails is when it tries to use data that is bad or missing.
Swift has a solution: optionals. An optional value is one that might have a value or might not.
What are optionals
Optional is just a type in Swift language, nothing fancy. Int and Int? (optional Int) are two different types, if your variable happens to be of type Int you can be absolutely sure it will always have an integer value, and if your variable is of type Int? it will either have an integer value or it will have no value at all (in other words, it will be nil).
Think of optional as a wrapper type. It’s like a gift box which wraps the value inside, and like a real-life box, optional can either contain something or be empty.
An optional which contains integer value of four, as if to write let myOptional: Int? = 4
An optional that doesn’t contain any value, as if to write let myOptional: Int? = nil
The high level idea of wrapping the value inside a box is that we can safely use the box without worrying what’s inside.
Under the hood optional types are merely an enum with two cases — None meaning no value is set and Some meaning the value is set and it’s the value associated with it.
enum optional<T> {
case None
case Some(T)
}
//These two statements are exactly the same
let x: String? = nil
let x = Optional<String>.None
//These two statements are exactly the same
let y: String? = “Hi this is malai”
let y = Optional<String>.Some(“Hi this is malai”)
Forced Unwrapping (!)
// forced unwrapping
let b: String? = "Hi there"
var a = b!
// under the hood forced unwrapping is a switch statement
switch b {
case .Some(let value): a = value
case .None: //raise an exception
}
Well, because compiler doesn’t know how to add a box into an integer. In order to achieve this we need to unwrap the optional, in other words we need to open the box and extract the value inside. For that we put the “!” mark after the variable’s name meaning “I’m sure this box contains something, extract that value and use it”. This is called forced unwrapping.
Optional Binding
Like forced unwrapping, optional binding is a way of opening the box, but it does the job more cleverly and with less pollution than forced unwrapping. It allows to check the optional and extract its value into a constant or variable as part of a single action.
let optionalInt: Int? = 5
if let constantInt = optionalInt {
print("optionalInt has an integer value of \(constantInt).")
} else {
print("optionalInt is nil")
}
// will print "optionalInt has an integer value of 5"
Implicitly Unwrapped Optionals
// forced unwrapping
let b: String? = "Hi there"
var a = b!
// under the hood forced unwrapping is a switch statement
switch b {
case .Some(let value): a = value
case .None: //raise an exception
}
| |
let optionalInt: Int? = 5
if let constantInt = optionalInt {
print("optionalInt has an integer value of \(constantInt).")
} else {
print("optionalInt is nil")
}
// will print "optionalInt has an integer value of 5"
| |
let assumedInt: Int! = 123
Sometimes we’re really-really sure we’ll always have a value in our optional just after it’s set the first time. In this case there’s no need to unwrap the optional every time we want to use it, because it’s safe to assume we have a value.
// forced unwrapping
let optionalInt: Int? = 123
let forcedInt: Int = optionalInt!
// implicitly unwrapped optional
let assumedInt: Int! = 123
let implicitInt: Int = assumedInt
Nil coalescing
let optionalInt: Int? = nil
Can be used safely by checking nil value before force unwrapping
let result = optionalInt != nil ? optionalInt! : 0
Nil coalescing allows us to shorten this even more.
let result = optionalInt ?? 0
Optional Chaining
Optional chaining is a feature that allows to call properties and methods on an optional that might currently be nil.
class Person {
var bankAccount: BankAccount?
}
class BankAccount {
var balance: Int
}
let person = Person()
if let currentBalance = person.bankAccount?.balance {
print("Person has a bank account and its balance is \(currentBalance)")
} else {
print("Person has no bank account")
}
// prints "Person has no bank account"
// forced unwrapping
| |
let optionalInt: Int? = 123
| |
let forcedInt: Int = optionalInt!
| |
// implicitly unwrapped optional
| |
let assumedInt: Int! = 123
| |
let implicitInt: Int = assumedInt
|
class Person {
var bankAccount: BankAccount?
}
class BankAccount {
var balance: Int
}
let person = Person()
if let currentBalance = person.bankAccount?.balance {
print("Person has a bank account and its balance is \(currentBalance)")
} else {
print("Person has no bank account")
}
// prints "Person has no bank account"
| |
