Error handling

Error handling is a critical aspect of programming in Swift. It provides a flexible and straightforward way to propagate and handle errors during runtime. Swift uses a combination of language features to support error handling, which includes throwing, catching, propagating, and manipulating errors.

Defining Errors

In Swift, errors are represented by types that conform to the Error protocol. You can use enum to group related error conditions together.

enum FileError: Error {
   case fileNotFound
   case insufficientPermissions
   case unknown
}

Throwing Errors

You can throw an error to indicate that an unexpected condition has occurred. Functions and methods that can throw an error must be marked with the throws keyword.

func readFile(filename: String) throws {
   if filename == "bad_file.txt" {
       throw FileError.fileNotFound
   }
   // rest of the code
}

Catching and Handling Errors

To handle errors in Swift, you use do-catch blocks. Within a do block, you write code that can potentially throw an error. The corresponding catch blocks catch and handle the error.

do {
   try readFile(filename: "bad_file.txt")
} catch FileError.fileNotFound {
   print("File not found.")
} catch FileError.insufficientPermissions {
   print("You don't have permissions to read this file.")
} catch {
   print("An unknown error occurred.")
}

You can also catch errors and bind them to a local constant for further interrogation:

do {
   try readFile(filename: "bad_file.txt")
} catch let error as FileError {
   print("Caught a specific file error: \(error)")
} catch {
   print("An unknown error occurred: \(error)")
}

Propagating Errors

You can propagate errors from a function to its callers by marking the function with throws. The calling function must then handle the error using a do-catch block or continue to propagate it.

func processFile(filename: String) throws {
   try readFile(filename: filename)
   // further code
}

Optional try

Swift provides try? and try! to convert the result into an optional. If the function throws an error, the result is nil.

if let result = try? readFile(filename: "some_file.txt") {
   print("Read file successfully.")
} else {
   print("Failed to read file.")
}

Using try! disables error propagation and runtime crashes if an error is thrown.

let result = try! readFile(filename: "known_good_file.txt")

Use try! cautiously, only when you're sure that the function will not throw an error.

Clean-up Actions

Swift provides defer blocks for writing code that is executed both when the code is successful and when it throws an error. It's useful for cleaning up resources like file handles.

func someFunction() throws {
   // Acquire some resource
   defer {
       // Release the resource
   }
   // Do something that may throw an error
}

Swift's error handling combines language features like throws, try, catch, and defer with standard library types like Error to provide a robust and comprehensive system for dealing with runtime errors in a clear and maintainable way.