iOS Interview Questions with Code Examples: Part 1

Photo by Maranda Vandergriff on Unsplash

Preparing for an iOS interview can be a daunting task, especially when you’re aiming for more advanced positions. To help you ace your iOS interview, we’ve compiled a list of challenging questions along with detailed answers and code examples. These questions will test your knowledge of iOS development concepts and best practices. Let’s dive in!

Table of Contents

1. Delegation vs. Notification
2. @escaping in Swift Closures
3. Retain Cycles and Memory Management
4. CoreData for Persistent Data Storage
5. iOS App Lifecycle

1. Delegation vs. Notification

Question: What is the difference between Delegation and Notification in iOS?

Answer: Delegation and Notification are two common ways for objects to communicate in iOS.

• Delegation: Delegation is a design pattern where one object, known as the delegate, handles decisions or events on behalf of another object. It establishes a one-to-one relationship. For example, when you work with a UITableView, its delegate is responsible for providing data and handling user interactions like cell selection.
• Notification: Notification is a mechanism for broadcasting messages to multiple objects that have registered interest in receiving those messages. It establishes a one-to-many relationship. Using NotificationCenter, you can notify various parts of your app about events, such as when the keyboard appears or a network request completes.

Example:

// Delegation
protocol DataProviderDelegate: class {
    func didFetchData(data: [String])
}

class DataProvider {
    weak var delegate: DataProviderDelegate?
    
    func fetchData() {
        // Fetch data
        let data = ["Item 1", "Item 2", "Item 3"]
        delegate?.didFetchData(data: data)
    }
}

// Notification
NotificationCenter.default.addObserver(forName: Notification.Name("DataFetched"), object: nil, queue: nil) { notification in
    if let data = notification.userInfo?["data"] as? [String] {
        // Handle data
    }
}

2. @escaping in Swift Closures

Question: Explain the purpose of the @escaping keyword in Swift closures.

Answer: In Swift, the @escaping keyword is used to indicate that a closure parameter may "escape" the current function's scope, meaning it can be stored and called outside the scope of the function it was passed into. This is commonly used when you pass a closure as an argument to an asynchronous function.

Example:

func downloadData(completion: @escaping (Data) -> Void) {
    // Simulate an asynchronous operation
    DispatchQueue.global().async {
        let data = Data() // Fetched data
        DispatchQueue.main.async {
            completion(data) // Calling the closure after escaping the function scope
        }
    }
}

3. Retain Cycles and Memory Management

Question: What is a retain cycle in iOS, and how can you prevent it?

Answer: A retain cycle occurs when two or more objects hold strong references to each other, preventing them from being deallocated by the memory management system (ARC). This can lead to memory leaks.

To prevent retain cycles:

• Use weak or unowned references when capturing self in closures.
• Use capture lists in closures to specify reference types (e.g., [weak self]) to break strong reference cycles.

Example:

class MyClass {
    var someClosure: (() -> Void)?
    
    init() {
        someClosure = { [weak self] in
            self?.doSomething()
        }
    }
    
    func doSomething() {
        // Do something here
    }
}

4. CoreData for Persistent Data Storage

Question: Explain the usage of CoreData in iOS for persistent data storage.

Answer: CoreData is a framework in iOS used to manage the model layer of an application and provides a way to interact with a SQLite database for data persistence.

To use CoreData:

• Create a Data Model using Xcode’s data modeling tool.
• Create subclasses of NSManagedObject to represent your data entities.
• Use a NSManagedObjectContext to create, read, update, and delete managed objects.
• CoreData can use various persistent stores, with SQLite being the default.

Code Example:

let context = persistentContainer.viewContext
let entity = NSEntityDescription.entity(forEntityName: "Person", in: context)!
let person = NSManagedObject(entity: entity, insertInto: context)
person.setValue("John Doe", forKey: "name")

do {
    try context.save()
} catch {
    print("Error saving: \(error)")
}

// Fetching data
let request = NSFetchRequest<NSFetchRequestResult>(entityName: "Person")
do {
    let results = try context.fetch(request) as! [NSManagedObject]
    for person in results {
        print(person.value(forKey: "name") as! String)
    }
} catch {
    print("Error fetching: \(error)")
}

5. iOS App Lifecycle

Question: How does the iOS App Lifecycle work, and what are the main methods associated with it?

Answer: The iOS App Lifecycle describes the sequence of events that occur from the moment a user launches an app to when it’s terminated. Key methods associated with it include:

• application(_:didFinishLaunchingWithOptions:): Called when the app is launched, used for setup and initialization.
• application(_:willResignActive:): Called when the app transitions from an active to an inactive state (e.g., when a call arrives).
• application(_:didEnterBackground:): Called when the app enters the background, useful for saving app state or cleanup.
• application(_:willEnterForeground:): Called when the app is about to enter the foreground, used for UI updates or data refresh.
• application(_:didBecomeActive:): Called when the app becomes active, typically used to restart paused tasks.
• applicationWillTerminate(_:): Called when the app is about to terminate, used for saving essential data.

Example:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // App initialization code
    return true
}

func applicationDidEnterBackground(_ application: UIApplication) {
    // Save app state or perform cleanup
}
// Other lifecycle methods...

These iOS interview questions cover a range of topics, from design patterns to memory management and app lifecycle. Mastering these concepts and being able to provide code examples will help you excel in your iOS interviews. Happy coding and best of luck with your interviews!