If-Else and Comparison Operators

Add to favorites

Building Dynamic SwiftUI: Mastering If-Else and Comparison Operators

SwiftUI Fundamentals Handbook

Building Your iOS Development Foundation

Comments: Documentation Waypoints in Your SwiftUI Codebase

22:02

SwiftUI Print Debugging

18:04

Variables and Constants

11:37

Strings and Interpolation

13:22

Swift Operators: The Foundation of SwiftUI Logic

Unary Operators

Binary Operators

Arithmetic Operators

If-Else and Comparison Operators

Logical Operators

Ternary Operators

Blocks and Scope

10:22

Swift Collections: Arrays, Sets, and Dictionaries Overview

Swift Arrays: The Basics Part 1

Swift Arrays: Best Practices in SwiftUI Part 2

Swift Sets

1. Conditional Logic in SwiftUI

Conditional logic is the cornerstone of creating dynamic and responsive user interfaces in SwiftUI. It enables your application to adapt and respond intelligently to changing conditions, user interactions, and data states. By leveraging Swift's powerful comparison operators and conditional statements, you can build interfaces that transform seamlessly based on the current context of your application. Screenshot 2025-02-21 at 2.05.07 PM

A. Basic Concepts

Conditional logic in SwiftUI refers to the ability of your app to make decisions and display different content based on specific conditions. At its core, conditional logic involves three fundamental components:

// Basic structure
if (condition) {
    // Do this if condition is true
} else {
    // Do this if condition is false
}

i. Comparison Operators These evaluate relationships between values and produce Boolean results:

Equal to (==): Checks if values match exactly
Not equal to (!=): Confirms values differ
Greater/less than (>, <): Compares numerical ordering
Greater/less than or equal to (>=, <=): Includes equality in comparison

ii. Conditional Structures Swift provides several ways to implement decision paths:

if-else statements: The primary conditional structure
Ternary operators: Compact single-line conditionals
switch statements: For handling multiple distinct cases
guard statements: For early returns and unwrapping optionals

iii. State Tracking SwiftUI's property wrappers allow UI to react automatically:

@State: For simple view-owned state
@Binding: For shared state that can be modified
@StateObject/@ObservedObject: For complex state in observable objects
@EnvironmentObject: For deeply shared app-wide state

B. Why Conditionals Matter in SwiftUI

Conditionals are essential to SwiftUI development for several critical reasons:

i. Declarative UI Construction
SwiftUI's fundamental design philosophy is declarative programming—you describe what your UI should look like for all possible states, not how to transition between states. Conditionals are the primary mechanism for expressing these state-dependent variations. Without conditionals, you would need to manually update your interface whenever state changes, losing the reactive benefits of SwiftUI entirely.

ii. Efficient Resource Management
Conditionals allow your app to selectively render only the components needed for the current state. This prevents wasteful construction of UI elements that won't be shown, leading to better performance and memory efficiency. SwiftUI's diffing engine uses these conditional branches to determine exactly what needs to change when state updates.

iii. Enhanced User Experience
Modern apps demand contextual interfaces that respond intuitively to user actions. Conditionals enable you to show empty states when data is missing, loading indicators during network requests, error messages when operations fail, and success confirmations when tasks complete. These contextual UI changes provide essential feedback that guides users through your application's workflow.

iv. Accessibility and Adaptability
Users interact with iOS apps on diverse devices with varying capabilities and settings. Conditionals help you adapt your interface for different screen sizes, orientations, dynamic type settings, and accessibility preferences. This ensures your app remains usable and attractive across the entire Apple ecosystem.

v. Feature Progression
As applications grow more complex, conditionals become critical for managing feature gating, onboarding sequences, and permission-based functionality. They allow you to progressively reveal capabilities based on user authentication status, subscription level, or completion of prerequisite steps.

C. Real-World Applications

Conditional logic powers countless features in modern iOS applications:

i. Authentication Flows
Apps display different screens based on authentication state (logged in vs. logged out), permission status, or account type:

if userIsAuthenticated {
    HomeView()
} else {
    LoginView()
}

ii. Feature Toggles
Enable or disable features based on subscription status, user preferences, or device capabilities:

if isPremiumUser {
    PremiumFeatureView()
} else {
    UpgradePromptView()
}

iii. Responsive Layouts
Adapt interfaces for different device orientations, screen sizes, or accessibility settings:

if horizontalSizeClass == .compact {
    MobileLayout()
} else {
    DesktopLayout()
}

iv. Error Handling
Display appropriate error messages, retry options, or fallback content when operations fail:

if let error = loadingError {
    ErrorView(message: error.localizedDescription)
} else if isLoading {
    LoadingView()
} else {
    ContentView(data: loadedData)
}

v. User Preferences
Customize the app experience based on user settings like theme preferences, notification opt-ins, or accessibility needs:

if userPrefers(colorScheme: .dark) {
    DarkThemeView()
} else {
    LightThemeView()
}

vi. Contextual Actions
Show different actions or controls depending on item state, selection count, or user permissions:

if isEditMode {
    EditOptionsToolbar()
} else if hasSelection {
    SelectionActionsToolbar()
} else {
    StandardToolbar()
}

2. What Are Comparison Operators?

Comparison operators allow you to evaluate relationships between values, forming the foundation of conditional rendering in SwiftUI. When you compare two values using these operators, the result is always a Boolean value (true or false), making them essential tools for controlling your app's logic. These operators enable your UI to adapt dynamically to changing data and user interactions, allowing your app to make intelligent decisions based on comparing values.

