In this tutorial, you'll learn about if-statements, using which you can do certain things only if certain conditions are met. In plain English, if-statements correspond to “Do this; then do that.” or “If this condition is true, perform this action; otherwise, do that action.”

A good way to visualize if-statements is flow charts. If-statements represent the yes / no questions in the flowchart below.

Before getting into if-statements, you'll first learn how to compare things in Swift as well as the Boolean data type (values true and false). At the end of the lesson, you'll also see comments, which are useful for making your code more readable and easy to follow.

Compare things

A big part of programming involves comparing things. What's the easiest thing to compare? Numbers, of course. Let's see how that works:

5 > 2
// true
2 > 5
// false
5 > 2 * 2
// true
1 == 1
// true
5 != 2
// true

We gave Swift some numbers to compare. As you can see, not only can Swift compare numbers, but it can also compare method results. Nice, huh?

Do you wonder why we put two equal signs == next to each other to compare if numbers are equal? We use a single = for assigning values to variables. You always, always need to put two of them – == – if you want to check if things are equal to each other. We can also state that things are unequal to each other. For that, we use the symbol !=, as shown in the example above.

6 >= 12 / 2
// true
3 <= 2 
// false

We've seen > and <, but what do >= and <= mean? Read them like this:

• x > y means: x is greater than y
• x < y means: x is less than y
• x <= y means: x is less than or equal to y
• x >= y means: x is greater than or equal to y

Swift also has logical operators which allows us to combine multiple comparison. You can give Swift as many numbers to compare as you want, and it will give you an answer! The following are the logical operators:

• and operator (&&) – if you use the && operator, both comparisons have to be true in order for the whole expression to be true.
• or operator (||) – if you use the || operator, only one of the comparisons has to be true in order for the whole expression to be true
• not operator (!) - if you use the ! operator, it inverts the value of the expression

Here are some examples:

6 > 2 && 3 > 1
// true (both sides are true)
2 > 1 && 4 < 2
// false (false and true is false)
4 > 5 || 9 < 17
// true (false and true is true)
!(5 > 2)
// false (= not true)
!(2 > 5)
// true (= not false)

As we've done with examples before, let's see the step-by-step evaluation of one of the above expressions to make sure everything is crystal clear.

2 > 1 &&  4 < 2
=> true && 2 < 1
=> true && false
=> false

If you try to compare an integer (Int) and a string (String), Swift gives an error with the following message: Binary operator '>' cannot be applied to operands of type 'Int' and 'String'. That is, Swift tells us the two types can't be compared to each other.

Boolean

Incidentally, you just learned about a new type of object in Swift. It's called Boolean.

There are only two Boolean values:

• true
• false

But for Swift to understand this, you need to always write it as true - TRUE, and tRUE won't work – only true is correct. (The same applies to false as well, of course.)

Booleans can be variables, too! See here:

var a = true
a
// true
a = 2 > 5 
a 
// false

Practice and have fun with Booleans by trying to run the following commands:

• true && true
• false && true
• true || 1 == 1
• 1 != 2

Congrats! Booleans are one of the coolest features in programming, and you just learned how to use them!

Printing

To print a statement or a value in swift we use the print() function.

print("Swift is used for iOS apps")
// Outputs - Swift is used for iOS apps
var a = "Swift is awesome"
print(a)
// Outputs - Swift is awesome

You can print multiple things at the same time as well. To do this, you need to separate the items by comma ",":

print("Swift is used for iOS apps", a)
// Outputs - Swift is used for iOS apps Swift is awesome

Now, let's see something much more interesting. There's a special syntax to use a variable's value in middle of a String. Try this:

a = "awesome"
print("Swift is an \(a) programming language")
// Outputs - Swift is an awesome programming language
a = "amazing"
print("Swift is an \(a) programming language")
// Outputs - Swift is an amazing programming language

Every print statement will print the content on the next line. So, if you're using the Swift Playground, you will see \n at the end on the result bar. \n represents a newline character.

If … else if … else

Lots of things in code should be executed only when given conditions are met. That's why Swift has something called if statements. Try this:

if 3 > 2 {
    print("It works")
}

All the code you write inside the curly braces ({ }) will only be executed if the if-condition is true.

Also, notice the indentation. A single tab indents the code by 4 spaces. tab makes the program looks neat and most of the programmers follow this.

What if a condition isn't True?

In the previous example, code was executed only when the condition was true. But Swift also has else if and else statements:

if 5 > 2 {
    print("5 is indeed greater than 2")
} else {
    print("5 is not greater than 2")
}

When this is run it will print out:

5 is indeed greater than 2

If 2 were a greater number than 5, then the second command would be executed.

Let's see how else if works:

var name = "Dave"
if name == "Commonlounge" {
    print("Hey Commonlounge!")
} else if name == "Dave" {
    print("Hey Dave!")
} else {
    print("Hey anonymous!")
}

and executed:

Hey Dave!

See what happened there? else if lets you add extra conditions that run if the previous conditions fail.

You can add as many else if statements as you like after your initial if statement. For example:

var volume = 57
if volume < 20 {
    print("It's kinda quiet.")
} else if 20 <= volume && volume < 40 {
    print("It's nice for background music")
} else if 40 <= volume && volume < 60 {
    print("Perfect, I can hear all the details")
} else if 60 <= volume && volume < 80 {
    print("Nice for parties")
} else if 80 <= volume && volume < 100 {
    print("A bit loud!")
} else {
    print("My ears are hurting! :( ")
}

Swift runs through each test in sequence and prints:

Perfect, I can hear all the details

Note that in a chain if ... else if ... else statements, only the first condition that is met gets executed. As soon as the first condition is met, none of future else (or else if) conditions will be considered. Hence, the above code could be written more concisely as:

var volume = 57
if volume < 20 {
    print("It's kinda quiet.")
} else if volume < 40 {
    print("It's nice for background music")
} else if volume < 60 {
    print("Perfect, I can hear all the details")
} else if volume < 80 {
    print("Nice for parties")
} else if volume < 100 {
    print("A bit loud!")
} else {
    print("My ears are hurting! :( ")
}

We're making use of the fact that, when we compare volume < 60 (for example), all the previous conditions must have been false. That automatically implies volume >= 40 (since the first two conditions were false). The code might be slightly harder to read, but it is equivalent to the previous one.

Comments

Comments are lines beginning with //. You can write whatever you want after the // and Swift will ignore it. Comments can make your code easier for other people to understand. For multi-line comments we start with /* and end with */

Let's see how that looks:

// Change the volume if it's too loud or too quiet
if volume < 20 or volume > 80 {
    volume = 50
    print("That's better!")
}
/* This is how we give
multi-line comments, its useful when we want to 
comment entire block of code while testing */

You don't need to write a comment for every line of code, but they are useful for explaining why your code is doing something, or providing a summary when it's doing something complex.

Summary

In the last few exercises you learned about:

• comparing things – in Swift you can compare things by using >, >=, ==, <=, < and the and, or operators
• Boolean – a type of object that can only have one of two values: true or false
• if … else if … else – statements that allow you to execute code only when certain conditions are met.
• comments - lines that Swift won't run which let you document your code

Appendix: List of Comparison Operators

The following is a list of all comparison operations supported by Swift.

Operator | Example | Result | Description 
---------|---------|--------|--------------------------------
   ==    | 4 == 5  | false  | is equal to
   !=    | 4 != 5  | true   | is not equal to
   >     | 4 > 5   | false  | is greater than
   <     | 4 < 5   | true   | is less than 
   >=    | 4 >= 5  | false  | is greater than or equal to
   <=    | 4 <= 5  | true   | is less than or equal to

Appendix: List of Boolean Operators

The following is a list of all boolean operations supported by Python.

Operator | Examples        | Result | Description 
=========|=================|========|====================================
   &&    | 3 < 4 && 5 < 4  | false  | true if both values are true
         | 3 < 4 && 5 > 4  | true   | 
---------|-----------------|--------|------------------------------------
   ||    | 3 < 4 || 5 < 4  | true   | true if at-least one value is true
         | 3 > 4 || 5 < 4  | false  | 
---------|-----------------|--------|------------------------------------
   !     |    !false       | true   | inverts the value 
         |    !True        | false  | 

Appendix: List of all Basic Data Types

The following is a list of data types in Swift.

Data type  | Examples                          | Description 
===========|===================================|========================================
 Int       | 5, -1, 0, 127                     | integer
 Float     | 5.3, -1.7, 2.0, 2.33333333        | floating-point values (decimal values)
 Double    | 2.33333333333333                  | 15 digit precision
 String    | "a", "Commonlounge", "12", "v1.0" | string
 Bool      | true, false                       | boolean - true or false
 Character | "C", "o", "5", "."                | character
 Optional  | Optional(1.0), Optional(5)        | optional - value might be missing

Time for a quiz and then the last part of this section!