iOS Interview Questions — Middle to Strong Senior

• var is used to declare variables whose values can change (mutable).
• let is used to declare constants whose values cannot be changed once assigned (immutable).Example:

var name = "John" // mutable
name = "Jane" // allowed

let age = 25 // immutable
// age = 26 // not allowed, compile-time error

Optional chaining is a process for querying and calling properties, methods, and subscripts on an optional that might currently be nil. If the optional is nil, the call returns nil without causing a runtime error; otherwise, it unwraps and proceeds.

Example:

struct Person {
var dog: Dog?
}
struct Dog {
var name: String
}

let person = Person(dog: Dog(name: "Rex"))
print(person.dog?.name ?? "Dog is nil") // "Rex"

If person.dog was nil, person.dog?.name would simply return nil.

ARC is a memory management mechanism in Swift (and Objective-C) that automatically keeps track of how many references point to each class instance.

When there are no more references (strong references) to an object, ARC frees it from memory. This eliminates the need for manual memory management most of the time.

A completion handler is a callback function passed as an argument to another function. It executes after a task completes (e.g., a network request). This helps with asynchronous operations.

Example:

func fetchData(completion: @escaping (Data?) -> Void) {
// Simulate asynchronous task
DispatchQueue.global().async {
let data = Data()
completion(data)
}
}

Here, the completion handler is called once data is fetched.

• Structs are value types; they are copied on assignment or passing.
• Classes are reference types; multiple variables can refer to the same instance. Classes support inheritance, while structs do not.

A protocol defines a blueprint of methods, properties, and other requirements that a class, struct, or enum can adopt.

Example:

protocol Greetable {
var greeting: String { get }
func greet()
}

struct Greeter: Greetable {
let greeting: String
func greet() {
print(greeting)
}
}

Extensions add new functionality to an existing class, struct, enum, or protocol type without modifying the original source code. They can add computed properties, instance methods, type methods, and more.

Example:

extension String {
var reversedString: String {
return String(self.reversed())
}
}

Async tasks are added to the queue and execution is immediately continued without waiting till the async task is finished - async task will be executed at some in future.

Sync tasks are added to the queue and execution will be continued after thing tasks is finished.

Model-View-Controller (MVC):

• Model: Manages the data and business logic.
• View: Handles the UI and presentation.
• Controller: Mediates between Model and View, handling updates and user input. This helps separate concerns and maintain cleaner code.

Best practices:

• if/if let statements are used to unwrap optional or checks inside the scope that are not influencing on general execution flow of a current scope
• guard/guard let statements are used to explicitly check the conditions to understand if the execution should be continued. If condition in guard/guard let statement fails in most cases it means that the current scope should be exited.

Codable is a protocol that combines Encodable and Decodable. It allows easy encoding/decoding of custom data types into/from formats like JSON.

Example:

struct User: Codable {
let name: String
let age: Int
}

// Encoding
let user = User(name: "John", age: 25)
if let encoded = try? JSONEncoder().encode(user) {
// Decoding
let decodedUser = try? JSONDecoder().decode(User.self, from: encoded)
}

Swift uses the throw, try, and catch keywords to handle errors. Functions can declare that they throw errors, which must be handled by callers.

Example:

enum DataError: Error {
case noData
}

func loadData() throws -> String {
throw DataError.noData
}

do {
let data = try loadData()
} catch {
print("Error: (error)")
}

A lazy stored property is not calculated until the first time it’s accessed. It’s useful for delaying costly initializations until they’re actually needed.

Example:

class DataManager {
lazy var data = expensiveDataLoad() // `data` is only loaded when first accessed
func expensiveDataLoad() -> [String] { return ["Item1","Item2"] }
}

URLSession is a framework/API that provides a set of classes and methods for configuring and managing network sessions. It gives a possibility to fetch data from a server, upload and download media and content files, and handles WebSocket communication.

Example:

let url = URL(string: "https://api.example.com/data")!
let task = URLSession.shared.dataTask(with: url) { data, response, error in
// Handle response
}
task.resume()

GCD is an API in iOS for managing concurrent operations. It allows you to dispatch tasks to different queues (main, global, custom) and handle parallelism easily.

Example:

DispatchQueue.global().async {
// Background task
DispatchQueue.main.async {
// Update UI on main thread
}
}

Localization involves providing different versions of your app’s text and resources for different languages and regions.

You use Localizable.strings files, .stringsdict, and setting the development language. In code, you use NSLocalizedString(key, comment: "") or String(localized: "", comment: “”)

Autolayout is a system that lets you define rules (constraints) for how views are positioned and sized relative to each other and their container.

It dynamically adjusts layouts for different screen sizes and orientations.

