Swift Program to Handle Simple Exceptions

1. Introduction

Exception handling is crucial in programming to deal with unexpected errors and ensure a smooth user experience. Swift provides a robust mechanism for handling exceptions using do-catch blocks. Let’s take a look at how to handle simple exceptions in Swift by working on a program that extracts a substring from a string.

2. Program Overview

1. We'll define a function substring(from:to:) to extract a substring from a given string between the specified indices.

2. We'll throw exceptions if the provided indices are invalid.

3. We'll then use a do-catch block to handle these exceptions.

3. Code Program

// Define the type of error we expect
enum StringError: Error {
    case invalidIndex
    case startIndexGreaterThanEndIndex

// Function that extracts a substring from a given string based on the start and end index
func substring(from string: String, start: Int, end: Int) throws -> String {
    guard start >= 0, end < string.count else {
        throw StringError.invalidIndex

    guard start <= end else {
        throw StringError.startIndexGreaterThanEndIndex

    let startIndex = string.index(string.startIndex, offsetBy: start)
    let endIndex = string.index(string.startIndex, offsetBy: end)

    return String(string[startIndex...endIndex])

// Using the function and handling exceptions
do {
    let result = try substring(from: "Hello, World!", start: 0, end: 4)
} catch StringError.invalidIndex {
    print("One of the indices provided is invalid.")
} catch StringError.startIndexGreaterThanEndIndex {
    print("Start index is greater than end index.")
} catch {
    print("An unknown error occurred.")



4. Step By Step Explanation

1. We start by defining an error type StringError that lists possible error scenarios. In our case, the scenarios are an invalid index and a start index greater than the end index.

2. Next, we define a function substring(from:to:). Within this function, we check for possible errors using guard statements:

- If the start or end index is outside the range of the string, we throw StringError.invalidIndex.- If the start index is greater than the end index, we throw StringError.startIndexGreaterThanEndIndex.

3. We then calculate the startIndex and endIndex in the string using the provided indices and return the substring.

4. When using the substring(from:to:) function, we wrap it in a do-catch block to handle potential errors. If an error is thrown within the do block, execution jumps to the catch block where we handle the error.

- If the error matches StringError.invalidIndex, we print a corresponding message.- If the error matches StringError.startIndexGreaterThanEndIndex, we print another message.- For all other errors, we print a generic error message.By implementing exception handling, we make our program more resilient and user-friendly. It's always good practice to anticipate and handle potential errors in your code.