A. Overview of All Operators

Swift offers six primary comparison operators, all resulting in a Boolean (true or false) value:

i. Equal To (==) Checks if two values are identical

if username == "admin" {
    // Execute when values are exactly equal
}

ii. Not Equal (!=) Verifies if two values are different

if userRole != "guest" {
    // Execute when values differ
}

iii. Greater Than (>) Tests if the left value exceeds the right

if score > 80 {
    // Execute when left value exceeds right value
}

iv. Less Than (<) Determines if the left value is smaller than the right

if remainingAttempts < 3 {
    // Execute when left value is smaller than right value
}

v. Greater Than or Equal To (>=) Checks if the left value is greater than or equal to the right

if age >= 18 {
    // Execute when left value is greater than or equal to right value
}

vi. Less Than or Equal To (<=) Verifies if the left value is less than or equal to the right

if price <= budget {
    // Execute when left value is less than or equal to right value
}

B. Best Practices

i. Use Computed Properties for Complex Conditions

struct ProductView: View {
    @State private var quantity = 0
    @State private var isOnSale = false

    // Better approach
    private var isEligibleForDiscount: Bool {
        quantity >= 5 && isOnSale
    }

    var body: some View {
        if isEligibleForDiscount {
            // Show discount information
        }
    }
}

ii. Prefer Ternary for Simple View Switching

// Instead of if-else for simple view choices:
Text(isComplete ? "Completed" : "Pending")
    .foregroundColor(isComplete ? .green : .orange)

iii. Handle Range Comparisons Clearly

// Instead of:
if score >= 0 && score <= 100 {

}

// Use range check:
if (0...100).contains(score) {

}

iv. Combine Related Conditions Logically

// Grouping related conditions improves readability
if isLoggedIn && (isPremiumUser || hasFreeTrial) {
    // Show premium content
}

v. Use Guard for Early Returns

func processPayment() {
    guard balance >= amount else {
        showInsufficientFundsError()
        return
    }

    // Continue with payment processing
}

C. Common Pitfalls

i. Equality vs. Identity Confusion

// Equality (==) compares values
if userA.name == userB.name { /* Same name */ }

// Identity (===) compares object references
if userA === userB { /* Same object instance */ }

ii. Accidental Assignment

// WRONG: This assigns true to isValid and always executes
if isValid = true {
    // Always runs!
}

// CORRECT: This compares isValid to true
if isValid == true {
    // Runs only if isValid is true
}

iii. Floating Point Comparison Issues

// BAD: Direct comparison may fail due to precision
if price == 19.99 {
    // May not execute as expected
}

// BETTER: Use tolerance
if abs(price - 19.99) < 0.001 {
    // More reliable
}

iv. Forgetting to Check for Optionals

// DANGEROUS: Will crash if userName is nil
if userName!.isEmpty {
    // Don't do this
}

// SAFE: Proper optional handling
if let userName = userName, userName.isEmpty {
    // Safe and clear
}

v. Over-Complicated Conditions

// TOO COMPLEX: Hard to understand
if (userRole == "admin" || userRole == "manager") && isActive && (!isPending || hasOverride) {
    // Difficult to read and maintain
}

// BETTER: Break it down
let hasManagementAccess = userRole == "admin" || userRole == "manager"
let hasClearanceForAction = isActive && (!isPending || hasOverride)

if hasManagementAccess && hasClearanceForAction {
    // Much clearer
}

vi. Using if-else Where Switch Would Be Clearer

// VERBOSE: Many if-else statements
if loadingState == .loading {
    return LoadingView()
} else if loadingState == .error {
    return ErrorView()
} else if loadingState == .empty {
    return EmptyView()
} else {
    return ContentView()
}

// CLEARER: Use switch for multiple discrete states
switch loadingState {
case .loading: return LoadingView()
case .error: return ErrorView()
case .empty: return EmptyView()
default: return ContentView()
}

3. What Are If-Else Statements?

If-else statements use the Boolean results from comparison operators to determine which code should execute. They create branches in your code's execution path based on specific conditions. The powerful combination of SwiftUI's declarative approach and Swift's conditional statements allows you to create dynamic UIs that respond instantly to state changes.

A. Why They're Essential in SwiftUI

In SwiftUI, if-else statements serve a special purpose beyond just controlling program flow. They allow you to conditionally include or exclude views from your UI hierarchy based on your app's state. This is what enables dynamic interfaces that can:

Show or hide elements based on user permissions
Present different screens based on authentication status
Display loading indicators while content fetches
Adapt layouts to different device sizes and orientations
Validate form inputs and show appropriate feedback

By mastering if-else statements and comparison operators in SwiftUI, you'll be able to create responsive, adaptive interfaces that provide a polished user experience in any context.

B. Simple View Conditionals

SwiftUI lets you conditionally include or exclude views based on Boolean conditions:

struct WeatherView: View {
    let temperature = 75

    var body: some View {
        VStack(spacing: 20) {
            Text("Current Temperature: \(temperature)°F")
                .font(.title2)

            if temperature > 85 {
                Text("It's hot outside! 🔥")
                    .foregroundColor(.red)
            } else if temperature < 50 {
                Text("It's cold today! ❄️")
                    .foregroundColor(.blue)
            } else {
                Text("The weather is pleasant! 🌤️")
                    .foregroundColor(.green)
            }
        }
        .padding()
    }
}