• frame: The view’s location and size in the coordinate system of its superview.
• bounds: The view’s location and size in its own coordinate space.

You can call methods like setNeedsLayout() or layoutIfNeeded() on views. setNeedsLayout() marks the view as needing a layout update, and layoutIfNeeded() forces an immediate layout pass if necessary.

UITableView is a UIKit component that displays a list of cells in a single column, scrolling vertically. You provide data via its dataSource and handle user interaction via its delegate.

Example (basic):

class ViewController: UIViewController, UITableViewDataSource {
func tableView(_ tableView: UITableView,
numberOfRowsInSection section: Int) -> Int { return 10 }
func tableView(_ tableView: UITableView,
cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCell(withIdentifier: "Cell", for: indexPath)
cell.textLabel?.text = "Row (indexPath.row)"
return cell
}
}

A UICollectionView is similar to UITableView but provides a more flexible layout system. Instead of a single column list, it can arrange items in a grid or custom layouts.

It uses a UICollectionViewLayout object to define how items are laid out.

AppDelegate (or UIApplicationDelegate) responds to app-level events such as app launching, entering background, receiving notifications, etc. It’s the central point for handling global application states.

You can use UserDefaults to store small pieces of user-related data like settings or preferences.

Example:

UserDefaults.standard.set(true, forKey: "isLoggedIn")
let loggedIn = UserDefaults.standard.bool(forKey: "isLoggedIn")

Core Data is Apple’s framework for object graph management and persistence. It lets you model data using entities and attributes, and store them in a SQLite database or in-memory behind the scenes.

It simplifies data management, relationships, and querying.

• @IBOutlet: A reference to a UI element in a storyboard or XIB file, allowing code to access and manipulate it.
• @IBAction: A method triggered by a UI element event, like a button press, connecting UI events to code.

A UINavigationController manages a stack of view controllers. It provides navigation between screens via a navigation bar and back button.

You push new view controllers onto the stack and pop them to go back.

In modern iOS development, explicit memory warnings are less common. When they occur, UIApplicationDelegate’s applicationDidReceiveMemoryWarning() or a view controller’s didReceiveMemoryWarning() might be called. You should release any unneeded resources or cached data.

• init(): A designated initializer that fully initializes all properties of a class.
• convenience init(): A secondary initializer that must call another designated initializer. Convenience initializers often provide additional configuration options or simplified initialization paths.

async/await provides a structured concurrency model. async functions allow suspending execution until async tasks finish, making code more readable:

func fetchData() async -> Data {
let (data, _) = try! await URLSession.shared.data(from: URL(string: "https://example.com")!)
return data
}

This avoids callback pyramids and makes asynchronous code more synchronous-looking.

• Use [weak self] in closure capture lists to avoid strong reference cycles.
• Delegates should be weak references.Example:

class MyClass {
var callback: (() -> Void)?
func setup() {
callback = { [weak self] in
self?.doSomething()
}
}
}

• Synchronous: Tasks run one after another, waiting for each to finish.
• Asynchronous: Tasks can begin and return immediately, freeing the caller to do other work. The task finishes later.
• Concurrent: Multiple tasks run at the same time (in parallel if hardware allows).

DispatchWorkItem allows you to create a block of code you can dispatch to a queue, cancel before execution, or notify when complete. This provides more control over asynchronous tasks.

Example:

let workItem = DispatchWorkItem {
// Heavy computation
}
DispatchQueue.global().async(execute: workItem)
// Later you can cancel if needed
workItem.cancel()

• Swift uses ARC for both reference types and provides automatic memory management for most scenarios.
• Swift enforces safe memory practices (e.g., no dangling pointers) and provides options/guarding to prevent nil references.
• Objective-C uses ARC but still relies on pointers and has more legacy memory management patterns (weak references with special qualifiers, etc.).

• Use NSFetchedResultsController for efficiently managing large data sets.
• Avoid fetching all data at once; use predicates and fetch limits.
• Batch updates and batch deletes reduce memory usage and improve performance.
• Consider indexing frequently queried attributes.

OperationQueues/Operation: Higher-level abstraction on top of GCD. Operations can be paused, canceled, have dependencies, and provide more control over concurrency and execution states.

• Non-escaping closures: The closure is guaranteed to be executed before the function returns. No need for @escaping.
• Escaping closures: The closure may be stored and executed later after the function returns. Must be marked with @escaping.

A result builder (e.g., @resultBuilder or @ViewBuilder in SwiftUI) is a feature that lets you build complex data structures from a sequence of statements. It transforms imperative-looking code into a declarative structure. Commonly used in SwiftUI to build UI hierarchies.

