So as it would seem, creating and manipulating data is pretty important. Let's take a look at some of the most common built-in data types in Swift by defining some constants:

let integer: Int            = 0
let floatingPoint: Float    = 0.0
let string: String          = "Hello"
let boolean: Bool           = true

Starting from the top, we have an integer (Int), then a floating point number (Float), then a string (String), and finally a Boolean value (Bool). You'll notice all of the built-in types are capitalized, which may be a little strange if you're coming from Objective-C.

While we're here, let's take a look at how a constant is defined in Swift:

let constantName: DataType = {Value}

First, we use the let keyword to signify that we are defining a constant. The next part is our constant's name, which we will use to reference it, followed by a colon. After the colon we define the data type of our constant, and finally we set it equal to its default value. Go to your playground and try to define some of your own constants using the data types we just looked at. (This example won't work: DataType is not a real data type! Replace that with a real data type, such as Int or String).

Since Swift has a strong focus on speed and safety, the use of unchanging constant values is encouraged as frequently as possible. However, we know that won't always be possible, and in cases where a value needs to change we use a variable. Defining a variable is exactly the same as defining a constant, but instead of using let, we use var:

var variableName: DataType = {Value}

Now we can manipulate and rewrite the value of this variable as much as we need!

One of the most important features of the Swift programming language is that it is type safe. This means that all of the constants and variables you define must have a type, or else the code won't even compile. In these past few examples, we've defined our variables and constants with explicit types, meaning we wrote the type right next to them to make sure the compiler knows about it. But the Swift compiler is very smart and can also figure out a type by its context, therefore giving it an implicit type. Here's an example:

var value1: Int = 0
var value2 = 0

On value1, we explicitly state that the variable is of the type Int. On value2, we just set an un typed value to 0, but the compiler knows that 0 is an integer and deduces that value2 must be an Int. This is called type inference. This will usually make more sense when instantiating objects later on, since it's more readable:

var myView = UIView()

Here, it's very clear that myView will be of the type of the UIView class (we'll get to classes soon enough):

var value1, value2, value3: String

You can also declare several variables on one line, and even use emojis as a variable name! (Although, it's really only useful as a novelty; I don't recommend using emojis in real-world code.)

An array in Swift is a simple ordered collection of values of a certain type. If you want your array to be immutable, meaning you can't add/remove/change values, then you define it with a let keywords. To make it mutable (changeable), define it with var:

let immutableArray: [Int] = [1, 2, 3]
var mutableArray: [Int] = [Int]()

In this example, you can see that the immutable array is initialized with default values of 1, 2, and 3, and that it is of the type [Int]. The square brackets around a data type let the compiler know that it is an array, and not just a single value. Beneath that, we did something similar, but instead of giving the mutableArray starting values, we just initialized a new empty array of integers to use later. Using what we learned about type inference in the last section, we could also let the compiler figure out the types and shorten these declarations to the following:

let immutableArray = [1, 2, 3]
var mutableArray = [Int]()

Let's take a look at some of the basic functionality of a Swift array. Adding an element to the end of an array looks like this:

mutableArray.append(1)
mutableArray.append(2)
mutableArray.append(3)

The contents of the array would now look like this: [1, 2, and 3], and if you're typing this into a playground, you should be able to see that in the results sidebar. To remove the last element, you can use dot-syntax to call a function on the array:

mutableArray.removeLast()

You can also use dot-syntax to access the properties of the array, such as count the number of elements the array contains:

mutableArray.count

Or you can even access a Bool value to let you know whether the array is empty or not:

mutableArray.isEmpty

You can access elements in an array by using subscript syntax, where you put the index of the element you are looking for in square brackets after the array variable, like this:

mutableArray[0]

There is plenty more to learn about the Swift arrays, but this should be enough to get us started. Feel free to experiment and look through Apple's documentation.

A dictionary is a collection where every value has a key that can be used to retrieve it. So as an example, if I put the number 05401 in a dictionary with the key zipCode, then later I would ask for zipCode and it would return 05401:

Figure 3.10: Dictionaries use keys which have an associated value

This has many use cases when developing software, and usually has the benefit of being easily human-readable. Let's take a look at how to create a dictionary:

var myDict = [String: Int]()

Here, we created an empty dictionary called myDict, where it uses a String as its key, and stores an Int value. Again, the two parentheses show that we are creating a new object here. To add a value for a key, or to access the value at a key, you can use subscript notation like with an array, but instead of an index you use the key:

myDict["example"] = 12345
let test = myDict["example"]