You can even nest conditionals for more complex view hierarchies:

if isLoggedIn {
    if hasCompletedProfile {
        DashboardView()
    } else {
        ProfileSetupView()
    }
} else {
    LoginView()
}

C. State-Driven UI Changes

Combining @State properties with conditionals creates responsive interfaces:

struct ToggleView: View {
    @State private var isExpanded = false

    var body: some View {
        VStack {
            Button(action: {
                isExpanded.toggle()
            }) {
                Text(isExpanded ? "Show Less" : "Show More")
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
            }

            if isExpanded {
                VStack(alignment: .leading, spacing: 10) {
                    Text("Additional information appears here")
                    Text("You can add as many details as needed")
                    Text("This content only shows when expanded")
                }
                .padding()
                .background(Color.gray.opacity(0.2))
                .cornerRadius(8)
                .transition(.opacity)
            }
        }
        .padding()
        .animation(.spring(), value: isExpanded)
    }
}

D. Ternary Operators in SwiftUI

The ternary operator (condition ? trueValue : falseValue) is ideal for compact conditional expressions:

struct StatusIndicator: View {
    @State private var isActive = true

    var body: some View {
        VStack {
            // Toggle button
            Button("Toggle Status") {
                isActive.toggle()
            }
            .padding()

            // Status with ternary operators
            Text(isActive ? "Active" : "Inactive")
                .foregroundColor(isActive ? .green : .red)
                .font(.headline)

            // Status indicator with ternary
            Circle()
                .foregroundColor(isActive ? .green : .red)
                .frame(width: 20, height: 20)

            // Conditional modifier with ternary
            Text("Status Indicator")
                .padding()
                .background(isActive ? Color.green.opacity(0.3) : Color.red.opacity(0.3))
                .cornerRadius(isActive ? 15 : 5)
        }
    }
}

Ternary operators are particularly useful for:

Toggling between two text values
Switching colors based on state
Applying different modifiers conditionally
Setting dynamic dimensions

4. Practical Examples

Mastering conditional logic in SwiftUI unlocks powerful real-world applications. Here are practical examples that demonstrate how to apply if-else statements and comparison operators in common app scenarios.

A. User Authentication Flows

Authentication systems rely heavily on conditional logic to manage different user states:

struct AuthenticationView: View {
    enum AuthState: String, CaseIterable {
        case signedOut = "Signed Out"
        case authenticating = "Authenticating"
        case signedIn = "Signed In" 
        case error = "Error"
    }

    @State private var authState: AuthState = .signedOut
    @State private var email = ""
    @State private var password = ""
    @State private var errorMessage = "Invalid credentials. Please try again."

    var body: some View {
        VStack {
            // State switcher using segmented control
            Picker("Auth State", selection: $authState) {
                ForEach(AuthState.allCases, id: \.self) { state in
                    Text(state.rawValue).tag(state)
                }
            }
            .pickerStyle(SegmentedPickerStyle())
            .padding(.horizontal)
            .padding(.top)

            Divider()
                .padding(.vertical)

            // Different views based on auth state
            if authState == .signedOut {
                SignInForm(
                    email: $email,
                    password: $password,
                    onSubmit: attemptLogin
                )
            } else if authState == .authenticating {
                ProgressView("Authenticating...")
                    .padding()
            } else if authState == .signedIn {
                VStack {
                    Text("Welcome back!")
                        .font(.title)

                    Button("Sign Out") {
                        authState = .signedOut
                        email = ""
                        password = ""
                    }
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
                }
                .padding()
            } else if authState == .error {
                VStack {
                    Text("Authentication Failed")
                        .font(.title)
                        .foregroundColor(.red)

                    Text(errorMessage)
                        .foregroundColor(.red)
                        .padding()

                    Button("Try Again") {
                        authState = .signedOut
                    }
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
                }
                .padding()
            }

            Spacer()
        }
        .padding()
        .animation(.easeInOut, value: authState)
    }

    private func attemptLogin() {
        authState = .authenticating

        // Simulate network request
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
            if email.lowercased() == "user@example.com" && password == "password123" {
                authState = .signedIn
            } else {
                errorMessage = "Invalid credentials. Please try again."
                authState = .error
            }
        }
    }
}

struct SignInForm: View {
    @Binding var email: String
    @Binding var password: String
    var onSubmit: () -> Void

    var body: some View {
        VStack(spacing: 15) {
            Text("Sign In")
                .font(.largeTitle)
                .padding(.bottom)

            TextField("Email", text: $email)
                .textFieldStyle(RoundedBorderTextFieldStyle())
                .keyboardType(.emailAddress)
                .autocapitalization(.none)

            SecureField("Password", text: $password)
                .textFieldStyle(RoundedBorderTextFieldStyle())

            Button("Sign In") {
                onSubmit()
            }
            .padding()
            .background(Color.blue)
            .foregroundColor(.white)
            .cornerRadius(8)
            .disabled(email.isEmpty || password.isEmpty)
        }
        .padding()
    }
}

B. Dynamic Content Loading

Conditional rendering is perfect for handling different data loading states:

struct NewsArticlesView: View {
    enum LoadingState: String, CaseIterable {
        case idle = "Idle"
        case loading = "Loading"
        case success = "Success"
        case failure = "Failure"
    }

