Do-try-catch execution flow in Swift - Time & Space Complexity

Time Complexity: Do-try-catch execution flow

O(1)

Understanding Time Complexity

When using do-try-catch in Swift, it's important to see how the program runs depending on success or failure.

We want to know how the number of steps changes as the code tries to run and handle errors.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

func readFile(name: String) throws -> String {
    // Imagine this reads a file and may throw an error
    return "File content"
}

func processFile(name: String) {
    do {
        let content = try readFile(name: name)
        print(content)
    } catch {
        print("Error reading file")
    }
}
    

This code tries to read a file and prints its content if successful, or prints an error message if it fails.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Calling readFile once inside the do block.
• How many times: Exactly one time per processFile call.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations
1	1 try + 1 print
10	10 tries + 10 prints (if called 10 times)
100	100 tries + 100 prints (if called 100 times)

Pattern observation: Each call to processFile performs exactly one try and one print (either content or error). Thus, the number of operations grows linearly with the number of calls.

Final Time Complexity

Time Complexity: O(1) per call to processFile

This means the time is constant and does not grow with input size within a single call.

Common Mistake

[X] Wrong: "The catch block runs multiple times inside one call if an error happens."

[OK] Correct: The catch block runs only once per try. It does not loop or repeat inside the same call.

Interview Connect

Understanding how do-try-catch flows helps you explain error handling clearly and shows you know how code runs step-by-step.

Self-Check

"What if the readFile function called itself recursively? How would the time complexity change?"