Conditional Statements & Operators

Topics Covered in This iOS Development Tutorial:

Conditional Statements, Comparison Operators, Arithmetic Operators, Logical Operators, Switch Statements

Exercise Overview

Conditional logic forms the backbone of every iOS application you've ever used. In this comprehensive exercise, you'll master the art of testing conditions and executing code based on outcomes—the fundamental skill that powers everything from user authentication to dynamic UI updates. You'll explore the full spectrum of operators (arithmetic, comparison, and logical) and discover how they combine to create sophisticated decision-making systems in your Swift applications.

Getting Started

1. Launch Xcode if it isn't already open.

2. If you completed the previous exercise, Variables.playground should still be open. If you closed it, re-open it now.

3. We strongly recommend completing the previous exercise (1C) before proceeding. If you did not complete the previous exercise, follow these steps:

   • Go to File > Open.
   • Navigate to Desktop > Class Files > yourname-iOS App Dev 1 Class and double–click on Swift Basics Ready for Conditionals.playground.

Conditional Statements

Every successful iOS application relies on conditional logic to create dynamic, responsive user experiences. When you launch Netflix, the app doesn't just display content—it makes dozens of decisions: Is the user logged in? What device are they using? What content should be recommended? These decisions are powered by if statements that test conditions and execute code accordingly. Understanding conditional logic is essential for building applications that respond intelligently to user input and changing data.

1. Let's construct your first if statement. The syntax begins with the keyword if, followed by the condition to test, then a set of curly braces ({}) containing the code to execute when the condition evaluates to true. Add this code at the bottom of your Xcode playground:

   if numberOfVerses == 4 {
      print("Yes the number of verses is 4")
   }

   Here, you're testing whether the constant numberOfVerses equals 4 using the equality comparison operator (==). Notice how this differs from the assignment operator (=)—a critical distinction we'll explore in depth shortly.

2. Boolean values offer a particularly elegant approach to conditional testing. Add this statement at the bottom:

   if iAmInHere == true {
      print("Yes I am in here")
   }

   Since you previously set iAmInHere to true, the condition evaluates successfully and prints the message. Booleans represent one of programming's most fundamental concepts—the binary nature of logical decisions that drive all computational thinking.

3. Now observe how changing the underlying data affects conditional execution. Navigate to the iAmInHere declaration (located in the middle of your code) and modify the value:

   var iAmInHere = false

4. Watch the right panel—the statement (Yes I am in here) disappears immediately. This demonstrates a fundamental principle: if statements execute their code blocks only when the tested condition evaluates to true. This binary behavior forms the foundation of all program logic.

5. Change the value back to true to restore the previous behavior.

6. Real-world applications require handling both positive and negative outcomes. The if/else construct provides this capability. Add this new conditional statement:

   if numberOfVerses == 5 {
      print("It is equal to 5")
   }

7. Now add the alternative execution path:

   if numberOfVerses == 5 {
      print("It is equal to 5")
   } else {
      print("No it is not equal to 5")
   }

8. Since numberOfVerses equals 4 (not 5), the condition fails and the else block executes, printing: No it is not equal to 5. This pattern ensures your application always responds appropriately, regardless of the data it encounters.

9. Complex applications often require testing multiple specific conditions. The else if construct enables this sophisticated decision-making. Add this code:

   if numberOfVerses == 5 {
      print("It is equal to 5")
   } else if numberOfVerses == 3 {
      print("It is equal to 3")
   }

   Since numberOfVerses equals 4, both conditions fail, and neither print statement executes. This demonstrates how conditional chains allow for precise, multi-path decision logic.

10. Modify the code to create a successful condition:

    if numberOfVerses == 5 {
       print("It is equal to 5")
    } else if numberOfVerses == 4 {
       print("It is equal to 4")
    }

11. The right panel now displays: It is equal to 4, confirming that your conditional logic is working correctly.

Comparison Operators

Comparison operators serve as the decision-making tools of programming, enabling your applications to evaluate relationships between values with precision. These operators return boolean values (true or false) that drive conditional logic throughout your iOS applications. Mastering these operators is crucial for implementing features like user validation, data filtering, and dynamic content display.

1. Let's implement the greater than operator in a practical scenario. Add this code:

   if numberOfVerses > 3 {
      print("Yes there are more than 3 verses")
   }

   Since numberOfVerses equals 4, this condition evaluates to true, demonstrating how comparison operators enable range-based logic in your applications.

