For-Loops and Range

Add to favorites

For-Loops and Ranges: Learn how to repeat code efficiently and work with sequences of numbers in Swift

1. Introduction to Loops in Swift

Loops are fundamental programming constructs that allow you to execute a block of code repeatedly. Instead of writing the same code multiple times, loops help you automate repetitive tasks, making your code more concise and maintainable.

A. Why Loops Matter

i. Efficiency: Loops eliminate the need to write repetitive code, reducing the chances of errors and making your codebase more manageable.

ii. Data processing: Loops are essential for processing collections of data, such as arrays, dictionaries, or any sequence of elements.

iii. Dynamic operations: Loops enable your app to perform operations whose repetition count is determined at runtime.

B. Types of Loops in Swift

Swift offers several types of loops, each designed for specific scenarios:

i. For-in loops: Ideal for iterating through a sequence (like an array, range, or string).

ii. While loops: Used when you need to repeat code until a condition becomes false.

iii. Repeat-while loops: Similar to while loops but guarantees at least one execution of the code block.

In this guide, we'll focus on for-in loops (commonly called for-loops) and how they work with ranges.

2. For-Loops Basics

The for-loop is the most commonly used loop in Swift, especially when working with collections or when you know exactly how many times you need to repeat an operation.

A. Syntax and Structure

The basic syntax of a for-loop in Swift is:

for item in collection {
    // Code to execute for each item
}

Where:

item is a constant that represents the current element in each iteration
collection is what you're iterating through (array, range, or any other sequence)

B. Iterating Through Ranges

One of the most common uses of for-loops is to iterate through a range of numbers:

for number in 1...5 {
    print(number)
}
// Prints: 1, 2, 3, 4, 5

C. Common Use Cases

i. Processing array elements:

let fruits = ["Apple", "Banana", "Orange"]
for fruit in fruits {
    print("I like \(fruit)s")
}

ii. Repeating an action a specific number of times:

for _ in 1...3 {
    print("Hello!")
}
// Prints "Hello!" three times

iii. Iterating with index and value using enumerated():

let colors = ["Red", "Green", "Blue"]
for (index, color) in colors.enumerated() {
    print("\(index): \(color)")
}
// Prints: 0: Red, 1: Green, 2: Blue

3. Understanding Ranges

Ranges in Swift are a powerful way to represent a sequence of values. They're particularly useful with for-loops for iterating through a series of numbers.

A. Closed Range Operator (...)

The closed range operator creates a range that includes both the lower and upper bounds:

for num in 1...5 {
    print(num)
}
// Prints: 1, 2, 3, 4, 5

B. Half-Open Range Operator (..<)

The half-open range operator includes the lower bound but excludes the upper bound:

for num in 1..<5 {
    print(num)
}
// Prints: 1, 2, 3, 4

This is particularly useful when working with arrays, as their indices start at 0 and go up to (but not including) the count:

let array = ["A", "B", "C", "D"]
for i in 0..<array.count {
    print("Index \(i): \(array[i])")
}

C. One-Sided Ranges

Swift also supports one-sided ranges, where you specify only one bound:

i. Lower bound only:

let numbers = [10, 20, 30, 40, 50]
for num in numbers[2...] {
    print(num)
}
// Prints: 30, 40, 50

ii. Upper bound only:

let numbers = [10, 20, 30, 40, 50]
for num in numbers[..<3] {
    print(num)
}
// Prints: 10, 20, 30

D. Stride Function

When you need to iterate with specific steps (not just by 1), use the stride function:

// Count from 0 to 10 by 2s
for num in stride(from: 0, to: 11, by: 2) {
    print(num)
}
// Prints: 0, 2, 4, 6, 8, 10

// Count from 10 down to 1
for num in stride(from: 10, to: 0, by: -1) {
    print(num)
}
// Prints: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

Note: stride(from:to:by:) excludes the upper bound, while stride(from:through:by:) includes it.

4. Practical Examples

Let's explore some common use cases for for-loops and ranges in real Swift applications.

A. Looping Through Arrays

