How to Iterate a Loop with Index and Element in Swift

This article will show how you can Iterate a Loop with Index and Element in Swift.

Swift provides multiple ways to iterate over a collection while accessing both the index and the element in each iteration. In this tutorial, we’ll explore two commonly used methods: indices and enumerated().

Using indices Property

The indices property is an instance property of the Collection protocol in Swift. It returns the range of valid indices for the collection, allowing you to iterate over them and access both the index and the corresponding element.

Using forEach loop

You can use the forEach method to iterate over the indices of an array and print each element along with its index.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Using forEach
list.indices.forEach { index in
    print("Item \(index): \(list[index])")
}

Explanation:

• list.indices provides a range of indices for the elements in the array.
• The forEach method is applied to these indices, and for each index, the closure is executed.
• Within the closure, you print the index and the corresponding element using list[index].

Output:

Item 0: Car
Item 1: Bike
Item 2: Plane
Item 3: Boat

Using for-in loop

You can also iterate over the indices and elements of an array in Swift, using a for-in loop with the indices property.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Using a for-in loop
for index in list.indices {
    print("Item \(index): \(list[index])")
}

Explanation:

• list.indices provides a range of indices for the elements in the array.
• The for-in loop iterates over these indices, and for each index, you print the index and the corresponding element using list[index].

Output:

Item 0: Car
Item 1: Bike
Item 2: Plane
Item 3: Boat

Using enumerated() Method

The enumerated() method returns a sequence of pairs, where the first element is the index, and the second element is the value. This method simplifies the process of iterating over a collection while obtaining both the index and the element.

Using forEach loop with enumerated()

You can use the enumerated() method with forEach to iterate over both the indices and elements of an array in Swift.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Using forEach with enumerated()
list.enumerated().forEach { (index, element) in
    print("Item \(index): \(element)")
}

Explanation:

• enumerated() is used to iterate over each element in the array along with its index.
• The forEach method is applied to the enumerated sequence, and for each tuple (index, element), the closure is executed.
• Within the closure, you print the index and the corresponding element.

Output:

Item 0: Car
Item 1: Bike
Item 2: Plane
Item 3: Boat

Using a for-in loop with enumerated()

You can also use the enumerated() method in the for-in loop to iterate over the array, providing both the index and the corresponding element in each iteration.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Using a for-in loop with enumerated()
for (index, element) in list.enumerated() {
    print("Item \(index): \(element)")
}

Explanation:

• enumerated() is used within the for-in loop to iterate over each element in the array along with its index.
• The loop variable (index, element) represents each tuple generated by enumerated().
• Within the loop, you print the index and the corresponding element.

Output:

Item 0: Car
Item 1: Bike
Item 2: Plane
Item 3: Boat

Note: The enumerated() method returns a counter for the enumeration but is not necessarily the index of the paired value.

Some alternative methods

Besides indices and enumerated(), Swift offers alternative methods to iterate over a collection with both the index and element. Here are a few alternatives:

Using zip with indices

The zip function combines two sequences into a single sequence of pairs. Combining it with indices allows you to iterate over both the index and element.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Using zip to iterate over the indices and elements of the array simultaneously
for (index, element) in zip(list.indices, list) {
    print("Item \(index): \(element)")
}

Explanation:

• list.indices provides a sequence of indices for the elements in the array.
• The zip function combines the indices and elements, creating pairs of (index, element).
• The for loop iterates over these pairs, and within the loop, you print the index and element.

Output:

Item 0: Car
Item 1: Bike
Item 2: Plane
Item 3: Boat

Using enumerated() with Map

You can use enumerated() with the map function to create an array of tuples containing the index and element pairs.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Using the enumerated() method to get the index and element of each item in the array
let arrayOfTuples = list.enumerated().map { (index, element) in
    return (index, element)
}

// Printing the array of tuples
print(arrayOfTuples)

Explanation:

• enumerated() is used to iterate over each element in the array along with its index.
• The closure inside the map function takes the index and element of each item and returns a tuple (index, element).
• The resulting array of tuples is stored in the variable arrayOfTuples.
• Finally, the array of tuples is printed.

Output:

[(0, "Car"), (1, "Bike"), (2, "Plane"), (3, "Boat")]

Using enumerated() with reduce

reduce can accumulate values while iterating, making it a suitable alternative.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Use enumerated() to get index-element pairs, then use reduce(into:) to transform into a dictionary
let result = list.enumerated().reduce(into: [:]) { (dict, tuple) in
    dict[tuple.offset] = tuple.element
}

// Sort the dictionary by keys
let sortedResult = result.sorted { $0.key < $1.key }

// Print the elements in order
for (index, element) in sortedResult {
    print("Item \(index): \(element)")
}

Explanation:

• enumerated() is used to create pairs of index and element from the array.
• reduce(into:) is employed to transform the enumerated pairs into a dictionary where the index is the key and the element is the value.
• sorted is used to sort the dictionary based on keys.
• Finally, a for loop is used to iterate through the sorted dictionary and print the index and corresponding element.

Output:

Item 0: Car
Item 1: Bike
Item 2: Plane
Item 3: Boat

Using a Custom Iterator

Create a custom iterator by conforming to the IteratorProtocol and Sequence protocols, providing manual control over the iteration.

Example

let list = ["Car", "Bike", "Plane", "Boat"]

// Define a custom iterator that conforms to IteratorProtocol and Sequence
struct IndexElementIterator<T>: IteratorProtocol, Sequence {
    var index = 0
    let elements: [T]

    // Implement the next() method required by IteratorProtocol
    mutating func next() -> (Int, T)? {
        guard index < elements.count else { return nil }
        defer { index += 1 }
        return (index, elements[index])
    }
}

// Use the custom iterator in a for-in loop
for (index, element) in IndexElementIterator(index: 0, elements: list) {
    print("Item \(index): \(element)")
}

Explanation:

• IndexElementIterator is a generic struct that conforms to both IteratorProtocol and Sequence. This allows it to be used in a for-in loop directly.
• The next() method is implemented to provide the next index-element pair in the iteration. It returns a tuple of type (Int, T)?, where Int is the index, and T is the type of the elements in the array.
• The defer statement ensures that the index is incremented after the value is returned, guaranteeing that the index is always updated correctly.
• The for-in loop then utilizes this custom iterator, providing a clean and readable way to iterate over the array with both index and element.

Output:

Item 0: Car
Item 1: Bike
Item 2: Plane
Item 3: Boat

These alternatives provide flexibility based on specific use cases and preferences. Choose the method that best suits the requirements of your Swift application.