Swift Boolean checking

Question

So in Objective-C when using Booleans it's possible, and encouraged, to write code using a variable's non-zero value as it's boolean value, which means you can write code like this:

if (someBool) {
    // Stuff
}

Also, there are reasons why code like the following is discouraged:

if (someBool == YES) {
    // Might run into problems here
}

The reasons why checking a boolean against another boolean are better explained here, but briefly the issue is just that when you're comparing equality to YES or NO directly, you're actually comparing against 1 and 0, respectively. Since Objective-C allows for using non-zero values as a truth value, you could end up comparing something that should be considered true against YES and have the expression resolve to NO, e.g.

int trueNumber = 2;
if (trueNumber == YES) {
    // Doesn't run because trueNumber != 1
}

Is this still an issue in Swift? Code style issues aside, if I see something like the following

var someBool = true
if someBool == true {
    // stuff
}

is that going to be an issue, or does it not really matter? Are these C-style comparisons still happening under the hood, or is there something built into the Swift BooleanType that prevents these issues?

Kametrixom · Accepted Answer · 2015-10-08 17:50:25Z

3

The if <something> {} structure in Swift requires the <something> to conform to the BooleanType protocol which is defined like this:

public protocol BooleanType {
    /// The value of `self`, expressed as a `Bool`.
    public var boolValue: Bool { get }
}

If the type doesn't conform to this protocol, a compile-time error is thrown. If you search for this protocol in the standard library you find that the only type that conforms to this protocol is Bool itself. Bool is a type that can either be true or false. Don't think of it as the number 1 or 0, but rather as On/Off Right/Wrong.

Now this protocol can be conformed to by any nominal type you want, e.g.:

extension Int : BooleanType {
    public var boolValue : Bool {
        return self > 0
    }
}

Now if you do this (you shouldn't honestly), you're defining it by yourself what "True" and "False" means. Now you'd be able to use it like this (again, don't do this):

if 0 {
    ...
}

edited Oct 8, 2015 at 17:50

answered Oct 1, 2015 at 19:38

Kametrixom

15k8 gold badges47 silver badges63 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Ziewvater Over a year ago

Okay, so the reason why the code that was a problem in Objective-C isn't an issue is simply because of the strict type-checking in Swift? It seems like in order to be used in boolean checks in Swift, a type basically has to return a strictly-typed Bool (as you've shown above), which avoids the issue that C and Objective-C had with the typedef signed char. Is it just as simple as that?

mustafa · Accepted Answer · 2015-10-01 17:03:11Z

2

Swift has Bool type. This is different from objective-c's BOOL which is not actual type. It is actually typedef unsigned char. When swift expects Bool you have to give it Bool otherwise it is compile error. The following code will not compile because check is not Bool

let check = 2
if check {
}

But this will work because == returns Bool

let check = 2
if check == 2 {
}

answered Oct 1, 2015 at 17:03

mustafa

15.5k10 gold badges50 silver badges57 bronze badges

3 Comments

Martin R Over a year ago

Actually Bool is its own type in Swift and not a type alias to "unsigned char" (which would be CUnsignedChar in Swift).

mustafa Over a year ago

Sorry I mean Objective-C not swift

Martin R Over a year ago

Well, it's more complicated in Objective-C, compare stackoverflow.com/questions/31267325/bool-with-64-bit-on-ios.

Code Different · Accepted Answer · 2015-10-02 00:44:58Z

To understand the ObjC style, you need to go back to C. In C, this statement:

if (something) {
    // Do something
}

will evaluate to false if something is null or 0. Everything else evaluate to true. The problem is C doesn't have a boolean type. Objective-C added YES and NO which is basically 1 and 0. So:

if (aBoolValue == YES) { } // Work as expected
if (anIntValue == YES) { } // False unless anIntValue == 1

The "discouraged" recommendation was to align with the behaviour in C. Swift has no such backward compatibility requirements. You can't write these:

if anIntValue {  } // Syntax error
if anObject { }    // Syntax error

Instead, the expression must evaluate to a boolean value:

if anIntValue != 0 { } // Ok
if anObject != nil { } // Ok

Collectives™ on Stack Overflow

Swift Boolean checking

3 Answers 3

1 Comment

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related