Arrays are one of the most common data structures you'll work with:

let taskList = ["Buy groceries", "Clean house", "Pay bills", "Call mom"]

for task in taskList {
    print("ToDo: \(task)")
}

// With indices
for (index, task) in taskList.enumerated() {
    print("Task \(index + 1): \(task)")
}

B. Creating Patterns with Nested Loops

Nested loops (loops inside loops) are useful for working with multi-dimensional data or creating patterns:

// Printing a simple triangle pattern
for row in 1...5 {
    var line = ""
    for _ in 1...row {
        line += "* "
    }
    print(line)
}
/*
Prints:
* 
* * 
* * * 
* * * * 
* * * * * 
*/

C. Working with Indices

Sometimes you need direct access to array indices:

let scores = [85, 92, 78, 96, 88]
var totalScore = 0

// Calculate average score
for i in 0..<scores.count {
    totalScore += scores[i]
}

let averageScore = Double(totalScore) / Double(scores.count)
print("Average score: \(averageScore)")

5. Best Practices

A. When to Use For-Loops vs Other Loops

i. Use for-loops when:

You know exactly how many iterations you need
You're working with collections (arrays, dictionaries, strings)
You need to iterate through a specific range of numbers

ii. Use while/repeat-while loops when:

The number of iterations is not known in advance
The loop condition depends on external factors (like user input)
You need to check the condition before or after each iteration

B. Performance Considerations

i. Avoid modifying the collection you're iterating through:

// Avoid this pattern:
var numbers = [1, 2, 3, 4, 5]
for number in numbers {
    if number % 2 == 0 {
        numbers.remove(at: numbers.firstIndex(of: number)!)
    }
}

Instead, create a new collection or use specialized methods like filter().

ii. Use break to exit a loop early when possible:

for number in 1...1000 {
    if number * number > 10000 {
        print("First number with square > 10000: \(number)")
        break
    }
}

iii. Use continue to skip the current iteration:

for number in 1...10 {
    if number % 2 == 0 {
        continue // Skip even numbers
    }
    print(number) // Prints only odd numbers
}

C. Common Mistakes to Avoid

i. Off-by-one errors: Be careful with the difference between closed ranges (...) and half-open ranges (..<).

ii. Infinite loops: While this is more common with while loops, be careful not to create a situation where your loop never terminates.

iii. Unnecessary iteration: Sometimes functions like map, filter, or reduce can be more efficient and readable than manual for-loops.

6. SwiftUI Specific Applications

In SwiftUI, for-loops are often used with the ForEach view to create dynamic lists of views:

struct ContentView: View {
    let colors = ["Red", "Green", "Blue", "Yellow", "Purple"]

    var body: some View {
        List {
            ForEach(0..<colors.count, id: \.self) { index in
                Text("\(index + 1). \(colors[index])")
            }
        }
    }
}

This creates a dynamic list where each row is a numbered color name.

7. Summary

For-loops and ranges are fundamental tools in Swift programming that allow you to:

Iterate through collections efficiently
Repeat code a specific number of times
Process data in a sequential manner
Create dynamic user interfaces in SwiftUI

Understanding how to use the different range operators (..., ..<) and special functions like stride() and enumerated() will help you write more efficient and readable code as you continue your Swift journey.

Remember that for-loops are just one tool in your programming arsenal. As you advance, you'll discover functional programming alternatives like map(), filter(), and reduce() that can sometimes replace loops with more concise code.

Learn with videos and source files. Available to Pro subscribers only.

Purchase includes access to 50+ courses, 320+ premium tutorials, 300+ hours of videos, source files and certificates.

BACK TO

Swift Dictionaries

Download source files

Download the videos and assets to refer and learn offline without interuption.

Design template

Source code for all sections

Video files, ePub and subtitles

Videos

Assets

Building Your iOS Development Foundation

Master the fundamentals of Swift programming with hands-on examples designed for beginners and experienced developers alike

SwiftUI Print Debugging

Print debugging: Unlock the invisible processes with strategic print statements that illuminate state changes, view lifecycles and data flow