Swift Logical Operators

Swift, Apple’s powerful and intuitive programming language, offers a range of logical operators that are essential in controlling the flow of your code. Understanding and mastering these logical operators is essential for writing clean, and efficient Swift code. In this article, we’ll explore the various logical operators available in Swift, and provide code examples to solidify your understanding.

What Are Logical Operators?

Logical operators are symbols or keywords that allow developers to perform operations based on Boolean logic. Swift supports several logical operators, each serving a specific purpose. Swift provides three main logical operators: && (logical AND), || (logical OR), and ! (logical NOT).

Logical AND Operator (&&)

The logical AND operator (&&) is used to combine two Boolean values. It returns true only if both of the operands are true.

let isUserLoggedIn: Bool = true
let hasPermission: Bool = true

if isUserLoggedIn && hasPermission {
    print("User is logged in and has permission.")
	
} else {
    print("User is not logged in or does not have permission.")
	
}

In this example, the print statement will be executed only if both isUserLoggedIn and hasPermission are true.

Logical OR Operator (||)

The logical OR operator (||) combines two Boolean values and returns true if at least one of the operands is true.

let hasPremiumAccount: Bool = false
let isTrialPeriodActive: Bool = true

if hasPremiumAccount || isTrialPeriodActive {
    print("User has access to premium features.")
	
} else {
    print("User does not have access to premium features.")
	
}

In this example, the print statement will be executed if either hasPremiumAccount or isTrialPeriodActive is true.

Logical NOT Operator (!)

The logical NOT operator (!) is a unary operator that negates a Boolean value. It flips true to false and vice versa.

let isLightOn: Bool = true

if !isLightOn {
    print("The light is off.")
	
} else {
    print("The light is on.")
	
}

Here, the print statement will be executed if isLightOn is false.

Short-Circuit Evaluation

Swift uses short-circuit evaluation when dealing with logical operators. This means that if the result of a logical operation can be determined by evaluating only the first part of the expression, the second part is not evaluated. This can lead to more efficient code execution.

let isDaytime: Bool = true
let hasEnergy: Bool = false

if isDaytime && hasEnergy {
    print("Let's go for a run!")
	
} else {
    print("Maybe later.")
	
}

In this example, if isDaytime is false, the second condition (hasEnergy) is not evaluated because the overall result of the AND operation is already known to be false. This prevents unnecessary computations. Alternatively, if we had used the OR operator, the second operand does not get executed if the first evaluates to true. This is because, for the OR operator, at least one operand has to be true for the entire expression to evaluate as true.

Precedence of Logical Operators

Basic understanding of operator precedence is essential for writing clear and concise code. Precedence defines the order in which operators are evaluated. In Swift, logical operators follow a specific precedence hierarchy, from highest to lowest:

1. Logical NOT (!)
2. Logical AND (&&)
3. Logical OR (||)

This means that expressions involving ! are evaluated first, followed by &&, and finally ||. It’s important to note that you can use parentheses to override the default precedence and explicitly specify the order of evaluation.

let a: Bool = true
let b: Bool = false
let c: Bool = true

if a && b || c {
    print("The expression is true.")
	
} else {
    print("The expression is false.")
	
}

In this example, the expression a && b || c is evaluated as (a && b) || c due to the precedence rules. If you want to change the order of evaluation, you can use parentheses:

let a: Bool = true
let b: Bool = false
let c: Bool = true

if a && (b || c) {
    print("The expression is true.")
	
} else {
    print("The expression is false.")
	
}

By adding parentheses, you ensure that the logical OR operation is performed before the logical AND operation. Always use parentheses to explicitly convey your intended order of evaluation.

Complex Conditions

In more complex scenarios, you may need to combine multiple conditions. For instance, ensuring a user is logged in, has a subscription, and is accessing the app during business hours:

import Foundation

let isUserLoggedIn = true
let hasSubscription = true

let currentHour = Calendar.current.component(.hour, from: Date())
let isBusinessHours = (9...17).contains(currentHour)

if isUserLoggedIn && hasSubscription && isBusinessHours {
    print("Welcome! Enjoy your experience.")
	
} else {
    print("Access denied. Please check your subscription or try again during business hours.")
	
}

In this example, we import the Foundation framework, use Date() to get the current date and time, and then check if the current hour falls within the business hours range (9 AM to 5 PM). The logical operators are appropriately used to control access based on whether the user is logged in, has a subscription, and is within business hours.

Conclusion

In conclusion, Swift’s logical operators provide a powerful toolset for building conditional statements and making decisions in your code. Whether you’re working on form validations, implementing business rules, or creating complex conditions, understanding and using logical operators is essential. Practice using these operators in various scenarios to reinforce your comprehension and enhance your Swift programming skills.

Sources:

• Swift Logical Operators | Documentation