    @State private var loadingState: LoadingState = .idle
    @State private var articles: [Article] = [
        Article(id: 1, title: "SwiftUI Conditional Logic", content: "Learn the basics..."),
        Article(id: 2, title: "Mastering State in SwiftUI", content: "State management...")
    ]
    @State private var errorMessage = "Network error. Please check your connection."

    var body: some View {
        VStack {
            // State switcher using segmented control
            Picker("Loading State", selection: $loadingState) {
                ForEach(LoadingState.allCases, id: \.self) { state in
                    Text(state.rawValue).tag(state)
                }
            }
            .pickerStyle(SegmentedPickerStyle())
            .padding(.horizontal)
            .padding(.top)

            Divider()
                .padding(.vertical)

            // Navigation bar with refresh button
            HStack {
                Text("News Feed")
                    .font(.headline)

                Spacer()

                Button(action: loadArticles) {
                    Image(systemName: "arrow.clockwise")
                }
                .disabled(loadingState == .loading)
            }
            .padding(.horizontal)

            // Conditional content based on loading state
            if loadingState == .idle {
                VStack {
                    Spacer()
                    Text("Tap to load articles")
                        .foregroundColor(.gray)
                    Button("Load News") {
                        loadArticles()
                    }
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
                    Spacer()
                }
            } else if loadingState == .loading {
                VStack {
                    Spacer()
                    ProgressView()
                    Text("Loading articles...")
                        .padding()
                    Spacer()
                }
            } else if loadingState == .success {
                if articles.isEmpty {
                    VStack {
                        Spacer()
                        Text("No articles available")
                            .foregroundColor(.gray)
                            .padding()
                        Spacer()
                    }
                } else {
                    List(articles) { article in
                        ArticleRow(article: article)
                    }
                }
            } else if loadingState == .failure {
                VStack {
                    Spacer()
                    Image(systemName: "exclamationmark.triangle")
                        .font(.largeTitle)
                        .foregroundColor(.orange)
                        .padding()

                    Text("Failed to load articles")
                        .bold()

                    Text(errorMessage)
                        .foregroundColor(.red)
                        .padding(.bottom)

                    Button("Try Again") {
                        loadArticles()
                    }
                    .padding()
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
                    Spacer()
                }
            }
        }
        .animation(.easeInOut, value: loadingState)
    }

    private func loadArticles() {
        loadingState = .loading

        // Simulate network request
        DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
            let success = Bool.random()

            if success {
                articles = [
                    Article(id: 1, title: "SwiftUI Conditional Logic", content: "Learn the basics..."),
                    Article(id: 2, title: "Mastering State in SwiftUI", content: "State management...")
                ]
                loadingState = .success
            } else {
                errorMessage = "Network error. Please check your connection."
                loadingState = .failure
            }
        }
    }
}

struct Article: Identifiable {
    let id: Int
    let title: String
    let content: String
}

struct ArticleRow: View {
    let article: Article

    var body: some View {
        VStack(alignment: .leading) {
            Text(article.title)
                .font(.headline)
            Text(article.content)
                .font(.subheadline)
                .foregroundColor(.gray)
        }
        .padding(.vertical, 4)
    }
}

C. Responsive Layouts

Adapt your layout based on device characteristics and orientation:

struct ResponsiveLayoutExample: View {
    @Environment(\.horizontalSizeClass) var sizeClass
    @State private var screenWidth: CGFloat = UIScreen.main.bounds.width

    var body: some View {
        GeometryReader { geometry in
            VStack {
                // Device info
                Text("Screen Width: \(Int(geometry.size.width))")
                    .font(.headline)

                // Content layout adapts based on available width
                if geometry.size.width > 700 {
                    // Wide layout (iPad, landscape)
                    HStack(alignment: .top, spacing: 20) {
                        sidebar
                        contentArea
                    }
                    .padding()
                } else {
                    // Narrow layout (iPhone, portrait)
                    VStack {
                        sidebar
                        contentArea
                    }
                    .padding()
                }

                // Conditional view based on size class
                if sizeClass == .regular {
                    Text("Regular Size Class - More Detail Available")
                        .font(.caption)
                        .padding()
                        .background(Color.green.opacity(0.2))
                        .cornerRadius(8)
                } else {
                    Text("Compact Size Class - Simplified View")
                        .font(.caption)
                        .padding()
                        .background(Color.orange.opacity(0.2))
                        .cornerRadius(8)
                }
            }
            .onAppear {
                screenWidth = geometry.size.width
            }
            .onChange(of: geometry.size) { newSize in
                screenWidth = newSize.width
            }
        }
    }

    var sidebar: some View {
        VStack(alignment: .leading, spacing: 12) {
            Text("Navigation")
                .font(.headline)

            ForEach(["Home", "Profile", "Settings", "Help"], id: \.self) { item in
                Text(item)
                    .padding(.vertical, 5)
            }
        }
        .frame(maxWidth: screenWidth > 700 ? 200 : .infinity, alignment: .leading)
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }

    var contentArea: some View {
        VStack {
            Text("Main Content Area")
                .font(.headline)

            Text("This area adapts based on the available screen space")
                .multilineTextAlignment(.center)
                .padding()
        }
        .frame(maxWidth: .infinity)
        .padding()
        .background(Color.blue.opacity(0.1))
        .cornerRadius(8)
    }
}

D. Form Validation

