Swift Logical Operators

🔗 What are Logical Operators?

Logical operators combine or modify boolean values (true/false). Use AND (&&) when both conditions must be true, OR (||) when either condition can be true, and NOT (!) to reverse a boolean value.


let isAdult = age >= 18
let hasLicense = true
let canDrive = isAdult && hasLicense  // Both must be true

🔗

AND (&&)

True only if both conditions are true

let both = true && true   // true
let mixed = true && false // false

🔀

OR (||)

True if at least one condition is true

let either = true || false  // true
let neither = false || false // false

🔄

NOT (!)

Reverses a boolean value

let opposite = !true   // false
let reversed = !false  // true

🧮

Combined

Use multiple operators together

let complex = !false && true // true
let mixed = true || !false   // true

🔹 Logical AND Operator (&&)

The AND operator returns true only when both conditions are true:

// Basic AND operations
let condition1 = true
let condition2 = true
let condition3 = false

let bothTrue = condition1 && condition2    // true
let oneTrue = condition1 && condition3     // false
let bothFalse = condition3 && false        // false

// Practical example: User access control
let isLoggedIn = true
let hasPermission = true
let isActive = true

let canAccess = isLoggedIn && hasPermission && isActive  // true

// Age and license check
let age = 20
let hasDriversLicense = true
let canDrive = (age >= 18) && hasDriversLicense  // true

print("Can access system: \(canAccess)")
print("Can drive: \(canDrive)")
print("Both conditions true: \(bothTrue)")

Output:

Can access system: true

Can drive: true

Both conditions true: true

🔹 Logical OR Operator (||)

The OR operator returns true when at least one condition is true:

// Basic OR operations
let option1 = true
let option2 = false
let option3 = false

let anyTrue = option1 || option2     // true
let stillTrue = option2 || option1   // true
let allFalse = option2 || option3    // false

// Practical example: Payment methods
let hasCreditCard = false
let hasDebitCard = true
let hasCash = false

let canPay = hasCreditCard || hasDebitCard || hasCash  // true

// Weekend check
let isSaturday = false
let isSunday = true
let isWeekend = isSaturday || isSunday  // true

// Emergency contact
let hasPhone = true
let hasEmail = false
let canContact = hasPhone || hasEmail  // true

print("Can pay: \(canPay)")
print("Is weekend: \(isWeekend)")
print("Can contact: \(canContact)")

Output:

Can pay: true

Is weekend: true

Can contact: true

🔹 Logical NOT Operator (!)

The NOT operator reverses a boolean value:

// Basic NOT operations
let isTrue = true
let isFalse = false

let notTrue = !isTrue      // false
let notFalse = !isFalse    // true

// Practical examples
let isLoggedIn = false
let isGuest = !isLoggedIn  // true

let isWeekday = true
let isWeekend = !isWeekday  // false

// Double negative
let isNotReady = false
let isReady = !isNotReady  // true

// Using with comparisons
let age = 15
let isMinor = !(age >= 18)  // true (same as age < 18)

let password = "123"
let isValidPassword = !(password.count < 8)  // false

print("Is guest: \(isGuest)")
print("Is weekend: \(isWeekend)")
print("Is minor: \(isMinor)")
print("Valid password: \(isValidPassword)")

Output:

Is guest: true

Is weekend: false

Is minor: true

Valid password: false

🔹 Combining Logical Operators

Use multiple logical operators together for complex conditions:

// Complex logical expressions
let age = 25
let hasJob = true
let hasGoodCredit = true
let hasCoSigner = false

// Loan approval logic
let isEligibleForLoan = (age >= 18) && (hasJob || hasCoSigner) && hasGoodCredit
print("Eligible for loan: \(isEligibleForLoan)")  // true

// Access control with multiple conditions
let isAdmin = false
let isManager = true
let isOwner = false
let hasSpecialPermission = true

let canDeleteFiles = isOwner || (isAdmin && hasSpecialPermission) || isManager
print("Can delete files: \(canDeleteFiles)")  // true

// Event attendance
let isWeekend = true
let isHoliday = false
let isVacation = false
let isAvailable = !isVacation && (isWeekend || isHoliday)
print("Available for event: \(isAvailable)")  // true

// Complex validation
let username = "user123"
let password = "securepass"
let isValidUser = !username.isEmpty && !password.isEmpty && username.count >= 3
print("Valid user: \(isValidUser)")  // true

Output:

Eligible for loan: true

Can delete files: true

Available for event: true

Valid user: true

🔹 Short-Circuit Evaluation

Swift uses short-circuit evaluation for efficiency:

Short-Circuit Rules:

AND (&&): If first condition is false, second isn't checked
OR (||): If first condition is true, second isn't checked
Benefit: Prevents errors and improves performance

// Short-circuit AND example
let numbers: [Int] = []
let hasElements = !numbers.isEmpty && numbers[0] > 0
// Second condition isn't evaluated because first is false
print("Has positive first element: \(hasElements)")  // false

// Short-circuit OR example
let isAdmin = true
let hasPermission = isAdmin || checkComplexPermission()
// checkComplexPermission() is never called because isAdmin is true

// Safe array access
let items = ["apple", "banana"]
let index = 5
let isValidAccess = index < items.count && items[index] == "cherry"
// items[index] isn't accessed because index >= items.count
print("Valid access: \(isValidAccess)")  // false

// Function that won't be called
func checkComplexPermission() -> Bool {
    print("Checking complex permission...")
    return false
}

// This will print the message because first condition is false
let needsCheck = false || checkComplexPermission()
print("Needs check: \(needsCheck)")

Output:

Has positive first element: false

Valid access: false

Checking complex permission...

Needs check: false

Swift Logical Operators

🔗 What are Logical Operators?