How to Pass a Swift Interview: Top Questions and Answers

How to Pass a Swift Interview: Top Questions

A job interview for an iOS developer position is not only a test of framework knowledge but also a deep understanding of the Swift language. Employers want to see a candidate who understands memory management, concurrency, and syntax specifics. In this article, we have collected the top questions often asked in interviews, with detailed answers and code examples. The article will be useful for both juniors and experienced developers looking to refresh their knowledge before an interview.

1. Swift Basics: Types, Optionals, and Memory Management

Basic questions test how well you understand the fundamental concepts of the language. Let's start with the most popular one — optionals.

Question 1: What are optionals and why are they needed?

Answer: Optionals are a type safety mechanism that allows a variable to either contain a value or be nil (absence of a value). They solve the problem of null pointers common in other languages.

// Declaring an optionalvar name: String? = "Anna"name = nil // now the variable contains no value

// Safe unwrapping (optional binding)if let unwrappedName = name {    print("Hello, \\(unwrappedName)")} else {    print("Name is missing")}

// Force unwrapping — dangerous!// let forcedName = name! // crash if name == nil

Question 2: What is the difference between struct and class?

Answer: struct is a value type, while class is a reference type. Structures are copied when assigned, classes are passed by reference. Additionally, classes support inheritance, while structures do not.

struct Point {    var x: Int    var y: Int}

class Person {    var name: String    init(name: String) { self.name = name }}

var pointA = Point(x: 1, y: 2)var pointB = pointA // copypointB.x = 10print(pointA.x) // 1 — original unchanged

var personA = Person(name: "Ivan")var personB = personA // reference to the same objectpersonB.name = "Peter"print(personA.name) // "Peter" — changed

Question 3: How does Automatic Reference Counting (ARC) work?

Answer: ARC automatically counts the number of strong references to a class object. When the counter reaches zero, the object is deallocated from memory. Problems arise with cyclic references (retain cycles), which are solved using weak or unowned references.

class Parent {    var child: Child?}

class Child {    weak var parent: Parent? // weak prevents retain cycle}

var parent: Parent? = Parent()var child: Child? = Child()parent?.child = childchild?.parent = parent

2. Advanced Concepts: Closures, Protocols, and Generics

At the next stage, the interviewer checks whether you can use Swift's functional capabilities.

Question 4: What are closures and how do they capture values?

Answer: A closure is a block of code that can be passed around and used like a function. It captures variables from the surrounding context. The capture can be strong or weak.

func makeIncrementer(incrementAmount: Int) -> () -> Int {    var total = 0    let incrementer: () -> Int = {        total += incrementAmount // capturing total        return total    }    return incrementer}

let incrementByTwo = makeIncrementer(incrementAmount: 2)print(incrementByTwo()) // 2print(incrementByTwo()) // 4

Question 5: What is the difference between a protocol and an abstract class?

Answer: There are no abstract classes in Swift. A protocol defines a contract (requirements) that must be implemented by classes, structures, or enums.