Top Swift Interview Questions in 2025

Question: What are generics in Swift? Provide an example of their usage.

Answer:

Generics in Swift allow you to write flexible, reusable, and type-safe code that can work with any type. By using generics, you can define functions, methods, classes, and structs that can work with any data type while maintaining type safety. Generics enable you to write code that is more general and adaptable without compromising on type information or safety.

Key Features of Generics in Swift:

1. Type Flexibility: You can write code that works with any data type (e.g., Int, String, CustomType), without needing to specify the exact type upfront.
2. Type Safety: Despite being flexible, generics ensure that the correct type is used in a type-safe manner. The compiler will catch type mismatches at compile-time.
3. Reusability: Generics allow you to write reusable functions and types that can work with any data type.
4. Type Constraints: You can constrain generics to restrict them to specific types, ensuring that only certain types can be used with a generic function, method, or type.

Syntax:

func functionName<T>(param: T) { ... }

Where:

• T is a placeholder for a type, and it will be replaced with a specific type when the function or type is used.
• You can use T as a type wherever you need a type (e.g., in parameters, return types, etc.).

Example 1: Generic Function

A basic example of a generic function that can accept parameters of any type:

// A generic function that returns the first element of an array
func firstElement<T>(of array: [T]) -> T? {
    return array.first
}

let intArray = [1, 2, 3]
let firstInt = firstElement(of: intArray) // Returns an optional Int: 1

let stringArray = ["a", "b", "c"]
let firstString = firstElement(of: stringArray) // Returns an optional String: "a"

In this example, the function firstElement is generic, which means it can work with arrays of any type. The placeholder type T represents any type, so the function can accept an array of Int, String, or any other type.

Example 2: Generic Type (Struct)

A generic type such as a struct that can hold any type of data:

// A generic struct to represent a box that holds any type
struct Box<T> {
    var value: T
}

// Creating instances of the Box struct with different types
let intBox = Box(value: 42)          // Box of Int
let stringBox = Box(value: "Hello")  // Box of String

print(intBox.value)      // Output: 42
print(stringBox.value)   // Output: Hello

In this example, the Box struct is generic and can hold any type of data. When creating instances of Box, you specify the type to be used, such as Int or String.

Example 3: Generic Constraints

Sometimes, you might want to restrict the types that can be used with a generic. This is done using type constraints. For example, you can constrain the type to only work with types that conform to a protocol:

// A protocol defining a requirement for an object to have a `description` property
protocol Describable {
    var description: String { get }
}

// A generic function with a constraint that the type must conform to `Describable`
func printDescription<T: Describable>(item: T) {
    print(item.description)
}

struct Person: Describable {
    var name: String
    var description: String {
        return "Person's name is \(name)"
    }
}

struct Car: Describable {
    var model: String
    var description: String {
        return "Car model is \(model)"
    }
}

// Using the generic function with types that conform to `Describable`
let person = Person(name: "Alice")
let car = Car(model: "Tesla")

printDescription(item: person)  // Output: Person's name is Alice
printDescription(item: car)     // Output: Car model is Tesla

In this example:

• We defined a Describable protocol with a description property.
• The function printDescription is generic but includes a constraint (T: Describable), meaning it can only accept types that conform to the Describable protocol.
• The Person and Car structs conform to Describable, so we can pass instances of them to the printDescription function.

Example 4: Generic Collections

Generics are heavily used in Swift’s standard library, such as with Array, Dictionary, and Set, which are all generic types:

// A generic array that holds Int values
var numbers: [Int] = [1, 2, 3, 4]

// A generic dictionary that maps a String to an Int
var ages: [String: Int] = ["Alice": 30, "Bob": 25]

// A generic set that holds unique String values
var uniqueNames: Set<String> = ["Alice", "Bob", "Charlie"]

• numbers is an array of type Int.
• ages is a dictionary with String keys and Int values.
• uniqueNames is a set that holds String values.

All of these collections are generic, allowing them to store any type of data (e.g., Int, String), and the Swift compiler enforces type safety when interacting with them.

Example 5: Generic Extensions

You can also extend existing types with generics. Here’s how you can extend Array to add a new method that finds the middle element of the array:

// Adding a generic method to Array
extension Array {
    func middleElement() -> Element? {
        guard count > 0 else { return nil }
        return self[count / 2]
    }
}

let numbers = [1, 2, 3, 4, 5]
if let middle = numbers.middleElement() {
    print(middle)  // Output: 3
}

let strings = ["apple", "banana", "cherry"]
if let middle = strings.middleElement() {
    print(middle)  // Output: banana
}

Here, the middleElement() method is added as a generic extension on the Array type. It works with any array type (Int[], String[], etc.).

Why Use Generics in Swift?

• Flexibility: Generics make your code more flexible and reusable by allowing you to write functions and types that work with any data type.
• Type Safety: Despite their flexibility, generics ensure that type safety is maintained, preventing type mismatches at compile time.
• Readability: Using generics can often make your code more readable and understandable by reducing the need for type casting and duplication.
• Performance: Generics are implemented using type substitution, meaning that there is no runtime cost or performance overhead when using them. Swift performs type inference and optimization at compile time.

Summary:

• Generics in Swift allow you to write flexible, reusable, and type-safe code that can work with any data type.
• They help you write more abstract code, which can handle multiple types while keeping the code clean and type-safe.
• Swift’s generics include powerful features such as type constraints and type inference, and they are widely used in the standard library to define collections like Array, Dictionary, and Set.

By using generics, you can create functions and types that work with any type while maintaining type safety and reusability.

Question: How does Swift handle error handling?

