Learning Swift Programming (2015)

---

You can also use += to easily concatenate two arrays:

raining += ["dogs","pigs","wolves"] // ["cats","dogs","pigs","wolves"]

When you append to an array, you are adding an element to the end of an array. The element you append will always become the last element.

If you want to add an element at the beginning of the array, you can use insert. Maybe it’s raining dogs and cats instead of cats and dogs:

var raining = ["cats"]
raining.insert("dogs",atIndex: 0)
raining // ["dogs","cats"]

Removing Elements from Arrays

If you want to remove items from an array, you can use a number of methods in Swift. For example, you can remove the last item with removeLast():

raining.removeLast()

And you can remove an element at a specific index by using removeAtIndex(:atIndex):

var raining = ["cats","octopuses"] // cats, octopuses
raining.insert("dogs", atIndex: 1)
raining // cats, dogs, octopuses
raining.removeAtIndex(1) // returns the element it removed "dogs"
raining // cats, octopuses

Here’s what’s going on here:

1. You start with an array of two elements.

2. You insert an element at index 1.

3. Then you just remove the same item you added at index 1.

When removing elements from an array it is important to remember that it works like a deck of cards. If you remove the third card from a deck, the fourth card becomes the third card and so on with every card below the fourth card. The second card does stay in the second position.

You can also do the following:

■ Create arrays with any type

■ Create arrays of mixed types

■ Add and remove items at the end of the array

Iterating Over Arrays

When you iterate over an array, you start at the beginning of the array and access each element of the array until you get to the end. Oftentimes you are looking for an element that meets a certain condition. Sometimes you will successfully find that element, and you will not need to iterate any further, so you will break the loop. The for-in loop is well suited for interating over arrays. Here’s what it looks like:

for animal in raining {
println(animal)
}
// cats
// octopuses

Sometimes you need to access the current index for tracking purposes. For this purpose, Swift provides a global enumerate function, which gives you access to the current index and current element. Here’s how it works:

for (i,animal) in enumerate(raining) {
println("Animal number \(i) is the \(animal)")
}
// Animal number 0 is the cats
// Animal number 1 is the octopuses

Extra Bits of Arrays

You can create arrays that are empty or with prepopulated contents. You can create and prepopulate an array by using the extra parameters extra: and repeatedValue:. Here’s an example:

var mapRow1 = [Int](count:10,repeatedValue:0) // [0,0,0,0,0,0,0,0,0,0,0]

Here we created a map for a game. If you were using this map for a game, you could place arrays within arrays to create a multidimensional array. You can use one array for each row and place that in one big array, like this:

var mapRow1 = [Int](count:10,repeatedValue:0)
var cols = 10
var rows = 10
var map = [[Int]]()
for row in 0..<rows {
var newRow = [Int](count:cols, repeatedValue:0)
map.append(newRow)
}
map

In this example, you create an array within an array. So the type of map is [[Int]], which means an array of arrays of Ints. Because [Int] is an array of Ints, wrapping that in square brackets will give you an array of Ints. This type of multidimensional array can be used in games to create a sort of tile map. Maybe for this map 0 is ground, 1 is road, and 2 is tree. The preceding example makes a whole map of ground. Notice that it does so without making a nested for loop.

Emptying an Array

You can completely empty an array by setting it equal to []: This technique is used in other languages.

map = []
map // 0 Elements

Using Dictionaries

Dictionaries are similar to arrays in that they are both containers that store multiple values of the same type. Dictionaries are different from arrays in that each value is stored with a key. You use that key to access the value. In arrays, you access elements by index. Arrays are stored in a specific order, and dictionaries are not. Just like arrays, though, dictionaries want to know what type you will be storing for their values. They also want to know what type you will use for its keys. You can write a dictionary in verbose form or shorthand. First the verbose:

var people:Dictionary<Int,String> = [186574663:"John Smith",
198364775:"Francis Green",
176354888:"Trevor Kalan"]
people[176354888] // {Some "Trevor Kalan"}