Create interactive forms with real-time validation feedback:

struct FormValidationExample: View {
    @State private var username = ""
    @State private var email = ""
    @State private var password = ""
    @State private var passwordConfirm = ""
    @State private var isSubmitted = false

    var usernameValid: Bool {
        username.count >= 4
    }

    var emailValid: Bool {
        email.contains("@") && email.contains(".")
    }

    var passwordValid: Bool {
        password.count >= 8 && 
        password.rangeOfCharacter(from: .decimalDigits) != nil
    }

    var passwordsMatch: Bool {
        password == passwordConfirm
    }

    var formValid: Bool {
        usernameValid && emailValid && passwordValid && passwordsMatch && !password.isEmpty
    }

    var body: some View {
        Form {
            Section(header: Text("Account Information")) {
                TextField("Username", text: $username)
                    .autocapitalization(.none)

                if !username.isEmpty && !usernameValid {
                    Text("Username must be at least 4 characters")
                        .font(.caption)
                        .foregroundColor(.red)
                }

                TextField("Email", text: $email)
                    .autocapitalization(.none)
                    .keyboardType(.emailAddress)

                if !email.isEmpty && !emailValid {
                    Text("Please enter a valid email address")
                        .font(.caption)
                        .foregroundColor(.red)
                }
            }

            Section(header: Text("Password")) {
                SecureField("Password", text: $password)
                SecureField("Confirm Password", text: $passwordConfirm)

                if !password.isEmpty && !passwordValid {
                    Text("Password must be at least 8 characters and include a number")
                        .font(.caption)
                        .foregroundColor(.red)
                }

                if !passwordConfirm.isEmpty && !passwordsMatch {
                    Text("Passwords do not match")
                        .font(.caption)
                        .foregroundColor(.red)
                }
            }

            Section {
                Button(action: submitForm) {
                    Text("Create Account")
                        .frame(maxWidth: .infinity)
                        .padding()
                }
                .disabled(!formValid)
                .background(formValid ? Color.blue : Color.gray)
                .foregroundColor(.white)
                .cornerRadius(8)

                if isSubmitted {
                    Text("Form submitted successfully!")
                        .foregroundColor(.green)
                        .padding(.top)
                }
            }
        }
        .navigationTitle("Registration Form")
    }

    func submitForm() {
        // In a real app, you would submit the data to your backend
        isSubmitted = true
    }
}

These examples illustrate how conditional logic enables common app patterns in SwiftUI. By combining state management with if-else statements and comparison operators, you can create sophisticated, adaptive interfaces that respond appropriately to user input and changing conditions.

5. Advanced Conditional Patterns

In real-world SwiftUI applications, you'll often encounter scenarios that require sophisticated conditional logic. As your app grows in complexity, properly structuring these conditions becomes crucial for maintaining code readability and performance. Let's explore powerful techniques to handle complex conditional patterns effectively.

A. Complex Conditions

When dealing with multiple related conditions, consider these approaches for cleaner code:

i. Computed Properties for Logical Grouping Moving complex conditional logic out of your view body into computed properties provides several key benefits. First, it dramatically improves readability by giving meaningful names to your conditions. Second, it allows you to break down complex multi-part conditions into smaller, more manageable pieces. Finally, it separates the business logic from the UI structure, making your code easier to test and maintain.

struct ProductDetailView: View {
    @State private var product: Product
    @State private var userSubscriptionLevel: SubscriptionTier
    @State private var inventoryCount: Int

    // Complex logic moved out of the view body
    private var canPurchase: Bool {
        // Check inventory
        let isInStock = inventoryCount > 0

        // Check access rights
        let hasAccessRights = product.minRequiredTier <= userSubscriptionLevel

        // Check additional business rules
        let isInUserRegion = product.availableRegions.contains(userRegion)

        return isInStock && hasAccessRights && isInUserRegion
    }

    var body: some View {
        VStack {
            // Much cleaner in the view body
            if canPurchase {
                BuyButton(action: processPurchase)
            } else {
                UnavailableProductView(reason: purchaseBlockReason)
            }
        }
    }

    // Conditional logic to determine why purchase is blocked
    private var purchaseBlockReason: String {
        if inventoryCount == 0 {
            return "Out of stock"
        } else if product.minRequiredTier > userSubscriptionLevel {
            return "Requires \(product.minRequiredTier) subscription"
        } else {
            return "Not available in your region"
        }
    }
}

ii. ViewBuilder for Conditional View Construction The @ViewBuilder attribute is SwiftUI's powerful tool for creating conditional view hierarchies. It allows you to write conditional logic that returns different views based on your app's state, without resorting to type erasure with AnyView. This approach preserves view identity, improves rendering performance, and creates cleaner, more modular code that's easier to maintain as your UI complexity grows.

struct ContentView: View {
    @State private var loadingState: LoadingState = .loading
    @State private var userData: UserData?
    @State private var error: Error?

    var body: some View {
        VStack {
            headerView
            statusView
            footerView
        }
    }

    @ViewBuilder
    private var statusView: some View {
        switch loadingState {
        case .loading:
            ProgressView("Loading your data...")
        case .loaded:
            if let userData = userData {
                UserProfileView(data: userData)
            } else {
                EmptyStateView(message: "No data available")
            }
        case .error:
            ErrorView(message: error?.localizedDescription ?? "Unknown error")
        case .initial:
            StartupView()
        }
    }
}

