Ex 1:
for (int i = 0; i < 100; i++)
{
// Whatever meaningful thing needs to be done 100 times
}
Ex 2a - exclusive end index (does not include 100):
for i in 0 ..< 100
{
print(i);
}
Ex 2b - inclusive end index (includes 100):
for i in 0 ... 100
{
print(i);
}
That about does it for our trivial example. Almost every real-world usage is more complex than this so I wanted to delve into those scenarios for the sake of other developers (and myself once I have forgotten). First off, there is the incrementer expression ('i++' in Example 1). In Java, I often write an incrementer other than i++:
Ex 3:
for (int i = 0; i < 100; i += 2)
{
// Whatever meaningful thing needs to be done 50 times
}
There is a straightforward answer for this: The where clause:
Ex 4a - exlcusive end index:
for i in 0 ..< 100 where i % 2 == 0
{
print(i);
}
Ex 4b - inclusive end index:
for i in 0 ... 100 where i % 2 == 0
{
print(i);
}
The downside of the where clause is that the runtime still counts all the values that don't match the where clause. I.E., in the loop in Ex 4 the runtime follows this process:
0: Initialize i to 0.
1: Evaluate where clause. If False skip to step 3:
2: print i (Loop body)
3: Increment i by 1.
4: Is i < 100? If so go to 1:
So, if your loop skips a lot of steps, or in other words uses a large increment, then this would waste a lot of cycles. But, take heart, there is an answer for this as well: stride.
Ex 6a - exclusive end index:
for i in stride(from: 0, to: 100, by: 2)
{
print(i);
}
Ex 6b - inclusive end index:
for i in stride(from: 0, through: 100, by: 2)
{
print(i);
}
The stride function actually returns a struct that serves as an iterator, so there is likely no allocation of memory since this can easily be accomplished in 1 variable. However, what about the case where you need to access not only the current value of the loop, but also the index within the loop itself? E.G., the loop in Ex 6a might have an i value of 2, but the loop index is 1. This is accomplished using the enumerated function:
Ex 7:
for (index, j) in stride(from: 0, to: 100, by: 2).enumerated()
{
print("\(index): \(j)");
}
The enumerated function returns an iterable set of tuples, and according to the names you provide will contain the loop index as the first variable name and the array value in the second name. In other words, the declaration in Ex 7 might as well be (Laurel, Hardy) as (index, j). In that case, Laurel would be my index and Hardy would contain the value. The order matters, not the labels.
In order to use enumerated, you have to be working with an object of some sort, either a Strideable as in Ex 7, or else some other appropriate type such as an array, as in Ex 8, but it can't be a plain numeric range:
Ex 8:
let arr: [Int] = [0, 2, 4, 6, 8];
for (index, j) in arr.enumerated()
{
print("\(index): \(j)");
}
Reverse loops are something I have really not ever had much need of (reverse counting loops). For reverse counting, I usually use an upward counting loop with a calculation for the downward counting value. Nonetheless, these can be accomplished in many of the same ways except that it always requires a more complex interaction over the traditional loop:
Ex 9 - simple reverse iteration:
for i in (0 ..< 100).reversed()
{
print(i);
}
Ex 10 - simple reverse iteration with where:
for i in (0 ..< 100).reversed() where i % 2 == 0
{
print(i);
}
Ex 11 - simple reverse iteration with index:
for (index, i) in (0 ..< 100).reversed().enumerated()
{
print(i);
}
Ex 12 - reverse iteration with stride:
for i in stride(from: 0, to: 100, by: 1).reversed()
{
print(i);
}
Ex 13 - reverse iteration with stride and index:
for (index, i) in stride(from: 0, to: 100, by: 1).reversed().enumerated()
{
print(i);
}
Ex 14 - reverse iteration with stride and a negative increment. May not be 'proper', but it works:
for i in stride(from: 100, to: 0, by: -1)
{
print(i);
}
"Wait", you say, "What about the case where I have to loop with . . . <blah> <blah> <blah> <some special circumstance>???!?" There is always some special circumstance which can't be accounted for in the language itself without making everything too complicated. The fallback answer is the trusty while loop:
Ex 15 - loop starting with my Aunts' age, skip 17039 days until you reach my julian birth date
let julianBirthday = 2440131;
let myAuntsAge = 31;
let unusualInterval = 17039;
var loopIndex = 0;
var counter = myAuntsAge;
while(counter < julianBirthday)
{
print("\(loopIndex): \(counter)");
counter += unusualInterval;
loopIndex += 1;
}
Ex 15, besides being completely useless, demonstrates that the basic while loop is much more tedious to build but contains enough to handle just about any situation. It is also not a very good example, because it can be written using the simplified versions:
Ex 16 - our loop was really not that special:
for (loopIndex, counter) in stride(from: myAuntsAge, to: julianBirthday, by: unusualInterval).enumerated()
{
print("\(loopIndex): \(counter)");
}