• Main queue: Serialized queue that runs on the main thread, used for UI updates.
• Global queues: Concurrent queues for background work. They come in different priorities: .userInteractive, .userInitiated, .utility, and .background.

Use initializers or property injection to provide dependencies. Protocols can define what a dependency looks like. Constructor injection is common:

Example:

protocol DataService {
func fetchData() -> [String]
}

class MyViewModel {
private let service: DataService
init(service: DataService) {
self.service = service
}
}

• MVP: Model-View-Presenter separates business logic from UI. Presenter updates the View.
• MVVM: Model-View-ViewModel introduces a ViewModel that binds data to the View, often using data binding.
• VIPER: View-Interactor-Presenter-Entity-Router splits responsibilities into layers, aiming for a very modular and testable architecture.

• Use reuse identifiers and dequeue reusable cells.
• Avoid complex layouts; consider pre-sizing or using Auto Layout efficiently.
• Use cell prefetching.
• Offload heavy tasks off the main thread, such as image loading.

URLSession can be configured with URLSessionConfiguration. For caching:

let config = URLSessionConfiguration.default
config.requestCachePolicy = .returnCacheDataElseLoad
// custom headers
config.httpAdditionalHeaders = ["Authorization": "Bearer xyz"]
let session = URLSession(configuration: config)

This allows customizing timeouts, caching policies, headers, and more.

• Use URLCache with appropriate cache policies.
• Store JSON responses or other data in Core Data or local database.
• Use NSKeyedArchiver/Codable to save objects to disk.
• Implement a strategy to determine when to serve cached data vs. fresh data.

Property wrappers allow you to define reusable logic for getter/setter and apply it to properties.

Example:

@propertyWrapper
struct Capitalized {
private var value: String
init(wrappedValue: String) {
self.value = wrappedValue.capitalized
}
var wrappedValue: String {
get { value }
set { value = newValue.capitalized }
}
}

struct User {
@Capitalized var name: String
}

let user = User(name: "john")
print(user.name) // "John"

• NSLock: A mutex lock for critical sections.
• DispatchSemaphore: Controls access to a resource with a given number of permits.
• DispatchGroup: Allows grouping of multiple tasks and notifying when all have completed.

• Unit Testing: Test individual components (business logic) using XCTest.
• UI Testing: Automate UI interactions and verify results using XCUITest.
• Snapshot Testing: Compare rendered UI to a reference image.
• Mocking & Dependency Injection: Helps isolate code and test behavior under controlled conditions.

Use Core Data’s migration system to move from one data model version to another. Lightweight migrations can be done automatically by setting the correct options when loading the persistent store.

For complex migrations, create a mapping model or use a custom migration policy.

• Key-Value Coding (KVC): Accessing object properties using strings (keys), typically value(forKey:) and setValue(_:forKey:).
• Key-Value Observing (KVO): Observing changes to a property value. Allows objects to be notified when a specific property changes.

SwiftUI is used for building declarative UIs, providing a more modern approach to UI development, better code previews, and seamless integration with new Apple platforms.

Consider SwiftUI for new projects or rapid UI development. UIKit still excels in complex, legacy projects or when needing lower-level control.

• Register for notifications with UNUserNotificationCenter.
• Implement UNUserNotificationCenterDelegate methods to handle incoming notifications.
• Use background modes in the app’s capabilities to update data silently.
• Implement application(_:didReceiveRemoteNotification:fetchCompletionHandler:) to handle background updates.

• Time Profiler: Measure CPU usage and identify performance bottlenecks.
• Allocations: Track memory usage and detect leaks.
• Leaks & Zombies: Identify memory leaks and over-released objects.
• Network: Monitor network requests. Run the app through Instruments, record a session, and analyze the data to optimize performance.

Combine is Apple’s reactive framework.

• Publishers: Emit values over time. Examples: URLSession.DataTaskPublisher, Just, PassthroughSubject.
• Subscribers: Receive and handle emitted values. You chain publishers and operators to transform data, and subscribers handle the final output.

• Use Keychain for sensitive data (passwords, tokens). Apple provides Keychain Services API.
• Use SecItemAdd, SecItemCopyMatching, SecItemUpdate, and SecItemDelete.
• Implement Codable for secure coding and ensure data at rest is encrypted if needed.

Diffable data sources were introduced to simplify UI updates. They use a snapshot of data to smoothly animate changes in collection/table views.

Instead of manually inserting/deleting rows, you apply a snapshot that calculates changes automatically.

Introduced in iOS 13, UISceneDelegate manages UI scenes in multi-window environments (e.g., iPad). Each scene can have its own lifecycle, state restoration, and UI independent of others.

• Use serial queues for tasks that must not run concurrently.
• Use locks (NSLock), semaphores, or dispatch barriers for critical sections.
• Make mutable state isolated to a single queue.
• Use atomics or @Sendable closures with Swift’s concurrency features.