B. Switch Statements vs If-Else

Choosing between switch statements and if-else constructs is a critical decision that impacts your code's readability and maintainability. While both can accomplish similar goals, each has distinct advantages in different scenarios. Understanding when to use each approach will help you write more elegant and performant SwiftUI code.

i. When to Use If-Else

For simple binary conditions: When your logic only has two possible outcomes (true/false), if-else provides a straightforward approach. The clear visual structure makes it instantly understandable what code executes in each case.
```
if isAuthenticated {
  AuthenticatedDashboardView()
} else {
  LoginView()
}
```
When conditions are unrelated to each other: If you're checking multiple independent conditions that don't follow a pattern, if-else statements allow you to handle each case separately without forcing an artificial relationship between them.
```
if isNetworkAvailable == false {
  OfflineIndicatorView()
}

if hasNewNotifications {
  NotificationBadgeView(count: notificationCount)
}

if shouldShowWelcomeMessage {
  WelcomeMessageView()
}
```
For optional unwrapping patterns: Swift's if-let and guard-let syntax is specifically designed for optional handling, making if-else the more natural choice for conditional unwrapping operations.
```
if let imageData = profileImageData {
  Image(uiImage: UIImage(data: imageData)!)
      .resizable()
      .scaledToFit()
} else {
  DefaultAvatarView()
}
```

ii. When to Use Switch

For multiple related conditions: When you have several conditions that all relate to a single variable or expression, switch statements provide a clear structure that groups all possible paths in one cohesive block, making the code easier to read and maintain.
```
switch userPermissionLevel {
case .admin:
  AdminControlPanelView()
case .editor:
  EditorToolsView()
case .viewer:
  ReadOnlyView()
case .banned:
  AccountRestrictedView()
}
```

When working with enums: Switch statements pair perfectly with enums, providing compile-time verification that all cases are handled. This creates a powerful type-safe approach to conditional UI rendering in SwiftUI.

enum LoadingState {
  case loading, success, error, empty
}

switch viewModel.state {
case .loading:
  ProgressView("Loading content...")
case .success:
  ContentListView(items: viewModel.items)
case .error:
  ErrorView(message: viewModel.errorMessage)
case .empty:
  EmptyStateView(message: "No items found")
}

For pattern matching: Swift's switch statements support sophisticated pattern matching capabilities that go far beyond what's possible with if-else, including value binding, tuple matching, and range matching.

switch (temperature, humidity) {
case (let temp, _) where temp < 0:
  Text("Freezing conditions")
case (0..<15, 0..<30):
  Text("Cold and dry")
case (0..<15, 30...100):
  Text("Cold and humid")
case (15..<25, _):
  Text("Comfortable temperature")
case (25..., 0..<30):
  Text("Hot and dry")
case (25..., 30...100):
  Text("Hot and humid")
default:
  Text("Unusual weather conditions")
}

For exhaustive handling of all cases: Switch statements in Swift must be exhaustive, ensuring you don't forget to handle any possible values. This built-in safety check is invaluable for creating robust UIs that gracefully handle all states.

enum ConnectionStatus {
  case connected, connecting, disconnected, failed
}

switch networkManager.status {
case .connected:
  OnlineView()
case .connecting:
  ConnectingView()
case .disconnected:
  DisconnectedPromptView()
case .failed:
  ConnectionErrorView()
// The compiler will warn if any case is missing!
}

By understanding these nuances, you can choose the most appropriate conditional structure for each situation, resulting in code that's not only more readable but also more maintainable and less prone to bugs.

6. Performance Considerations

Conditional rendering in SwiftUI can significantly impact your app's performance since each state change potentially triggers view recalculations. Optimizing how and when your conditions are evaluated can make the difference between a smooth, responsive UI and one that feels sluggish. Here are key strategies to ensure your conditional logic doesn't become a performance bottleneck.

A. Minimize View Body Recalculations

i. Isolate Expensive Operations The body property of your SwiftUI views is recalculated whenever any state it depends on changes. Complex conditional logic inside the body can lead to unnecessary recalculations and redraws. By isolating expensive operations and complex conditions into computed properties, you ensure they're only evaluated when needed and prevent them from triggering cascading view updates throughout your view hierarchy.

// INEFFICIENT: Recalculates with any state change
var body: some View {
    if calculateComplexCondition() {
        ExpensiveView()
    } else {
        SimpleView()
    }
}

// BETTER: Isolate the expensive calculation
private var shouldShowExpensiveView: Bool {
    calculateComplexCondition()
}

var body: some View {
    if shouldShowExpensiveView {
        ExpensiveView()
    } else {
        SimpleView()
    }
}

B. Use Equatable for Custom Types

i. Implement Equatable Protocol SwiftUI relies on value comparison to determine when views need to be redrawn. By implementing the Equatable protocol for your custom view types, you give SwiftUI the information it needs to avoid unnecessary redraws when your underlying data hasn't meaningfully changed. This is especially important for complex views where redrawing is expensive.

struct UserProfileView: View, Equatable {
    let user: User

    // Implement Equatable to prevent unnecessary redraws
    static func == (lhs: UserProfileView, rhs: UserProfileView) -> Bool {
        lhs.user.id == rhs.user.id && 
        lhs.user.version == rhs.user.version
    }

    var body: some View {
        // Complex view that will only redraw when user ID or version changes
    }
}