Answer:

Swift provides a powerful and flexible error handling model that allows developers to handle runtime errors in a structured way. Error handling in Swift is built around three key components:

1. Error Types
2. Throwing Functions
3. Catching Errors

Key Concepts in Swift Error Handling:

1. Error Types:

In Swift, errors are represented by values of types that conform to the Error protocol. The Error protocol itself is an empty protocol, meaning that any type can conform to it, as long as it doesn’t have specific requirements. Usually, custom error types are defined using enums or structs.

Example of defining an error type:

enum NetworkError: Error {
    case badURL
    case timeout
    case serverError
}

Here, the NetworkError enum conforms to the Error protocol, and each case represents a different kind of error that might occur during a network operation.

2. Throwing Functions:

A function in Swift can throw an error using the throw keyword. A throwing function is defined by appending the throws keyword to the function signature.

Example of a throwing function:

func fetchData(from url: String) throws -> Data {
    guard let validURL = URL(string: url) else {
        throw NetworkError.badURL  // Throws an error if URL is invalid
    }
    
    // Simulating a network request
    let success = false
    if !success {
        throw NetworkError.serverError  // Throws an error if the server fails
    }
    
    return Data()  // Returns data if no errors occur
}

In the example above:

• The fetchData(from:) function is marked with the throws keyword because it may throw an error.
• The function throws NetworkError.badURL or NetworkError.serverError depending on the conditions.

3. Catching Errors:

You catch errors using the do-catch statement. This allows you to handle errors at the point where the function is called.

Syntax of do-catch:

do {
    // Try to execute throwing function
    try someThrowingFunction()
} catch {
    // Handle the error
}

Example of using do-catch:

do {
    let data = try fetchData(from: "https://example.com")
    print("Data fetched: \(data)")
} catch NetworkError.badURL {
    print("Invalid URL.")
} catch NetworkError.serverError {
    print("Server error occurred.")
} catch {
    print("An unexpected error occurred: \(error)")
}

In this example:

• The fetchData(from:) function is called inside the do block, and the try keyword is used to indicate that the function can throw an error.
• If an error is thrown, control moves to the catch block, where specific errors are matched. If none of the specific catch blocks match, the general catch block will handle any other errors.

4. Propagating Errors:

Swift allows errors to be propagated from a throwing function to its caller. This is useful when you want to let the calling code handle the error, rather than handling it inside the current function.

Example of propagating errors:

func performNetworkRequest() throws {
    try fetchData(from: "https://example.com")
}

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

In this example:

• The performNetworkRequest function calls the fetchData function, and because fetchData is a throwing function, performNetworkRequest is also marked as throws to propagate the error.
• When calling performNetworkRequest, we use try and handle any errors with catch.

5. Optional Try (try?):

Sometimes, you want to ignore an error and handle it gracefully by returning nil instead of propagating the error. You can use the try? keyword for this purpose. This converts any error into an optional value.

Example of using try?:

let data = try? fetchData(from: "https://example.com")

if let data = data {
    print("Data fetched successfully.")
} else {
    print("Failed to fetch data.")
}

In this example:

• try? returns an optional value (Data?). If the function throws an error, it returns nil.
• You can use optional binding (if let) to check if the operation succeeded.

6. Forced Try (try!):

If you are certain that a throwing function will not throw an error, you can use try! to execute the function without needing to handle errors explicitly. This will cause a runtime crash if the function does throw an error.

Example of using try!:

let data = try! fetchData(from: "https://example.com")
print("Data fetched successfully.")

In this case:

• If fetchData(from:) throws an error, it will cause a crash at runtime. Use try! cautiously and only when you’re sure no error will occur.

7. Multiple Catch Clauses:

You can have multiple catch blocks to handle different error types. This helps in providing more specific error handling.

Example:

do {
    try fetchData(from: "https://example.com")
} catch NetworkError.badURL {
    print("Invalid URL.")
} catch NetworkError.serverError {
    print("Server error occurred.")
} catch {
    print("An unexpected error occurred: \(error)")
}

In this example:

• Different errors are handled in separate catch blocks.
• The catch block that matches the error type will be executed.

8. Custom Error Types:

You can define your own custom error types by conforming to the Error protocol. This can be useful when you want to represent more specific errors in your application.

Example:

enum CustomError: Error {
    case networkFailure
    case invalidData
}

func processData() throws {
    throw CustomError.networkFailure
}

do {
    try processData()
} catch CustomError.networkFailure {
    print("Network failure occurred.")
} catch CustomError.invalidData {
    print("Invalid data encountered.")
} catch {
    print("An unexpected error occurred.")
}

Summary of Error Handling Features in Swift:

• Error Types: Errors are types that conform to the Error protocol (commonly enums or structs).
• Throwing Functions: Functions that can throw errors are marked with the throws keyword. You must use try when calling them.
• Do-Catch: Used to handle errors. Inside the do block, you use try to call a throwing function. The catch block handles errors.
• Error Propagation: Errors can be propagated using throws to pass the error handling responsibility to the calling function.
• Optional Try (try?): Returns an optional value, which is nil if an error occurs.
• Forced Try (try!): Used when you’re sure the function won’t throw an error. It will cause a runtime crash if an error occurs.
• Multiple Catch Clauses: You can handle different error types with multiple catch blocks.
• Custom Error Types: You can create your own error types by conforming to the Error protocol.

Swift’s error handling model ensures that errors are handled gracefully, providing mechanisms to catch, propagate, and recover from errors in a predictable manner.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as Swift interview questions, Swift interview experiences, and details about various Swift job positions. Click here to check it out.