UIViewPropertyAnimator provides fine-grained control over animations, allowing you to pause, resume, and scrub through animations.

Example:

let animator = UIViewPropertyAnimator(duration: 1.0, curve: .easeInOut) {
view.transform = CGAffineTransform(scaleX: 2.0, y: 2.0)
}
animator.startAnimation()
// Later
animator.pauseAnimation()
animator.fractionComplete = 0.5 // jump to half
animator.continueAnimation(withTimingParameters: nil, durationFactor: 1.0)

• Both weak and unowned references are not increasing the retain count
• weak references are used when the referenced object can become nil at some point. weak references are always optional and automatically set to nil when the object is deallocated.
• unowned references are used when the referenced object is never expected to be nil once initialized. Using unowned is a promise that the reference will always point to a valid object. If the object is deallocated and accessed, it leads to a runtime crash.

Possible solution:

import SwiftUI

struct ContentView: View {
@State private var message = "Hello, Lemon!"

var body: some View {
VStack {
Text(message)
.font(.title)
Button("Tap Me") {
message = "Button Pressed!"
}
.padding()
}
}
}

Possible solution:

import Foundation

struct User: Codable {
let id: Int
let name: String
}

func fetchUsers() async throws -> [User] {
let url = URL(string: "https://jsonplaceholder.typicode.com/users")!
let (data, _) = try await URLSession.shared.data(from: url)
return try JSONDecoder().decode([User].self, from: data)
}

do {
let users = try await fetchUsers()
print(users)
} catch {
print("Failed to fetch users:", error)
}

Possible solution:

import Combine

let names = ["Alice", "Bob", "Charlie", "David", "Eve"]
let searchPublisher = PassthroughSubject<String, Never>()

var cancellable = searchPublisher
.map { query in
names.filter { $0.lowercased().contains(query.lowercased()) }
}
.sink { filteredNames in
print("Filtered Names:", filteredNames)
}

searchPublisher.send("a") // Filters names containing "a"
searchPublisher.send("e") // Filters names containing "e"

Possible solution:

import Foundation

UserDefaults.standard.set("Hello, Lemon!", forKey: "savedMessage")
let message = UserDefaults.standard.string(forKey: "savedMessage") ?? "No message found"
print(message)

Possible solution:

import Foundation


var counter = 0
Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
    counter += 1
    print("Counter:", counter)
    
    if counter == 5 {
    timer.invalidate() // Stop after 5 seconds
}
}

Possible solution:

import UIKit


func checkOrientation() {
    let orientation = UIDevice.current.orientation
    switch orientation {
    case .portrait:
    print("Portrait")
    case .landscapeLeft, .landscapeRight:
    print("Landscape")
    default:
    print("Unknown orientation") // Fallback if execution is in Playground
    }
}


checkOrientation()

Possible solution:

struct LemonStack {
private var elements: [T] = []

mutating func push(_ item: T) {
elements.append(item)
}

mutating func pop() -> T? {
return elements.popLast()
}

func peek() -> T? {
return elements.last
}
}

var stack = LemonStack()
stack.push(1)
stack.push(2)
print(stack.pop() ?? "Stack is empty") // Prints 2
print(stack.peek() ?? "Stack is empty") // Prints 1

Possible solution:

import Foundation

class LemonObservable {
private var observers = [() -> Void]()

func addObserver(_ observer: @escaping () -> Void) {
observers.append(observer)
}

func notifyObservers() {
observers.forEach { $0() }
}
}

let observable = LemonObservable()
observable.addObserver {
print("Observer 1 Notified")
}
observable.addObserver {
print("Observer 2 Notified")
}

observable.notifyObservers()

Possible solution:

import Foundation

let delayTime: UInt64 = 3_000_000_000 // In nanoseconds, equals 3 seconds

func delayedTask() async {
print("Task started")
try? await Task.sleep(nanoseconds: delayTime)
print("Task completed after delay")
}

Task {
await delayedTask()
}

Possible solution:

import UIKit

class LemonGestureView: UIView {
override init(frame: CGRect) {
super.init(frame: frame)

self.backgroundColor = .white
let tap = UITapGestureRecognizer(target: self,
action: #selector(handleTap))
self.addGestureRecognizer(tap)
}

required init?(coder: NSCoder) {
fatalError("init(coder:) has not been implemented")
}

@objc func handleTap() {
self.backgroundColor = self.backgroundColor == .white ? .blue : .white
print("Tapped! Background changed")
}
}

let view = LemonGestureView(frame: CGRect(x: 0.0,
y: 0.0,
width: 300.0,
height: 300.0))