C. Lazy Loading for Conditional Content

i. Reduce Memory Usage When parts of your UI are only visible conditionally, using lazy loading ensures those elements are only created when they're actually needed. This reduces memory usage and improves initial load times, especially for complex UI elements that might never be shown to certain users based on their permissions or actions.

VStack {
    // Only builds child views when condition is true
    if showDetailedView {
        LazyVStack {
            ForEach(items) { item in
                DetailRow(item: item)
            }
        }
    }
}

D. State-Driven UI vs. Conditional Content

i. Use a Single State Variable Rather than embedding numerous if-else conditions in your view hierarchy, consider using a state-driven approach where you manage a single state variable that determines which view to display. This pattern is more scalable, easier to debug, and often performs better than deeply nested conditional statements.

// Instead of many conditionals:
if case1 {
    View1()
} else if case2 {
    View2()
} else if case3 {
    View3()
}

// Consider view-state pattern:
@State private var activeViewID: String = "view1"

var body: some View {
    VStack {
        // Navigation
        HStack {
            Button("View 1") { activeViewID = "view1" }
            Button("View 2") { activeViewID = "view2" }
            Button("View 3") { activeViewID = "view3" }
        }

        // Content
        switch activeViewID {
        case "view1": View1()
        case "view2": View2()
        case "view3": View3()
        default: EmptyView()
        }
    }
}

E. Use AnyView Sparingly

i. Preserve View Identity While AnyView can be tempting for returning different view types from conditional logic, it breaks SwiftUI's type safety and view identity tracking. This type erasure prevents SwiftUI from optimizing view updates and can lead to performance issues in complex UIs. Instead, use @ViewBuilder to create conditional content while preserving view identity.

// AVOID: Excessive AnyView usage breaks view identity
func getView() -> some View {
    if condition {
        return AnyView(Text("One"))
    } else {
        return AnyView(Text("Two"))
    }
}

// BETTER: Use ViewBuilder
@ViewBuilder
func getView() -> some View {
    if condition {
        Text("One")
    } else {
        Text("Two")
    }
}

By implementing these performance-focused approaches, you can ensure your conditional logic enhances your SwiftUI app without compromising its responsiveness or efficiency, even as your application scales in complexity.

7. Conclusion

Conditional logic is the backbone of responsive, dynamic SwiftUI interfaces. By mastering if-else statements and comparison operators, you've gained essential skills for creating applications that adapt intelligently to user actions, data states, and device characteristics. We've explored everything from basic comparisons to advanced patterns like computed properties, ViewBuilder implementations, and performance optimization techniques.

The powerful combination of SwiftUI's declarative syntax and Swift's conditional expressions creates a foundation for building interfaces that respond instantly to state changes without manual manipulation. This approach not only improves code maintainability but also enhances the user experience by ensuring your app feels responsive and contextually aware.

Next Steps

i. Practice with Real-World Scenarios Apply these patterns in authentication flows, data loading sequences, and form validation contexts.

ii. Explore State Management Libraries Consider how frameworks like The Composable Architecture (TCA) or Redux can help manage complex conditional states.

iii. Combine with SwiftUI Animations Learn how to animate between conditional states for smoother transitions.

iv. Implement Accessibility Considerations Use conditionals to adapt your UI for different accessibility needs.

v. Performance Profiling Use Instruments to measure the impact of your conditional rendering approaches and optimize accordingly.

vi. Study Apple's Design Patterns Examine how Apple's own apps implement conditional UI patterns for inspiration.

vii. Create Reusable Conditional Components Build your own library of state-aware, conditionally rendering components to use across projects.

By continuing to refine these skills, you'll be able to create increasingly sophisticated and intuitive interfaces that delight your users while maintaining clean, maintainable code.

Learn with videos and source files. Available to Pro subscribers only.

Purchase includes access to 50+ courses, 320+ premium tutorials, 300+ hours of videos, source files and certificates.

BACK TO

Arithmetic Operators

Download source files

Download the videos and assets to refer and learn offline without interuption.

Design template

Source code for all sections

Video files, ePub and subtitles

Browse all downloads

Building Your iOS Development Foundation

Master the fundamentals of Swift programming with hands-on examples designed for beginners and experienced developers alike

Comments: Documentation Waypoints in Your SwiftUI Codebase

Transform your code from mysterious instructions to a comprehensive narrative with strategic comments that explain the why

22:02

SwiftUI Print Debugging

Print debugging: Unlock the invisible processes with strategic print statements that illuminate state changes, view lifecycles and data flow

18:04

Variables and Constants

Learn when and how to use variables and constants to write safer, more efficient SwiftUI code

11:37

Strings and Interpolation

Learn essential string operations in Swift: Build better iOS apps with efficient text handling techniques

13:22

Swift Operators: The Foundation of SwiftUI Logic

Building powerful iOS apps through the language of operations

Unary Operators

Mastering the elegant simplicity of unary operators for cleaner, more expressive SwiftUI code that transforms your UI with minimal syntax

Binary Operators

Master the two-operand symbols that transform complex interface logic into concise, readable declarations

Arithmetic Operators

Learn how to implement and optimize arithmetic operations in SwiftUI, from basic calculations to complex mathematical interfaces

If-Else and Comparison Operators

Building Dynamic SwiftUI: Mastering If-Else and Comparison Operators

Logical Operators

Master SwiftUI's logical operators: Building intelligent iOS apps with robust decision-making systems