In the first line, we are creating a new entry in the dictionary with a key of example and assigning its value as 12345. In the second line, we retrieve the value stored at the key example and assign it to our test variable. The test variable will now store the value 12345. Again, there is a lot more to know about the Swift dictionary, but this should be enough to get you started.

Starting with conditional statements, let's look at how Swift handles a standard if statement:

let condition = true

if condition {
    // condition was true
} else if !condition {
    // condition was false
} else {
    // this would honestly never happen
}

At the top, we just declare a simple Boolean called condition and set it to true. Remember, Swift is using type inference to determine that the condition is a Boolean value. The first line of the statement uses the if keyword, followed by the condition, and finishes with a set of curly braces to wrap the branch.

The things to note about Swift's implementation is that parentheses around the condition are not required, but the curly braces always are. In some languages, they are unnecessary for single-line code branches, but in Swift they are mandatory.

Underneath the first if statement is an else if statement. Like other languages, if an if statement's condition is not met, it will fall through to any number of else if statements before terminating at an else statement. So for example, if our condition Boolean was set to false, the first if would fail and the else if condition would pass (Swift uses the exclamation mark to invert a conditional expression/Boolean, like many other languages). Since a Boolean can only be true or false, our final else statement would never realistically be hit, and is only there to show you what it looks like.

Similar to the if is the guard statement. The primary difference is that if a guard statement's condition is true, code continues after the braces, instead of inside. The primary use case for a guard is to exit code early. In this way, the guard statement is a way of saying make sure these conditions are true before we continue:

let age = 25

guard age > 0 else {
    // invalid age!
    return
}

In this example, we have an age variable. Then we use guard to ensure that the age is greater than 0, since that would be invalid. If the condition fails, then the code block inside the else is executed. There must always be an else statement for a guard.

You can also use guard to unwrap optionals:

guard let myInt = optionalInt, myString = optionalString else {
    return
}

Sometimes this makes more sense than using if let and only using those unwrapped optionals inside the scope of if let.

In addition to the if/guard conditionals, we also have the switch statement. The switch takes a value, matches it against cases until it finds a match, and then executes the code block pertaining to that case:

let value = 1

switch value {
case 0:
    print("value was 0")
case 1:
    print("value was 1")
case 2:
    print("value was 2")
case 3, 4, 5:
    print("value was between 3 and 5")
default:
    print("value was some number")
}

In this example, the value that the switch statement is considering is an integer, 1. It then checks against each case until it finds one that matches. You'll notice one case has multiple matching conditions, separated by commas. If no matches are found, the default case will be executed.

Unlike some other languages, there is no implicit fall-through with cases in a Swift switch statement. That means that you don't need to use break to end a case. In addition, a switch case must be exhaustive, meaning that every possible value is represented. If there are too many values for that to make sense, a default case must be specified at the end.

In Swift 3, the old C-style for loop has been deprecated. Now, our only option is to use the for loop, which is a very powerful alternative. This is how we can use a for-in loop to run a piece of code 5 times:

for var i = 0; i < 5; i++ {
    // loop code
}

Like most implementations, you have the first expression that runs before the loop starts, the second expression which is the condition for the loop to run, and the third expression that runs on the completion of the loop.

However, in Swift the for-in loop is a very powerful alternative. Here is that same loop above, but using the for-in method:

for i in 0..<5 {
    // loop code
}

This is much easier to read, since you can see that you are incrementing through a range from 0 to 5, not inclusive (0…5 would be inclusive). Using for-in with collections is even easier:

var sum = 0
var values = [0, 1, 2, 3, 4, 5]
for value in values {
    sum += value
}

Here we declare a small array of integers for testing purposes, named values. Then, in the for-in, we ask it to loop through every element in the values array, and give us access to those elements through the name value. Then we add them to our sum variable. This makes for-in much simpler to use, and much easier to read than a standard for.

The while loop is a very basic loop. At the top is a condition that evaluates to true or false, and the loop will run forever until the condition is no longer true. We used one earlier in the chapter, but let's take another look:

var time: Float = 0
var position: Float = 0

while time < 1.0 {
    position = time*time
    time += 0.05
}

Here, our condition is that the loop will continue until the time is over one second. When working with while loops, it's important to make sure that the condition can be changed from inside the loop. If, for example, we were not increasing the time variable, the condition would never be false, and the loop would run forever and crash our program.

Finally, we have the repeat-while, which is the same as the while loop, except that it runs through its code before it checks the condition:

var x = 0

repeat {
    x += 1
} while x < 0

In this example, the condition is always false, but since it is a repeat-while, the code in the loop will run a full cycle before it checks the condition and exits the loop.