NaN.

Swift Arrays and Loops[ Edit ]

You have already learnt about arrays and loops in previous tutorials. In this tutorial, we're going to dive deeper into these two topics.

Review of arrays

Array's are written within square brackets [ ]. Use the .count attribute to get number of elements inside the array and square brackets [index] to access data of that specific index. Remember the first element is at index 0.

var colors = ["red", "blue", "green"]
print(colors[0])    // red
print(colors[2])    // green
print(colors.count) // 3

Assignment with an = on Array's makes a copy.

var b = colors   // copies the Array onto the new variable

The "empty array" is just an empty pair of brackets [ ]. The + works to append two arrays, so [1, 2] + [3, 4] yields [1, 2, 3, 4] (this is just like + with strings).

FOR and IN

Swift's for and in constructs are extremely useful, and you have already seen it's use with arrays. The for construct -- for element in array -- is an easy way to look at each element in an array (or other collections). Do not add or remove from the array during iteration.

var squares = [1, 4, 9, 16]
var total = 0
for num in squares {
    total += num
}
print(total)  // 30

If you know what sort of thing is in the array, use a variable name in the loop that captures that information such as num, or name, or url. Your variable names are a key way for you to keep straight what is going on, so always name them appropriate.

The for / in constructs are very commonly used in Swift code and work on data types other than Arrays, so you should just memorize their syntax. You may have habits from other languages where you start manually iterating over a collection, where in Swift you should just use for / in.

You can also use for / in to work on a string. The string acts like a arrays of its chars, so

// print all the chars in the string s.
for ch in s {
    print(ch)
}

Range

The ... function yields the numbers 0, 1, ... n and a...b returns a, a+1, ... b -- up to the last number. The combination of the for-loop and the ... function allow you to build a numeric for loop:

// print the numbers from 1 through 100
for i in 1...100 {
    print(i)
}

..< function yields the numbers 0, 1, ... n-1 and a..<b returns a, a+1, ... b-1 -- up to but not including the last number.

You can use range operator in Arrays also to get specific elements in the same manner

var a = [1,2,3,4,5,6,7,8,9]
print(a[1...3])  //[2, 3, 4]
print(a[4...7])  //[5, 6, 7, 8]

While Loop

In addition to the for loop, Swift has another loop known as the while loop. The while loop continually executes a block of statements while a particular condition is true. Its syntax is:

while (condition) {
     .. statements (loop body) ..
}

The initialization of the variables used in condition can be done anytime before the while loop, and the value of the variable can be updated anywhere inside the while loop.

Here's a while loop which prints the the odd numbers smaller than 10.

var x = 1 
while (x < 10) {
    print(x)
    x += 2
}

Output:

Let's see how above program works.

First, we give x an initial value of 1.
Then, the condition x < 10 is checked. Currently, the value of x is 1, hence the condition x < 10 is true and the loop body will get executed.
Then, in the loop value, we print the current value of x (print(x)), this prints 1. Then we add 2 to x (x += 2) which updates the current value of x to 3.
Since x < 10 is still true (since x is equal to 3), the value 3 gets printed, and then x is updated to 5.
This continues till x = 9. Finally, the value of x is updated to 11. Then the condition is checked which is no longer true, and the loop execution stops.

Note: If you don't update the value of the variable used in the condition statement, then the condition will always be true and you will have an infinite loop. That is, your program will keep running forever!

Break and continue

break and continue give us some more control over what code is executed inside a loop.

If a break is encountered, Swift immediate stops iterating over the loop (it also ignores all the code after the break within the block, if any). Here's an example:

var a = [1, 5, 3, 2, 4, 6, ]
for element in a {
    print(element)
    if element == 2 { // quit the loop when element == 2
        break
    }
    print(-element) // when element == 2, this line too won't execute
}

Here's the code output:

Note: 4 and 6 don't get printed at all. 2 gets printed, but -2 does not, since break happens before that.

If a continue is encountered, Swift ignores the code after the continue within the block, but "continues" iterating over the rest of the elements. Here's an example:

var a = [1, 5, 3, 2, 4, 6, ]
for element in a {
    print(element)
    if element <= 2 {
        continue       // don't execute the rest if element <= 2
    }   
    print(-element)    // when element <= 2, this line too won't execute
}

Here's the code output:

Note: All numbers get printed. However, for 1 and 2, the negative values don't get printed because of the continue.

Lastly, break and continue can be used inside while-loops as well.

Array Methods

Here are some other common array methods.

array.append(elem) -- adds a single element to the end of the array. Common error: does not return the new array, just modifies the original.
array.insert(elem,at: index) -- inserts the element at the given index, shifting elements to the right.
array.append(contentsOf: [elem]) adds the elements in array to the end of the array. Using + or += on an array is similar to using.append(contentsOf: [elem]).
array.remove(at: index) -- removes the element at the given index. Throws a fatal error if the index is out of range.
array.sort() -- sorts the array in place (does not return it).
array.reverse() -- reverses the array in place (does not return it)
array.popLast() -- removes and returns the last element.

Notice that these are methods on an array object.

var array = ["larry", "curly", "moe"]
array.append("shemp")                    // append elem at end
array.insert("xxx",at: 0)                // insert elem at index 0
array.append(contentsOf: ["yyy","zzz"])  // add array of elems at end
print(array)    // ["xxx", "larry", "curly", "moe", "shemp", "yyy", "zzz"]
print(array.index(of: "larry")!)         // "1"
array.remove(at: 3)                      // remove that element
array.popLast()                          // removes and returns "zzz"
print(array)    // ["xxx", "larly", "curly", "shemp", "yyy"]

Common error: note that the above methods do not return the modified array, they just modify the original array.

var array = [1, 2, 3]
print(array.append(4))  // NO, does not work, append() returns None
// Correct pattern:
array = [1, 2, 3]
array.append(4)
print(array)            // [1, 2, 3, 4]

Array Build Up

One common pattern is to start an array as the empty array [], then use append() to add elements to it:

var array: [String] = []  // Start as an empty array
array.append("a")         // Use append() to add elements
array.append("b")

Summary

In the last few exercises you learned about:

for-loops - let you iterate over elements in an Array
for-loops with a...b - lets you create a numeric loop
while-loops - loops that keep repeating while a condition is true
break and continue – break can be used to exit the loop, and continue can be used to skip some parts of the loop body

Exciting stuff! Let's do some coding exercises using what you just learnt!

Category: Computer Programming

Comment