Why error handling is explicit in Swift - See It in Action

Why error handling is explicit in Swift

📖 Scenario: Imagine you are building a simple app that reads user data from a file. Sometimes the file might not exist or the data might be corrupted. You want to handle these problems clearly so the app doesn't crash unexpectedly.

🎯 Goal: You will create a small Swift program that shows how to explicitly handle errors using Swift's do-catch blocks and throws functions. This will help you understand why Swift makes error handling clear and visible.

📋 What You'll Learn

Create a function called readUserData() that can throw an error

Define an error type called DataError with a case fileNotFound

Use a do-catch block to call readUserData() and handle the error explicitly

Print a message when the data is read successfully or when an error occurs

💡 Why This Matters

🌍 Real World

Apps often need to read files, access the internet, or work with user input where errors can happen. Handling errors explicitly helps keep apps stable and user-friendly.

💼 Career

Understanding Swift's explicit error handling is important for iOS developers to write safe and maintainable code that gracefully handles problems.

1

Define the error type

Define an enum called DataError that conforms to Error and has one case called fileNotFound.

Swift

# Define the DataError enum here
// Your code here

Hint

Use enum to define error types in Swift. Make sure it conforms to Error.

2

Create a throwing function

Create a function called readUserData() that returns a String and is marked with throws. Inside, immediately throw the DataError.fileNotFound error.

Swift

enum DataError: Error {
    case fileNotFound
}

// Create the readUserData() function here
// Your code here

Hint

Mark the function with throws to indicate it can throw an error.

3

Use do-catch to handle the error

Write a do-catch block that calls readUserData(). In the do block, assign the result to a variable called data. In the catch block, catch DataError.fileNotFound and print "File not found error caught!".

Swift

enum DataError: Error {
    case fileNotFound
}

func readUserData() throws -> String {
    throw DataError.fileNotFound
}

// Add do-catch block here
// Your code here

Hint

Use try before calling a throwing function inside do. Catch specific errors in catch blocks.

4

Print the final output

Run the program so it prints the message "File not found error caught!" when the error is thrown and caught.

Swift

enum DataError: Error {
    case fileNotFound
}

func readUserData() throws -> String {
    throw DataError.fileNotFound
}

do {
    let data = try readUserData()
    print("Data read: \(data)")
} catch DataError.fileNotFound {
    print("File not found error caught!")
}

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

Hint

When you run the program, it should print the error message because the function always throws.

Practice

1. Why does Swift require error handling to be explicit using throws and try?

easy

A. To make sure programmers handle errors clearly and avoid unexpected crashes

B. To make the code run faster by skipping error checks

C. To hide errors from users automatically

D. To allow errors to be ignored silently

Solution

1. Step 1: Understand Swift's error handling design

   Swift forces explicit error handling to make sure errors are noticed and managed properly.

2. Step 2: Recognize the benefit of explicit handling

   This avoids unexpected crashes and makes programs more reliable and easier to maintain.

3. Final Answer:

   To make sure programmers handle errors clearly and avoid unexpected crashes -> Option A

4. Quick Check:

   Explicit error handling = clear, safe code [OK]

Hint: Explicit means you must handle errors clearly every time [OK]

Common Mistakes:

• Thinking errors are handled automatically
• Believing explicit handling slows down code
• Confusing explicit with optional error handling

2. Which of the following is the correct way to call a function that can throw an error in Swift?

easy

A. let result = someFunction()

B. let result = try someFunction()

C. let result = throws someFunction()

D. let result = catch someFunction()

Solution

1. Step 1: Recall Swift syntax for calling throwing functions

   Functions that can throw errors must be called with the try keyword.

2. Step 2: Identify the correct syntax

   Only let result = try someFunction() uses the correct keyword try before the function call.

3. Final Answer:

   let result = try someFunction() -> Option B

4. Quick Check:

   Use try before throwing functions [OK]

Hint: Use 'try' before calling throwing functions [OK]

Common Mistakes:

• Omitting 'try' when calling throwing functions
• Using 'throws' instead of 'try' when calling
• Using 'catch' incorrectly in function calls

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

func canThrow() throws -> String {
  return "Success"
}

func test() {
  do {
    let result = try canThrow()
    print(result)
  } catch {
    print("Error caught")
  }
}
test()

medium

A. Success

B. Error caught

C. No output

D. Compile error

Solution

1. Step 1: Analyze the throwing function behavior

   The function canThrow() is marked as throwing but always returns "Success" without throwing an error.

2. Step 2: Understand the do-catch block execution

   The try succeeds, so print(result) prints "Success" and the catch block is skipped.

3. Final Answer:

   Success -> Option A

4. Quick Check:

   try succeeds, prints result [OK]

Hint: If no error thrown, do-catch prints success path [OK]

Common Mistakes:

• Assuming catch runs even if no error
• Thinking throws always cause errors
• Expecting compile error without catch

4. Identify the error in this Swift code snippet:

func risky() throws -> Int {
  return 42
}

let value = risky()

medium

A. Cannot assign function result to a constant

B. Function must return a String, not Int

C. Missing 'throws' keyword in function declaration

D. Missing 'try' keyword when calling a throwing function

Solution

1. Step 1: Check function declaration and call

   The function risky() is declared with throws, so it can throw errors.

2. Step 2: Verify calling syntax

   Calling a throwing function requires the try keyword, which is missing here.

3. Final Answer:

   Missing 'try' keyword when calling a throwing function -> Option D

4. Quick Check:

   Call throwing functions with 'try' [OK]

Hint: Always use 'try' when calling throwing functions [OK]

Common Mistakes:

• Calling throwing functions without 'try'
• Confusing return types
• Ignoring function's throws declaration

5. You want to write a Swift function that reads a file and returns its content as a String. The file reading can fail. How should you design this function to follow Swift's explicit error handling?

hard

A. Use do-catch inside the function but do not mark it with throws

B. Return an optional String and ignore errors silently

C. Declare the function with throws and use try when calling file reading methods

D. Catch errors inside the function and print them, then return an empty String

Solution

1. Step 1: Understand Swift's explicit error handling philosophy

   Functions that can fail should be marked with throws to force callers to handle errors explicitly.

2. Step 2: Apply correct design for file reading

   The function should declare throws and use try when calling file reading methods that can throw errors.

3. Final Answer:

   Declare the function with throws and use try when calling file reading methods -> Option C

4. Quick Check:

   Use throws and try for error propagation [OK]

Hint: Mark throwing functions with 'throws' and call with 'try' [OK]

Common Mistakes:

• Ignoring errors by returning optionals
• Catching errors inside without propagating
• Returning empty strings on failure silently