Do-try-catch execution flow in Swift - Mini Project: Build & Apply

Do-try-catch Execution Flow in Swift

📖 Scenario: Imagine you are writing a simple Swift program that reads a number from a string and handles errors if the string is not a valid number.

🎯 Goal: You will build a Swift program that uses do-try-catch to safely convert a string to a number and handle possible errors.

📋 What You'll Learn

Create a function that throws an error if the string is not a valid number

Use a do block with try to call the function

Add catch blocks to handle errors

Print the result or error message

💡 Why This Matters

🌍 Real World

Handling errors when converting user input or data from files is very common in apps and programs.

💼 Career

Understanding <code>do-try-catch</code> is essential for Swift developers to write robust and crash-free code.

1

Create a throwing function

Write a function called convertToInt that takes a String parameter named input and returns an Int. The function should throw an error of type ConversionError.invalidNumber if the string cannot be converted to an integer. Define the ConversionError enum with a case invalidNumber.

Swift

// Define ConversionError enum and convertToInt function
// Your code here

Hint

Use guard let to try converting the string to Int. If it fails, throw the error.

2

Set up the input string

Create a constant called inputString and set it to the string "123a".

Swift

enum ConversionError: Error {
    case invalidNumber
}

func convertToInt(input: String) throws -> Int {
    guard let number = Int(input) else {
        throw ConversionError.invalidNumber
    }
    return number
}

// Create inputString constant
// Your code here

Hint

Use let inputString = "123a" to create the string.

3

Use do-try-catch to convert the string

Write a do block that tries to convert inputString to an integer using try convertToInt(input: inputString). Store the result in a constant called number. Add a catch block that catches ConversionError.invalidNumber and prints "Invalid number format.". Add a general catch block that prints "Unknown error.".

Swift

enum ConversionError: Error {
    case invalidNumber
}

func convertToInt(input: String) throws -> Int {
    guard let number = Int(input) else {
        throw ConversionError.invalidNumber
    }
    return number
}

let inputString = "123a"

// Use do-try-catch to convert inputString
// Your code here

Hint

Use do { let number = try convertToInt(input: inputString) } and add catch blocks for errors.

4

Print the final output

Run the program and observe the output printed by the do-try-catch block.

Swift

enum ConversionError: Error {
    case invalidNumber
}

func convertToInt(input: String) throws -> Int {
    guard let number = Int(input) else {
        throw ConversionError.invalidNumber
    }
    return number
}

let inputString = "123a"

do {
    let number = try convertToInt(input: inputString)
    print("Number is \(number)")
} catch ConversionError.invalidNumber {
    print("Invalid number format.")
} catch {
    print("Unknown error.")
}

// Run the program and see the output
// Your code here

Hint

The program should print Invalid number format. because the string contains a letter.

Practice

1. What is the main purpose of using do-try-catch in Swift?

easy

A. To handle errors safely without crashing the program

B. To create loops that run multiple times

C. To define new functions

D. To declare variables with default values

Solution

1. Step 1: Understand the role of do-try-catch

   This structure is used to run code that might throw errors and handle those errors gracefully.

2. Step 2: Identify the purpose

   It prevents the program from crashing by catching errors and allowing alternative actions.

3. Final Answer:

   To handle errors safely without crashing the program -> Option A

4. Quick Check:

   Error handling = A [OK]

Hint: Remember: try means risky code, catch means safe backup [OK]

Common Mistakes:

• Confusing error handling with loops
• Thinking try-catch defines functions
• Assuming it declares variables

2. Which of the following is the correct syntax to start a do-try-catch block in Swift?

easy

A. try someFunction() do { catch handleError() }

B. try { do someFunction() } catch { handleError() }

C. catch { try someFunction() } do { handleError() }

D. do { try someFunction() } catch { handleError() }

Solution

1. Step 1: Recall correct do-try-catch syntax

   The correct syntax starts with do {}, inside which try is used before the function that might throw.

2. Step 2: Match syntax with options

   do { try someFunction() } catch { handleError() } correctly places do block, uses try inside, and follows with catch block.

3. Final Answer:

   do { try someFunction() } catch { handleError() } -> Option D

4. Quick Check:

   Correct syntax = D [OK]

Hint: Remember: do { try ... } catch { ... } is the pattern [OK]

Common Mistakes:

• Placing try outside do block
• Swapping catch and do blocks
• Missing curly braces

3. What will be the output of the following Swift code?

enum MyError: Error { case fail }

func risky() throws {
  throw MyError.fail
}

do {
  try risky()
  print("Success")
} catch {
  print("Caught an error")
}

medium

A. Success

B. Caught an error

C. No output

D. Compile-time error

Solution

1. Step 1: Analyze the function risky()

   This function always throws an error of type MyError.fail.

2. Step 2: Trace the do-try-catch block

   When try risky() runs, it throws an error, so the code jumps to the catch block and prints "Caught an error".

3. Final Answer:

   Caught an error -> Option B

4. Quick Check:

   Error thrown = catch block runs = B [OK]

Hint: If try throws, catch block runs, not code after try [OK]

Common Mistakes:

• Assuming code after try runs despite error
• Thinking no output occurs
• Confusing compile error with runtime error

4. Identify the error in this Swift code snippet:

do {
  try someFunction()
} catch error {
  print("Error: \(error)")
}

func someFunction() {
  print("Running")
}

medium

A. Function someFunction() must be marked with throws

B. Catch block syntax is incorrect

C. Missing do keyword

D. Print statement inside catch is invalid

Solution

1. Step 1: Check function declaration

   The function someFunction() is called with try, so it must be declared with throws to indicate it can throw errors.

2. Step 2: Identify mismatch causing error

   Since someFunction() is not marked throws, the compiler will raise an error.

3. Final Answer:

   Function someFunction() must be marked with throws -> Option A

4. Quick Check:

   try requires throws function = C [OK]

Hint: Only functions marked throws can be called with try [OK]

Common Mistakes:

• Ignoring throws keyword on function
• Thinking catch syntax is wrong
• Assuming print inside catch is invalid

5. Given this Swift code, what will be printed?

enum FileError: Error { case notFound, unreadable }

func readFile(_ name: String) throws -> String {
  if name == "missing.txt" { throw FileError.notFound }
  if name == "bad.txt" { throw FileError.unreadable }
  return "File content"
}

do {
  let content = try readFile("bad.txt")
  print(content)
} catch FileError.notFound {
  print("File not found")
} catch {
  print("Other error")
}

hard

A. File content

B. File not found

C. Other error

D. No output

Solution

1. Step 1: Analyze the function call

   Calling readFile("bad.txt") throws FileError.unreadable.

2. Step 2: Check catch blocks for matching error

   The first catch handles FileError.notFound, which does not match. The second catch is a general catch that handles all other errors, so it runs and prints "Other error".

3. Final Answer:

   Other error -> Option C

4. Quick Check:

   Specific catch misses, general catch runs = A [OK]

Hint: Specific catch runs only if error matches exactly [OK]

Common Mistakes:

• Assuming first catch runs for all errors
• Thinking no output occurs
• Confusing error types