2. Copy the greater than if statement and paste it directly below to create a foundation for the next example.
3. Transform the copy into a less than comparison:
   

   if numberOfVerses < 10 {
      print("Yes there are less than 10 verses")
   }

   This condition also evaluates to true, showcasing how multiple comparison operators can validate different aspects of the same data.

4. Create another copy and modify it to demonstrate the not equal to operator:
   

   if numberOfVerses != 5 {
      print("No this song does not have 5 verses")
   }

   Since numberOfVerses equals 4 (which is indeed not equal to 5), this condition succeeds and prints the message.

5. Boolean values require special consideration due to their binary nature. Locate this if statement from earlier in the exercise:

   if iAmInHere == true {
      print("Yes I am in here")
   }

6. With boolean variables, explicitly comparing to true creates unnecessary code complexity. Simplify the statement by removing the redundant comparison:

   if iAmInHere {
      print("Yes I am in here")
   }

   This cleaner syntax is preferred in professional Swift development and clearly communicates the boolean's role in the conditional test.

7. To test for a false boolean value, use the logical not operator. Add this code at the bottom:

   if !iAmInHere {
      print("No I am not in here")
   }

   The not operator (!) inverts the boolean value, so this statement executes when iAmInHere is false. This operator belongs to the logical operators family, which we'll explore comprehensively in the upcoming section.

8. Notice that no message appears in the right panel. Locate the iAmInHere declaration:

   var iAmInHere = true

9. Change the value to demonstrate the not operator's functionality:

   var iAmInHere = false

   The print message now appears in the right panel, confirming that the not operator correctly inverted the boolean test.