Ternary Operators

Use the power of Swift's ternary conditional operator to create dynamic, responsive interfaces with minimal code in SwiftUI

Blocks and Scope

A comprehensive guide to writing clean, organized code through proper variable management and state control

10:22

Swift Collections: Arrays, Sets, and Dictionaries Overview

Organize Your Data Effectively: Learn How to Choose and Optimize the Perfect Collection Type for Your SwiftUI Applications

Swift Arrays: The Basics Part 1

Master essential array operations and manipulations to build a solid foundation for iOS development

Swift Arrays: Best Practices in SwiftUI Part 2

Integrate arrays with SwiftUI, optimize performance, and implement professional-grade patterns for production apps

Swift Sets

From Basics to Advanced: Swift Set Techniques for Better Apps

Meet the instructor

We all try to be consistent with our way of teaching step-by-step, providing source files and prioritizing design in our courses.

Sourasith Phomhome

UI Designer

Designer at Design+Code

19 courses - 74 hours

Design Multiple Apps with Figma and AI

In this course, you’ll learn to design multiple apps using Figma and AI-powered tools, tackling a variety of real-world UI challenges. Each week, a new episode will guide you through a different design, helping you master essential UI/UX principles and workflows

4 hrs

SwiftUI Fundamentals Handbook

A comprehensive guide to mastering Swift programming fundamentals, designed for aspiring iOS developers. This handbook provides a structured approach to learning Swift's core concepts, from basic syntax to advanced programming patterns. Through carefully sequenced chapters, readers will progress from essential programming concepts to object-oriented principles, building a solid foundation for SwiftUI development. Each topic includes practical examples and clear explanations, ensuring a thorough understanding of Swift's capabilities. This handbook serves as both a learning resource and a reference guide, covering fundamental concepts required for modern iOS development. Topics are presented in a logical progression, allowing readers to build their knowledge systematically while gaining practical programming skills.

1 hrs

Design and Code User Interfaces with Galileo and Claude AI

In this course, you’ll learn how to use AI tools to make UI/UX design faster and more efficient. We’ll start with Galileo AI to create basic designs, providing a solid foundation for your ideas. Next, we’ll refine these designs in Figma to match your personal style, and finally, we’ll use Claude AI to turn them into working code—eliminating the need for traditional prototyping.

4 hrs

Build a React Native app with Claude AI

This comprehensive course explores the integration of cutting-edge AI tools into the React Native development workflow, revolutionizing the approach to mobile application creation. Participants will learn to leverage AI-powered platforms such as Claude and Locofy to expedite coding processes, enhance problem-solving capabilities, and optimize productivity.

13 hrs

Design and Prototype for iOS 18

Design and Prototype for iOS 18 is an immersive course that equips you with the skills to create stunning, user-friendly mobile applications. From mastering Figma to understanding iOS 18's latest design principles, you'll learn to craft two real-world apps - a Car Control interface and an AI assistant.

3 hrs

Master Responsive Layouts in Figma

Creating responsive layouts is a must-have skill for any UI/UX designer. With so many different devices and screen sizes, designing interfaces that look great and work well on all platforms is necessary. Mastering this skill will make you stand out in the field. In this course, we'll start from scratch to create this beautiful design using Figma. You'll learn how to make layouts that are easy to use and work well on any device. We'll cover key concepts and tools to help you master responsive design in Figma.

2 hrs

UI UX Design with Mobbin and Figma

Mobbin is a powerful tool for UI/UX designers seeking inspiration and innovative design solutions. This platform offers a vast collection of real-world mobile app designs, providing a treasure trove of UI elements and layouts.

2 hrs

3D UI Interactive Web Design with Spline

Learn to create 3D designs and UI interactions such as 3D icons, UI animations, components, variables, screen resize, scrolling interactions, as well as exporting, optimizing, and publishing your 3D assets on websites

3 hrs

Design and Prototype for iOS 17 in Figma

Crafting engaging experiences for iOS 17 and visionOS using the Figma design tool. Learn about Figma's new prototyping features, Dev Mode, variables and auto layout.

6 hrs

Design and Prototype Apps with Midjourney

A comprehensive course on transforming Midjourney concepts into interactive prototypes using essential design techniques and AI tools

8 hrs

iOS Design with Midjourney and Figma

Learn the fundamentals of App UI design and master the art of creating beautiful and intuitive user interfaces for mobile applications

1 hrs

UI Design for iOS, Android and Web in Sketch

Create a UI design from scratch using Smart Layout, Components, Prototyping in Sketch app

1 hrs

UI Design a Camera App in Figma

Design a dark, vibrant and curvy app design from scratch in Figma. Design glass icons, lens strokes and realistic buttons.

1 hrs

UI Design for iOS 16 in Sketch

A complete guide to designing for iOS 16 with videos, examples and design files

3 hrs

Prototyping in Figma

Learn the basics of prototyping in Figma by creating interactive flows from custom designs

1 hrs

UI Design Quick Websites in Figma

Learn how to design a portfolio web UI from scratch in Figma

1 hrs

UI Design Android Apps in Figma

Design Android application UIs from scratch using various tricks and techniques in Figma

2 hrs

UI Design Quick Apps in Figma

Design application UIs from scratch using various tricks and techniques in Figma

12 hrs

Figma Handbook

A comprehensive guide to the best tips and tricks in Figma

6 hrs