This dictionary is of type [Int : String]. Again, you can three-finger-click or tap the variable name to find the type of the dictionary. The keys are of type Int, and the values are of type String. There are a couple things to note here. For one thing, you can access the dictionary by using the same syntax that you use to access arrays. Note that by accessing the dictionary, Swift returns an optional (see Chapter 1). Why does Swift return an optional? It is possible that you are trying to access something that is not there. If you were sure that there is a value at the key you were accessing, you could force the value out with an exclamation point, like this:

people[176354888]! // "Trevor Kaleface"

Of course, there is a shorthand way to write dictionaries since Swift can automatically infer the types of dictionaries. You can rewrite a dictionary without an explicit type, like this:

var people = [186574663:"John Smith",
198364775:"Francis Green",
176354888:"Trevor Kaleface"]

It’s still the same dictionary as before.

Adding, Removing, and Inserting with Dictionaries

Previously you used the subscript syntax (the square brackets syntax) to access elements of a dictionary. You can use that syntax to also set values by key. In the previous example, you can set a person with a Social Security number of 384958338:

people[384958338] = "Skip Wilson"

If the key exists, then you will replace that Social Security value with Skip Wilson. If not, you will have a new key/value pair. Try to assign a key using a string, and you get an error.

You can also use the method updateValue(forKey:) to update your dictionary. This method also updates a value for a key if it exists, or it creates a new key value if it does not exist. updateValue returns an optional, which is the old value it replaced, or nil if it did not replace anything.

To remove items from a dictionary, you can just assign it to nil:

people[384958338] = nil

Now the person with Social Security number 384958338 is removed from the dictionary. You can also use removeValueForKey to do the same thing. It returns the old value it removed if the key exists. If not, it returns nil. It is otherwise known as an optional, and it looks like this:

people.removeValueForKey(176354888) // {Some "3343"}
people.removeValueForKey(24601) // nil

Iterating Over Dictionaries

You can iterate over a dictionary much the same way that you iterate over an array—by using a for-in loop. The only difference between an array for-in loop and a dictionary for-in loop is that with the dictionary loop, you are able to get both keys and values while looping, like this:

for (ssn,name) in people {
println("SSN: \(ssn) Name: \(name)")
}
// SSN: 198364775 Name: Francis Green
// SSN: 176354888 Name: Trevor Kalan
// SSN: 186574663 Name: John Smith

You can also loop through just the keys of a dictionary, with .keys. In addition, you can loop though just the values with .values:

for ssn in people.keys {
println("SSN: \(ssn)")
}
for name in people.values {
println("Name: \(name)")
}

Extra Bits of Dictionaries

You can create a new dictionary like this:

var vehicles = Dictionary<String,String>()

It is worth noting that once again, if you Command+click on the dictionary, you will see that it is made up of a Struct and subscripts. The <> characters tell you that the dictionary is made with generics, and it will accept any typeat all for its keys and values. (Generics are a powerful feature of Swift. and you will learn much more about them in Chapter 9, “Becoming Flexible with Generics.”)

If you want to count the number of key/value pairs in a dictionary, you can use .count:

people.count // 3

Emptying a Dictionary

You can empty a dictionary just by calling [:], like this:

people = [:] // 0 key/value pairs

Testing Dictionaries for the Presence of Values

Dictionaries return optionals when you try to access items. Therefore, you might want to place them into value bindings. If you don’t need the value of the key you are testing, you can instead use a regular if statement, like this:

if people[198364775] {
println("Got him")
} else {
println("No one with that Social Security number")
}

If you do in fact want the unwrapped value from the optional (if it does succeed), you can use full value binding, like this:

if let person = people[198364775] {
println("Got \(person)")
} else {
println("No one with that social security number")
}

Now you will have the unwrapped value of the optional available to you if there is a value to be had.

Putting It All Together

Next, you will create a little program from all the massive amounts of knowledge you have acquired thus far. Enter the code in Listing 2.1.

Listing 2.1 A Complete Example