10. Remove the not operator from the last conditional statement to observe the change in behavior:

    if iAmInHere {

    The message disappears because the statement now tests whether iAmInHere is true, but its current value is false.

11. Restore the not operator to complete this section:

    if ! iAmInHere {

Arithmetic Operators

Mathematical calculations power countless features in iOS applications—from calculating tip amounts in restaurant apps to determining progress percentages in fitness trackers. Swift's arithmetic operators provide the foundation for these calculations, enabling your applications to process numerical data dynamically and present meaningful results to users.

Swift supports these essential arithmetic operators:

1. Create variables that simulate a real-world scenario involving dynamic calculations. Add this code to your playground:

   var songsInSetList = 18
   var totalSongsPlayed: Int

   Notice the explicit type declaration for totalSongsPlayed—this is required when declaring variables without initial values, ensuring type safety throughout your application.

2. Simulate a concert scenario where the band performs additional songs during an encore. Implement this calculation using the addition operator:

   totalSongsPlayed: Int
   
   totalSongsPlayed = songsInSetList + 3

   This demonstrates how arithmetic operators enable dynamic calculations based on changing conditions—a fundamental requirement in interactive applications.

3. Display the calculated result using string interpolation:

   totalSongsPlayed = songsInSetList + 3
   print("They played \(totalSongsPlayed) songs!")

   The right panel should display: They played 21 songs!, demonstrating how arithmetic results integrate seamlessly with output formatting.

4. Model a different scenario using subtraction to handle cases where plans change. Add this code:
   

   totalSongsPlayed = songsInSetList - 4
   print("They only played \(totalSongsPlayed) songs...")

   The output They only played 14 songs... shows how the same variable can be recalculated based on different conditions—a pattern common in responsive applications.

5. Extend the scenario to include financial calculations, demonstrating multiplication and division operators. Add these variables:

   var ticketPrice = 20
   var peopleAttended = 100
   var bandMembers = 4

6. Calculate total revenue using multiplication:

   var moneyMade = ticketPrice * peopleAttended
   print("The band made $\(moneyMade).")

   This calculation pattern appears frequently in commercial applications—from e-commerce total calculations to subscription revenue modeling.

7. The right panel displays: The band made $2,000, confirming the multiplication operation's success.

8. Complete the financial model using division to distribute the total among band members:
   

   var membersCut = moneyMade / bandMembers
   print("Each member got a $\(membersCut) cut from the gig.")

9. The output Each member got a $500 cut from the gig demonstrates equitable distribution through division.

   NOTE: Arithmetic operators support compound calculations following standard mathematical order of operations (precedence rules). Use parentheses to group expressions when you need to override default precedence, ensuring calculations execute in the intended sequence.

Logical Operators

Logical operators enable sophisticated decision-making by combining multiple conditions into complex boolean expressions. These operators power advanced features like multi-criteria search filters, comprehensive form validation, and intelligent user interface states. Professional iOS applications rely heavily on logical operators to create nuanced, context-aware user experiences.

The and operator proves invaluable when multiple conditions must be satisfied simultaneously—such as validating that a user is both logged in and has premium access before displaying exclusive content.

1. Implement a compound condition using the and operator:
   

   if numberOfVerses == 4 && songRating > 3 {
      print("Yes this is a good song")
   }

   This statement requires both conditions to be true: numberOfVerses must equal 4 AND songRating must exceed 3. This pattern mirrors real-world scenarios where multiple criteria determine user access or content eligibility.

   Since both conditions are currently true, the message prints successfully.

2. Demonstrate how the and operator behaves when one condition fails:

   if numberOfVerses == 5 && songRating > 3 {

   The message disappears because the first condition now evaluates to false, causing the entire and expression to fail—regardless of the second condition's truth value.

3. Copy the modified if statement to create a foundation for exploring the or operator.

4. Paste the statement at the bottom of your playground.

5. Transform the and operator into an or operator by replacing && with || (created by pressing Shift-Backslash):

   if numberOfVerses == 5 || songRating > 3 {
      print("Yes this is a good song")
   }

   The or operator succeeds when either condition is true. Since songRating > 3 evaluates to true (even though numberOfVerses == 5 is false), the entire expression succeeds and the message prints.

6. String comparison follows the same patterns as numerical comparison, enabling powerful text-based conditional logic. Add this code:

   songName = "Comfortably Numb"
   
   if songName == "Comfortably Numb" {
      print("Yep that is the song name")
   }

   String equality checks form the foundation of user input validation, search functionality, and content filtering in iOS applications.

7. Combine multiple logical operators to create sophisticated conditional logic:

   if (numberOfVerses == 5 || songRating > 3) && songName == "Comfortably Numb" {
      print("Yes this is the right song")
   }

   Notice the parentheses around the or condition. Just as multiplication takes precedence over addition in arithmetic, the and operator (&&) takes precedence over the or operator (||) in logical expressions. The parentheses ensure that the or condition evaluates first, then the result combines with the string comparison using and logic.

8. The right panel displays: Yes this is the right song, confirming that complex logical expressions can successfully combine multiple data types and conditions.

Switch Statements

Switch statements provide an elegant solution for handling multiple discrete values, offering superior readability and performance compared to lengthy if-else chains. Modern iOS applications use switch statements extensively for handling user interface states, processing API response codes, and managing complex enumerated values. When you need to evaluate more than three possible outcomes, switch statements represent the professional standard for clean, maintainable code.

1. Begin by establishing a variable that will demonstrate switch statement capabilities:

   var userName = "DrFalken"

2. Construct the switch statement framework using proper Swift syntax. The switch keyword precedes the variable being evaluated:

   switch userName {
   
   }

3. Define specific cases using the case keyword. Each case represents a potential value that triggers specific code execution:

   switch userName {
   
      case "DrFalken", "David":
      print("Welcome, \(userName). Would you like to play a game?")
   
      case "Jennifer":
      print("Welcome, Jennifer!")
   
      case "McKittrick":
      print("I'm sorry, your access has been revoked.")
   
   }

   Notice how the first case handles multiple values ("DrFalken" and "David") separated by commas—this demonstrates switch statements' ability to group related conditions efficiently.

4. Add the required default clause to handle any values not explicitly covered by the defined cases:

   switch userName {
   
      case "DrFalken", "David":
      print("Welcome, \(userName). Would you like to play a game?")
   
      case "Jennifer":
      print("Welcome, Jennifer!")
   
      case "McKittrick":
      print("I'm sorry, your access has been revoked.")
   
      default: 
      print("I'm sorry, \(userName), but you are not authorized to log in.")
   
   }

   The default clause ensures your switch statement handles all possible input values gracefully—a critical requirement for robust application behavior. Swift only allows omitting the default clause when all possible values are explicitly covered, such as with boolean values or complete enumeration cases.

5. Since userName contains "DrFalken", the first case executes and displays: Welcome, DrFalken. Would you like to play a game? This demonstrates how switch statements provide precise, readable control flow for complex decision logic.

6. Save your work and close the file. Keep Xcode open for the next exercise, where you'll build upon these fundamental concepts to create more sophisticated iOS functionality.