Swift good coding practice: If statement with optional type Bool?

Question

So I've been developing an app in Swift, and today I spent nearly an hour debugging a problem that turned out to be completely unexpected. It all resulted from the code below. if (hero.isAI) { //isAI is a Bool } The problem was that this if statement ALWAYS returned true. So I thought that maybe I was setting isAI to true somewhere but in the end I realized that I declared isAI as an optional type as shown below. var isAI: Bool! when it should have been var isAI: Bool This resulted in the if-statement not checking if isAI was true, but instead checking if it contained a value. So to be safe now I make sure to write my if-statments like this if (hero.isAI == true) { //isAI is a Bool } So my question is, **what are my options to avoid this problem in the future?** (this problem seems extremely dangerous, especially when working on a team on a large project). Should I always write my if-statment explicitly, should I just avoid the optional type for Bools altogether? Note that I did not have this problem in Xcode Beta 2. This problem came about when I upgraded to Xcode beta 3. I think because in Beta 2 Apple handled implicitly unwrapped Bool in an if-statement by checking its value rather than checking if it contains a value. Lastly, below is an example of which if-statements run given an optional Bool to better help people understand the problem. let myBool: Bool! = false if (myBool) { //Runs } if (myBool!) { //Won't Run } if (!myBool) { //Runs } if (myBool == true) { //Won't Run }

Answer 1

TLDR: Typically avoid Optionals for vars that have a finite set of potential values like Bool, probably enums

Generally speaking, you should try to avoid using Implicitly Unwrapped Optionals (marked by !) unless you absolutely have to as they can be pretty dangerous if you accidentally consume one that doesn't have a value set. In the example you posted, it seems you already know that myBool is false given that variable is given a value on initialization. Exceptions would include something like Views from Storyboards linked to UIViewControllers where the underlying tool by Apple controls setting those values.

Whether to adopt a pattern usually depends on the design details, but typically I avoid having boolean Optionals since those variables are limited to a binary set (true or false). I'll save Optionals for variables that carry meaning for possibly nil values. For instance take this (slightly trivialized) Person struct example:

struct User {

let firstName: String

let middleName: String?

let lastName: String

...

}

It can make sense to use an Optional for middleName because not everyone has a middle name. The nil-ablility carries meaning here.

If we were to extend our type with a var indicating whether a given User is logged in or not:

struct User {

let firstName: String

let middleName: String?

let lastName: String

let isLoggedIn: Bool

...

}

we would probably not make it an Optional. Why? Well...if you think about it, it is probably safe to assume that a User either logged in or not at any given moment. There is never a practical scenario where we don't know that fact. If you're worried about having an initial value or mutability, you can always specify those:

struct User {

let firstName: String

let middleName: String?

let lastName: String

// notice the change from let -> var and the default value

var isLoggedIn: Bool = false

...

}

If you're fetching data from somewhere (like from an API) and worried about waiting for a value to come back from the response body, you can always add an isLoading: Bool somewhere to help you transition between states.