Using forEach, forEnumerated, forIn within Swift

Swift provides us with multiple ways to loop through items in a collection, they are:

for pokemon in pokemons {
   print(pokemon)
}

pokemons.forEach { (pokemon) in
   print("Pokemon", pokemon)
}

for (index, element) in pokemons.enumerated() {
   print("Number:", index, "Pokemon:", element)
}

Using for in

many programming languages the for in loo is called for-each. Standard loop statement in other languages uses this format:

for (i = 0; i < n; i++) {
   ///some fancy collecion to loop thur
}

Please note: Swift 3 no longer supports c-style for-loops

Now when using swift this approach is a little different, the rationale of this for-in syntax is it can be used to loop over ranges, iterators, strings, sequences, and collections with the same syntax.

let pokemons = ["Pikachu", "Charmander", "Squirtle", "Bulbasaur"]

for i in 0...< pokemons.count {
   print("Pokemon \(i+1):" pokemons[i])
}

//output:
Pokemon 1: Pikachu
Pokemon 2: Charmander
Pokemon 3: Squirtle
Pokemon 4: Bulbasaur

Within Swift the use of object types like arrays, dictionaries, and sets are known as collection. Any collection can be iterated with a for-in loop. For example with dictionary:

let pokedex = ["Electric":"Pikachu","Water":"Squirtle","Fire":"Charmander","Grass":"Bulbasaur"]

for (type, pokemon) in pokedex {
   print("The \(type)'s Pokemon is \(pokemon))
}

//output
The Electric's Pokemon is Pikachu
The Water's Pokemon is Squirtle
The Fire's Pokemon is Charmander
The Grass's Pokemon is Bulbasaur

In addition, Swift also  provided two range operators lowerBound...upperBound as a shortcut for expressing a range of values.

Take note: lowebound is greater than upperBound the code will crash

for i in 0...5 {
   print(i)
}
//output
0
1
2
3
4
5

for i in 0..<5 {
   print(i)
}

//output
0
1
2
3
4

If interested in reversing the range while looping, we can easily achieve that using  reversed

for i in (0...5).reversed() {
   print(i)
}

//output
5
4
3
2
1
0

Stride

As I referenced before, C-Style for loops are no longer supported within Swift 3, so you’re probably asking how to acquire the ‘increment of the counter’ (i++). We accomplished this by using stride, and this helps us to move from one value to another using any incremental value, we can also specify whether the upperBound is inclusive or exclusive.

for i in stride(from 0, to: 10, by: 2) {
   print(i)
}

//output
0
2
4
6
8

Using for each

pokemons.forEach {
   print("Pokemon", pokemon)
}

//output
Pokemon Mewtwo
Pokemon Snorlax
Pokemon Eevee

Swift provides a dedicated method forEach for specific, unlike the above forIn this method can’t break the loop partway (at some point). It has to loop over each item in the sequence. It has to loop over each item in the sequence. This helps people reading your code to figure out your intent: that you want to act on all items, and won’t stop in the middle.

Please note: break stops execution in a loop immediately and continues directly after the loop.

continue only exits the current iteration of the loop — it will jump back to the top of the loop and resumes up from there for next iteration

var oddNumbers = [Int]()

for numbers in (0...100) {
   guard oddNumbers.count < 15 else {
      break
   }

   guard numbers % 3 == 0 else {
      continue
   }
   
   oddNumbers.append(numbers)

   print(oddNumbers)
}

the same cannot be achieved in forEach with break and continue, so we need something like:

let oddNumbers = (0...100).filter {numbers -> Bool in
   return numbers % 3 == 0
}.prefix(10)

print(oddNumbers)

Using for enumerated

This Swift loop iterates to each of the items by also telling the index of it. In case if we need to iterate the elements and need their index also, then forEnumerated is the perfect loop for us.

Nested for loops:

var pokedex = ["001", "002", "003"]
var pokemons = ["Bulbasaur", "Ivysaur", "Venusaur"]

for i in 0..< pokedex.count {
   var string = "\(pokedex[i]) is "

   for _ in 1...3 {
      string += "\(pokemons[i])"
   }

   print(string)
}

//output
001 is Bulbasaur
002 is Ivysaur
003 is Venusaur

While:

// a while loop performs a set of statements until a condition becomes false
while condition {
   //statements
}

var index = 0 
while index < pokemons.count {
   print(pokemon[index])
   index += 1
}

//output
Bulbasaur
Ivysaur
Venusaur

Repeat:

//repeat while loop is similar to do while loops in other languages

repeat {
   statements
} while condition

var index = 0
repeat {
   print (pokemons[index])
   index += 1
} while index < pokemons.count 

//output
Bulbasaur
Ivysaur
Venusaur

It is similar to the above while loop but the major difference is that this loop evaluates the condition after running the statements. Either way, both while and repeat are best used in the loops where the numbers of steps are unknown.