# Swift If Else: Conditions, Syntax, and Practical Examples Source: https://devdocs10.com/articles/swift/swift-if-else By Murat Bo · Published 2026-05-12 · DevDocs10 (https://devdocs10.com) Swift uses `if`, `else if`, and `else` to run different code depending on whether a condition is true or false. This is one of the most important control flow tools in Swift, because it lets your programs make decisions based on user input, data values, and application state. > **Quick answer:** In Swift, an `if` statement checks a Boolean condition. If the condition is `true`, that block runs; if it is `false`, Swift can run an `else` block or test another condition with `else if`. > **Difficulty:** Beginner > > **Helpful to know first:** You'll understand this better if you know basic Swift syntax, how variables store values, and simple types like `Int`, `String`, and `Bool`. ## 1. What Is If & Else? An `if` statement is a conditional branch. It asks a yes-or-no question using a Boolean expression and then decides which code should run. - `if` runs code only when a condition is true. - `else` runs code when the `if` condition is false. - `else if` lets you test additional conditions in order. - Swift requires each condition to evaluate to a real `Bool`. - This is different from some languages that allow numbers or strings as conditions. For example, a program might check whether a score is passing, whether a username is empty, or whether an age is high enough for a feature. Without conditional logic, programs would always behave the same way regardless of input. > A common beginner confusion is expecting Swift to treat values like `1` or a non-empty string as true automatically. Swift does not do that. The condition must already be Boolean, such as `age >= 18` or `isLoggedIn`. ## 2. Why If & Else Matters Almost every real Swift program depends on decision-making. Even simple command-line programs need to compare values and choose between outcomes. You use `if` and `else` when you need to: - validate user input before processing it - show different messages for different cases - guard against invalid values - choose one calculation path over another - respond differently to app state, permissions, or settings You should not use long chains of `if` statements when the logic is better represented by another tool, such as `switch` for many fixed matching cases. But for everyday true-or-false decisions, `if` is usually the clearest choice. ## 3. Basic Syntax The basic form of an `if` statement in Swift is very direct. You write a Boolean condition after `if`, then place the code to run inside braces. ### Simple if statement This example runs a line only when the condition is true. ```swift let age = 20 if age >= 18 { print("You are an adult.") } ``` Output (tested with Swift 6.4): ```text You are an adult. ``` Here, `age >= 18` produces a Boolean result. Because it is true, the print statement runs. ### If with else Use `else` when you want one path for true and another path for false. ```swift let isRaining = true if isRaining { print("Take an umbrella.") } else { print("Enjoy the weather.") } ``` Output (tested with Swift 6.4): ```text Take an umbrella. ``` Because `isRaining` is already a Boolean, it can be used directly as the condition. ### If with else if Use `else if` when you need to test more than two possibilities. ```swift let temperature = 12 if temperature >= 25 { print("It's warm.") } else if temperature >= 15 { print("It's mild.") } else { print("It's cool.") } ``` Output (tested with Swift 6.4): ```text It's cool. ``` Swift checks these conditions from top to bottom and stops at the first true one. ### Operators commonly used in conditions Conditions often use comparison and logical operators. ```swift let score = 85 let hasBonus = true if score >= 80 && hasBonus { print("Excellent result.") } ``` Output (tested with Swift 6.4): ```text Excellent result. ``` In this code, `>=` compares values and `&&` requires both conditions to be true. ## 4. Step-by-Step Examples ### Example 1: Checking if a number is positive This example uses a simple true-or-false check. ```swift let number = 7 if number > 0 { print("The number is positive.") } ``` Output (tested with Swift 6.4): ```text The number is positive. ``` Because `7 > 0` is true, the message is printed. ### Example 2: Choosing between two messages This version uses `else` so one branch always runs. ```swift let username = "Taylor" if username == "" { print("Please enter a username.") } else { print("Welcome, \(username)!") } ``` Output (tested with Swift 6.4): ```text Welcome, Taylor! ``` If the string is empty, the program asks for input. Otherwise, it prints a welcome message. ### Example 3: Grading with else if Multiple ranges are a common reason to use `else if`. ```swift let grade = 76 if grade >= 90 { print("A") } else if grade >= 80 { print("B") } else if grade >= 70 { print("C") } else { print("Needs improvement") } ``` Output (tested with Swift 6.4): ```text C ``` Swift checks from top to bottom. Since `76 >= 70` is the first true condition, it prints `C`. ### Example 4: Combining conditions You can combine multiple Boolean expressions to create more specific rules. ```swift let age = 22 let hasTicket = true if age >= 18 && hasTicket { print("Entry allowed.") } else { print("Entry denied.") } ``` Output (tested with Swift 6.4): ```text Entry allowed. ``` This is useful when more than one rule must be satisfied at the same time. ## 5. Practical Use Cases - Checking whether a user is old enough to access a feature. - Displaying different text when a form field is empty or filled in. - Validating a password length before allowing account creation. - Choosing a shipping fee based on order total. - Handling game logic such as win, lose, or bonus states. - Deciding whether to retry a task based on a success flag. - Showing different output based on numeric ranges like scores, prices, or temperatures. ## 6. Common Mistakes ### Mistake 1: Using a non-Boolean value as the condition In Swift, the condition inside an `if` statement must evaluate to `true` or `false`. A number or string cannot be used directly as a condition. **Problem:** This code uses an `Int` where Swift expects a `Bool`, so it will not compile. ```swift let count = 3 if count { print("There are items.") } ``` **Fix:** Write a comparison that produces a Boolean value. ```swift let count = 3 if count > 0 { print("There are items.") } ``` Output (tested with Swift 6.4): ```text There are items. ``` The corrected version works because `count > 0` evaluates to a Boolean. ### Mistake 2: Writing assignment instead of comparison Beginners sometimes try to compare values using `=` instead of `==`. In Swift, `=` assigns a value, while `==` checks equality. **Problem:** This condition attempts assignment where a Boolean comparison is required, so the code is invalid. ```swift var isMember = true if isMember = true { print("Discount applied.") } ``` **Fix:** Compare with `==`, or use the Boolean variable directly when possible. ```swift let isMember = true if isMember { print("Discount applied.") } ``` Output (tested with Swift 6.4): ```text Discount applied. ``` The corrected version works because the condition is a proper Boolean expression. ### Mistake 3: Ordering else if conditions incorrectly When conditions overlap, order matters. Swift stops at the first true branch, so a broad condition placed first can hide a more specific one below it. **Problem:** This code checks the lower threshold first, so the higher-score branch never runs for values above 90. ```swift let score = 95 if score >= 70 { print("Passed") } else if score >= 90 { print("Excellent") } ``` Output (tested with Swift 6.4): ```text Passed ``` **Fix:** Put the most specific or highest-priority condition first. ```swift let score = 95 if score >= 90 { print("Excellent") } else if score >= 70 { print("Passed") } ``` Output (tested with Swift 6.4): ```text Excellent ``` The corrected version works because Swift reaches the more specific match before the broader one. ### Mistake 4: Comparing a Boolean to true or false unnecessarily Swift allows direct use of Boolean values in conditions. Explicit comparisons to `true` or `false` are often longer and less readable. **Problem:** This code is more verbose than necessary and can make simple conditions harder to read. ```swift let isLoggedIn = false if isLoggedIn == true { print("Show dashboard.") } else { print("Show sign-in screen.") } ``` Output (tested with Swift 6.4): ```text Show sign-in screen. ``` **Fix:** Use the Boolean directly, or negate it with `!` when needed. ```swift let isLoggedIn = false if isLoggedIn { print("Show dashboard.") } else { print("Show sign-in screen.") } ``` Output (tested with Swift 6.4): ```text Show sign-in screen. ``` The corrected version works because the condition is shorter and clearer without changing the logic. ## 7. Best Practices ### Use conditions that read like plain logic Good conditional code should be easy to read without extra mental effort. Favor expressions that make the rule obvious. Less clear: ```swift let temperature = 30 if !(temperature < 25) { print("Hot day") } ``` Output (tested with Swift 6.4): ```text Hot day ``` Preferred: ```swift let temperature = 30 if temperature >= 25 { print("Hot day") } ``` Output (tested with Swift 6.4): ```text Hot day ``` The preferred version communicates the rule directly. ### Put special cases before general cases When multiple branches overlap, place the most specific match first. This prevents broader conditions from catching values too early. Less preferred: ```swift let points = 100 if points >= 50 { print("Reward unlocked") } else if points == 100 { print("Maximum reward unlocked") } ``` Output (tested with Swift 6.4): ```text Reward unlocked ``` Preferred: ```swift let points = 100 if points == 100 { print("Maximum reward unlocked") } else if points >= 50 { print("Reward unlocked") } ``` Output (tested with Swift 6.4): ```text Maximum reward unlocked ``` The preferred version preserves the intended priority of the conditions. ### Keep each branch focused If branches become very long, the decision itself becomes harder to understand. Keep the condition simple and move complex work into functions when possible. Less preferred: ```swift let isPremium = true if isPremium { print("Load premium dashboard") print("Load premium widgets") print("Load premium reports") } ``` Output (tested with Swift 6.4): ```text Load premium dashboard Load premium widgets Load premium reports ``` Preferred: ```swift func showPremiumExperience() { print("Load premium dashboard") print("Load premium widgets") print("Load premium reports") } let isPremium = true if isPremium { showPremiumExperience() } ``` Output (tested with Swift 6.4): ```text Load premium dashboard Load premium widgets Load premium reports ``` The preferred version makes the decision logic easier to scan and reuse. ## 8. Limitations and Edge Cases - Swift requires a Boolean condition. You cannot use integers, strings, or optionals as truthy or falsy shortcuts. - Only the first matching branch in an `if` / `else if` chain runs. - Long chains of conditions can become hard to maintain. In some cases, `switch` is clearer. - Conditions are checked in order, so branch order can change program behavior. - An `else` block is optional. If it is missing and the condition is false, no branch runs. - Complex combined conditions with `&&` and `||` can be difficult to read without parentheses. - If your condition depends on an optional value, you often need optional binding such as `if let` rather than a plain comparison. > A common next-step comparison is plain `if` versus `if let`. Plain `if` checks a Boolean condition, while `if let` safely unwraps an optional only if it contains a value. ## 9. Practical Mini Project This small program checks an order total and membership status to decide shipping and discount messages. It uses `if`, `else if`, and `else` in a realistic way. ```swift let orderTotal = 72.5 let isMember = true if orderTotal >= 100 { print("You qualify for free express shipping.") } else if orderTotal >= 50 { print("You qualify for free standard shipping.") } else { print("Shipping charges apply.") } if isMember { print("Member discount applied.") } else { print("Join to receive member discounts.") } ``` Output (tested with Swift 6.4): ```text You qualify for free standard shipping. Member discount applied. ``` This example shows two separate decisions. The first checks a numeric range for shipping, and the second checks a Boolean flag for membership benefits. ## 10. Key Points - `if` runs code only when its condition is true. - `else` provides a fallback path when the `if` condition is false. - `else if` lets you test multiple conditions in sequence. - Swift conditions must evaluate to `Bool`. - Condition order matters because Swift stops at the first true branch. - Comparison and logical operators are commonly used inside conditions. - Readable conditions and clear branch order make code easier to maintain. ## 11. Practice Exercise Build a small program that checks a person's age and prints the correct ticket category. - If the age is less than 13, print `Child ticket`. - If the age is from 13 through 64, print `Standard ticket`. - If the age is 65 or older, print `Senior ticket`. **Expected output:** For an age of `70`, the program should print `Senior ticket`. **Hint:** Start by checking the highest-priority or most specific range in a clear order. ```swift let age = 70 if age < 13 { print("Child ticket") } else if age >= 65 { print("Senior ticket") } else { print("Standard ticket") } ``` Output (tested with Swift 6.4): ```text Senior ticket ``` ## 12. Final Summary Swift `if`, `else if`, and `else` statements are the foundation of decision-making in your code. They let you branch based on Boolean conditions, compare values, combine rules with logical operators, and choose the right behavior for each situation. In this article, you saw the core syntax, worked through practical examples, learned how branch order affects results, and fixed common mistakes such as using non-Boolean conditions or writing comparisons incorrectly. Once you are comfortable with `if` and `else`, a useful next step is learning related Swift control flow tools such as `switch`, `guard`, and `if let` for optionals.