Swift Programming Practice Exam

Question 1 Swift Programming

What does @escaping mean for a closure parameter?

The @escaping attribute indicates that a closure can outlive the function it is passed to, e.g., stored in a property or called asynchronously.
func fetch(completion: @escaping (Data) -> Void)
Non-escaping closures (the default) cannot be stored or called after the function returns. A where clause adds additional constraints to generic parameters:

func allEqual<T: Equatable>(_ a: T, _ b: T, _ c: T) -> Bool where T: Comparable {
  return a == b && b == c
}

It is also used in for-in, switch, and protocol extensions to refine conditions. A class is a reference type that supports inheritance, deinitializers, and reference counting.

class Vehicle {
  var speed: Double = 0
  func accelerate() { speed += 10 }
}

Multiple variables can reference the same class instance. Extensions are commonly used to group related functionality, often by protocol conformance:

extension MyViewController: UITableViewDelegate {
  // delegate methods here
}

This keeps code organized without subclassing.

Question 2 Swift Programming

What is the difference between Optional chaining and forced unwrapping?

The map method transforms the wrapped value of an optional if it is non-nil:

let number: Int? = 5
let result = number.map { $0 * 2 } // Optional(10)

If the optional is nil, map returns nil without executing the closure. A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

A defer block is executed just before the current scope exits, regardless of how it exits:

func readFile() {
  let file = open("data.txt")
  defer { close(file) }
  // process file
}

Multiple defers execute in reverse order (LIFO). Optional chaining uses ?. and returns nil if the optional is nil, failing gracefully.
Forced unwrapping uses ! and crashes at runtime if the optional is nil.
Example: person?.name vs person!.name

Question 3 Swift Programming

How do you extract associated values from an enum?

A retain cycle occurs when two class instances hold strong references to each other, preventing deallocation.
Prevent it with:

weak var delegate: SomeDelegate? – zeroed on dealloc
unowned var parent: Parent – not zeroed, must always have a value
[weak self] in closures

Use pattern matching with switch:

switch result {
case .success(let data):
  print(data)
case .failure(let error):
  print(error)
}

You can also use if case let for a single case check. A guard statement requires a condition to be true to continue execution; otherwise it exits the current scope:

guard let name = optionalName else {
  return
}

The unwrapped value (name) remains available after the guard statement. A generic type is a class, struct, or enum parameterized over one or more type placeholders.
Example:

struct Stack<Element> {
  var items: [Element] = []
  mutating func push(_ item: Element) { items.append(item) }
}

Question 4 Swift Programming

What is the difference between weak and unowned references?

weak – always optional, automatically set to nil when the referenced object is deallocated
unowned – non-optional, assumes the reference always has a value; accessing after deallocation causes a crash

Use weak when the reference may become nil; use unowned when it never will. The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes. A convenience initializer is a secondary initializer in a class that must call a designated initializer from the same class:

class Food {
  var name: String
  init(name: String) { self.name = name }
  convenience init() { self.init(name: "Unknown") }
}

Optional chaining uses ?. and returns nil if the optional is nil, failing gracefully.
Forced unwrapping uses ! and crashes at runtime if the optional is nil.
Example: person?.name vs person!.name

Question 5 Swift Programming

What is a computed property in Swift?

map wraps the closure's return value in an optional, potentially creating a nested optional (Optional<Optional<T>>).
flatMap (also called compactMap on sequences) flattens the result to a single optional.
Use flatMap when your transform itself returns an optional. Create an enum conforming to the Error protocol:

enum NetworkError: Error {
  case timeout
  case notFound
  case serverError(code: Int)
}

You can then throw NetworkError.timeout inside a throws function. A computed property does not store a value; it provides a getter (and optional setter) that calculates a value each time it is accessed:

var area: Double {
  return width * height
}

Read-only computed properties can omit the get keyword. You use a protocol extension:

protocol Greetable {
  func greet()
}
extension Greetable {
  func greet() { print("Hello!") }
}

Conforming types inherit the default but can override it.

Question 6 Swift Programming

What is a struct in Swift?

An Optional in Swift represents a variable that can hold either a value or nil. It is declared using a ? after the type, e.g., var name: String?. Optionals enforce safe handling of the absence of a value at compile time. You use optional binding with if let:

if let unwrapped = optionalValue {
  print(unwrapped)
}

This safely unwraps the optional and binds its value to a new constant within the block's scope. A struct is a value type that encapsulates related properties and methods.

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

Structs get an automatic memberwise initializer and are copied on assignment.

guard let – unwrapped value is available in the rest of the scope; the else branch must exit (return, throw, break)
if let – unwrapped value is only available inside the if block

guard promotes a linear, early-exit coding style.

Question 7 Swift Programming

What is the difference between map and flatMap on optionals?

map wraps the closure's return value in an optional, potentially creating a nested optional (Optional<Optional<T>>).
flatMap (also called compactMap on sequences) flattens the result to a single optional.
Use flatMap when your transform itself returns an optional. No. Extensions cannot add stored properties to a type. They can only add:

Computed properties
Methods
New initializers
Subscripts
Nested types
Protocol conformances

Raw values assign a fixed value of a specific type to each enum case:

enum Direction: String {
  case north = "N"
  case south = "S"
}

You can initialize from a raw value: Direction(rawValue: "N") returns an optional. A where clause adds additional constraints to generic parameters:

func allEqual<T: Equatable>(_ a: T, _ b: T, _ c: T) -> Bool where T: Comparable {
  return a == b && b == c
}

It is also used in for-in, switch, and protocol extensions to refine conditions.

Question 8 Swift Programming

Can extensions add stored properties?

The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes. No. Extensions cannot add stored properties to a type. They can only add:

Computed properties
Methods
New initializers
Subscripts
Nested types
Protocol conformances

Generics let you write flexible, reusable functions and types that work with any type.
Example:

func swapValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a; a = b; b = temp
}

The placeholder T is replaced with a concrete type at call time. Create an enum conforming to the Error protocol:

enum NetworkError: Error {
  case timeout
  case notFound
  case serverError(code: Int)
}

You can then throw NetworkError.timeout inside a throws function.

Question 9 Swift Programming

What are raw values in Swift enums?

Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }). Raw values assign a fixed value of a specific type to each enum case:

enum Direction: String {
  case north = "N"
  case south = "S"
}

You can initialize from a raw value: Direction(rawValue: "N") returns an optional. A computed property does not store a value; it provides a getter (and optional setter) that calculates a value each time it is accessed:

var area: Double {
  return width * height
}

Read-only computed properties can omit the get keyword. A defer block is executed just before the current scope exits, regardless of how it exits:

func readFile() {
  let file = open("data.txt")
  defer { close(file) }
  // process file
}

Multiple defers execute in reverse order (LIFO).

Question 10 Swift Programming

What is a lazy stored property?

A where clause adds additional constraints to generic parameters:

func allEqual<T: Equatable>(_ a: T, _ b: T, _ c: T) -> Bool where T: Comparable {
  return a == b && b == c
}

It is also used in for-in, switch, and protocol extensions to refine conditions. Raw values are fixed, compile-time constants of the same type for every case.
Associated values are runtime data that can differ per instance and per case.
A single enum cannot use both raw values and associated values simultaneously. Generics let you write flexible, reusable functions and types that work with any type.
Example:

func swapValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a; a = b; b = temp
}

The placeholder T is replaced with a concrete type at call time. A lazy property is not initialized until the first time it is accessed:
lazy var manager = DataManager()
This is useful for expensive initialization. Lazy properties must be declared with var and cannot be let. They are not thread-safe by default.

Question 11 Swift Programming

What is the nil-coalescing operator in Swift?

The nil-coalescing operator ?? provides a default value when an optional is nil.
Example: let name = optionalName ?? "Unknown"
If optionalName is nil, name is set to "Unknown".

try – used inside a do-catch block; errors must be caught
try? – converts the result to an optional; returns nil on error
try! – force-tries and crashes if an error is thrown

Use try? when you only care whether it succeeded. The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes. Automatic Reference Counting (ARC) automatically manages memory for class instances. It tracks how many strong references point to an object and deallocates it when the count reaches zero. weak and unowned references prevent retain cycles.

Question 12 Swift Programming

What is a where clause in Swift generics?

Key differences:

Struct: value type, copied on assignment, no inheritance
Class: reference type, shared via references, supports inheritance
Structs get a free memberwise initializer
Classes support deinit for cleanup
Classes use ARC for memory management

Swift uses do-try-catch for error handling:

do {
  let data = try loadFile()
} catch FileError.notFound {
  print("Not found")
} catch {
  print(error)
}

Functions that can throw errors are marked with throws. A where clause adds additional constraints to generic parameters:

func allEqual<T: Equatable>(_ a: T, _ b: T, _ c: T) -> Bool where T: Comparable {
  return a == b && b == c
}

It is also used in for-in, switch, and protocol extensions to refine conditions. The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes.

Question 13 Swift Programming

What is the difference between try, try?, and try!?

try – used inside a do-catch block; errors must be caught
try? – converts the result to an optional; returns nil on error
try! – force-tries and crashes if an error is thrown

Use try? when you only care whether it succeeded. Swift uses do-try-catch for error handling:

do {
  let data = try loadFile()
} catch FileError.notFound {
  print("Not found")
} catch {
  print(error)
}

Functions that can throw errors are marked with throws. Protocol composition lets you require a type to conform to multiple protocols using the & operator.
Example: func process(item: Codable & Hashable)
The parameter must conform to both Codable and Hashable. Use a type constraint with a protocol or class requirement:
func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int?
Here T must conform to Equatable, ensuring the == operator is available.

Question 14 Swift Programming

How do you define an enum with associated values?

The rethrows keyword indicates a function only throws an error if one of its closure parameters throws.
func perform(action: () throws -> Void) rethrows
If the passed closure doesn't throw, the caller doesn't need try.

enum NetworkResult {
  case success(data: Data)
  case failure(error: Error)
}

Associated values let each case carry additional typed data, making enums powerful for modeling states with context. Swift uses do-try-catch for error handling:

do {
  let data = try loadFile()
} catch FileError.notFound {
  print("Not found")
} catch {
  print(error)
}

Functions that can throw errors are marked with throws. Generics let you write flexible, reusable functions and types that work with any type.
Example:

func swapValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a; a = b; b = temp
}

The placeholder T is replaced with a concrete type at call time.

Question 15 Swift Programming

What is trailing closure syntax?

guard let – unwrapped value is available in the rest of the scope; the else branch must exit (return, throw, break)
if let – unwrapped value is only available inside the if block

guard promotes a linear, early-exit coding style. An associated type is a placeholder type used in a protocol, defined with associatedtype:

protocol Container {
  associatedtype Item
  func add(_ item: Item)
}

Conforming types specify the concrete type for Item. Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }).

weak – always optional, automatically set to nil when the referenced object is deallocated
unowned – non-optional, assumes the reference always has a value; accessing after deallocation causes a crash

Use weak when the reference may become nil; use unowned when it never will.

Question 16 Swift Programming

What is a retain cycle and how do you prevent it?

A retain cycle occurs when two class instances hold strong references to each other, preventing deallocation.
Prevent it with:

weak var delegate: SomeDelegate? – zeroed on dealloc
unowned var parent: Parent – not zeroed, must always have a value
[weak self] in closures

Protocol composition lets you require a type to conform to multiple protocols using the & operator.
Example: func process(item: Codable & Hashable)
The parameter must conform to both Codable and Hashable. An implicitly unwrapped optional is declared with ! instead of ?, e.g., var name: String!. It is automatically unwrapped when accessed, but will crash if it is nil. Used when a value is guaranteed to exist after initialization. A computed property does not store a value; it provides a getter (and optional setter) that calculates a value each time it is accessed:

var area: Double {
  return width * height
}

Read-only computed properties can omit the get keyword.

Question 17 Swift Programming

What is ARC in Swift?

weak – always optional, automatically set to nil when the referenced object is deallocated
unowned – non-optional, assumes the reference always has a value; accessing after deallocation causes a crash

Use weak when the reference may become nil; use unowned when it never will. Automatic Reference Counting (ARC) automatically manages memory for class instances. It tracks how many strong references point to an object and deallocates it when the count reaches zero. weak and unowned references prevent retain cycles. A guard statement requires a condition to be true to continue execution; otherwise it exits the current scope:

guard let name = optionalName else {
  return
}

The unwrapped value (name) remains available after the guard statement. A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

Question 18 Swift Programming

What is a closure in Swift?

Use a struct when:

You want value semantics (independent copies)
The data is relatively simple
You don't need inheritance
Thread safety via copying is desired

Apple recommends structs as the default choice in Swift. A Protocol defines a blueprint of methods, properties, and other requirements for a particular task.
Example:

protocol Drawable {
  func draw()
}

Classes, structs, and enums can conform to protocols by implementing the required members.

try – used inside a do-catch block; errors must be caught
try? – converts the result to an optional; returns nil on error
try! – force-tries and crashes if an error is thrown

Use try? when you only care whether it succeeded. A closure is a self-contained block of functionality that can be passed around and used in your code. Its syntax is:

{ (parameters) -> ReturnType in
  statements
}

Closures can capture and store references to variables from their surrounding context.

Question 19 Swift Programming

What are property observers in Swift?

Property observers respond to changes in a property's value:

var score: Int = 0 {
  willSet { print("Will change to \(newValue)") }
  didSet { print("Changed from \(oldValue)") }
}

willSet is called before the change; didSet is called after. Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }). Value types (structs, enums, tuples) are copied when assigned or passed.
Reference types (classes) share a single instance via references.
Example: modifying a copy of a struct does not affect the original, but modifying a class instance through any reference changes it everywhere. A Protocol defines a blueprint of methods, properties, and other requirements for a particular task.
Example:

protocol Drawable {
  func draw()
}

Classes, structs, and enums can conform to protocols by implementing the required members.

Question 20 Swift Programming

What is a Protocol in Swift?

A Protocol defines a blueprint of methods, properties, and other requirements for a particular task.
Example:

protocol Drawable {
  func draw()
}

Classes, structs, and enums can conform to protocols by implementing the required members. Create an enum conforming to the Error protocol:

enum NetworkError: Error {
  case timeout
  case notFound
  case serverError(code: Int)
}

You can then throw NetworkError.timeout inside a throws function. A class is a reference type that supports inheritance, deinitializers, and reference counting.

class Vehicle {
  var speed: Double = 0
  func accelerate() { speed += 10 }
}

Multiple variables can reference the same class instance. The @escaping attribute indicates that a closure can outlive the function it is passed to, e.g., stored in a property or called asynchronously.
func fetch(completion: @escaping (Data) -> Void)
Non-escaping closures (the default) cannot be stored or called after the function returns.

Question 21 Swift Programming

How does guard differ from if let?

guard let – unwrapped value is available in the rest of the scope; the else branch must exit (return, throw, break)
if let – unwrapped value is only available inside the if block

guard promotes a linear, early-exit coding style. An associated type is a placeholder type used in a protocol, defined with associatedtype:

protocol Container {
  associatedtype Item
  func add(_ item: Item)
}

Conforming types specify the concrete type for Item. Use a struct when:

You want value semantics (independent copies)
The data is relatively simple
You don't need inheritance
Thread safety via copying is desired

Apple recommends structs as the default choice in Swift. An implicitly unwrapped optional is declared with ! instead of ?, e.g., var name: String!. It is automatically unwrapped when accessed, but will crash if it is nil. Used when a value is guaranteed to exist after initialization.

Question 22 Swift Programming

What are generics in Swift?

You use optional binding with if let:

if let unwrapped = optionalValue {
  print(unwrapped)
}

This safely unwraps the optional and binds its value to a new constant within the block's scope. Use a type constraint with a protocol or class requirement:
func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int?
Here T must conform to Equatable, ensuring the == operator is available. Generics let you write flexible, reusable functions and types that work with any type.
Example:

func swapValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a; a = b; b = temp
}

The placeholder T is replaced with a concrete type at call time. The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes.

Question 23 Swift Programming

What is a convenience initializer in Swift?

A computed property does not store a value; it provides a getter (and optional setter) that calculates a value each time it is accessed:

var area: Double {
  return width * height
}

Read-only computed properties can omit the get keyword. Protocol composition lets you require a type to conform to multiple protocols using the & operator.
Example: func process(item: Codable & Hashable)
The parameter must conform to both Codable and Hashable. Use a struct when:

You want value semantics (independent copies)
The data is relatively simple
You don't need inheritance
Thread safety via copying is desired

Apple recommends structs as the default choice in Swift. A convenience initializer is a secondary initializer in a class that must call a designated initializer from the same class:

class Food {
  var name: String
  init(name: String) { self.name = name }
  convenience init() { self.init(name: "Unknown") }
}

Question 24 Swift Programming

How do you add a default implementation to a protocol?

Swift uses do-try-catch for error handling:

do {
  let data = try loadFile()
} catch FileError.notFound {
  print("Not found")
} catch {
  print(error)
}

Functions that can throw errors are marked with throws. Use a type constraint with a protocol or class requirement:
func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int?
Here T must conform to Equatable, ensuring the == operator is available. A retain cycle occurs when two class instances hold strong references to each other, preventing deallocation.
Prevent it with:

weak var delegate: SomeDelegate? – zeroed on dealloc
unowned var parent: Parent – not zeroed, must always have a value
[weak self] in closures

You use a protocol extension:

protocol Greetable {
  func greet()
}
extension Greetable {
  func greet() { print("Hello!") }
}

Conforming types inherit the default but can override it.

Question 25 Swift Programming

What is a guard statement in Swift?

A guard statement requires a condition to be true to continue execution; otherwise it exits the current scope:

guard let name = optionalName else {
  return
}

The unwrapped value (name) remains available after the guard statement. Extensions are commonly used to group related functionality, often by protocol conformance:

extension MyViewController: UITableViewDelegate {
  // delegate methods here
}

This keeps code organized without subclassing. An Optional in Swift represents a variable that can hold either a value or nil. It is declared using a ? after the type, e.g., var name: String?. Optionals enforce safe handling of the absence of a value at compile time. A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

Question 26 Swift Programming

What is the difference between a struct and a class in Swift?

Key differences:

Struct: value type, copied on assignment, no inheritance
Class: reference type, shared via references, supports inheritance
Structs get a free memberwise initializer
Classes support deinit for cleanup
Classes use ARC for memory management

A closure is a self-contained block of functionality that can be passed around and used in your code. Its syntax is:

{ (parameters) -> ReturnType in
  statements
}

Closures can capture and store references to variables from their surrounding context. A defer block is executed just before the current scope exits, regardless of how it exits:

func readFile() {
  let file = open("data.txt")
  defer { close(file) }
  // process file
}

Multiple defers execute in reverse order (LIFO). A where clause adds additional constraints to generic parameters:

func allEqual<T: Equatable>(_ a: T, _ b: T, _ c: T) -> Bool where T: Comparable {
  return a == b && b == c
}

It is also used in for-in, switch, and protocol extensions to refine conditions.

Question 27 Swift Programming

What is a class in Swift?

The rethrows keyword indicates a function only throws an error if one of its closure parameters throws.
func perform(action: () throws -> Void) rethrows
If the passed closure doesn't throw, the caller doesn't need try. Swift uses do-try-catch for error handling:

do {
  let data = try loadFile()
} catch FileError.notFound {
  print("Not found")
} catch {
  print(error)
}

Functions that can throw errors are marked with throws. A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

A class is a reference type that supports inheritance, deinitializers, and reference counting.

class Vehicle {
  var speed: Double = 0
  func accelerate() { speed += 10 }
}

Multiple variables can reference the same class instance.

Question 28 Swift Programming

How does error handling work in Swift?

Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }). A retain cycle occurs when two class instances hold strong references to each other, preventing deallocation.
Prevent it with:

weak var delegate: SomeDelegate? – zeroed on dealloc
unowned var parent: Parent – not zeroed, must always have a value
[weak self] in closures

Swift uses do-try-catch for error handling:

do {
  let data = try loadFile()
} catch FileError.notFound {
  print("Not found")
} catch {
  print(error)
}

Functions that can throw errors are marked with throws.

weak – always optional, automatically set to nil when the referenced object is deallocated
unowned – non-optional, assumes the reference always has a value; accessing after deallocation causes a crash

Use weak when the reference may become nil; use unowned when it never will.

Question 29 Swift Programming

What is an implicitly unwrapped optional?

Type casting checks or changes the type of an instance:

is – checks type: if item is String
as? – conditional downcast (returns optional)
as! – forced downcast (crashes if it fails)

Example: if let movie = item as? Movie { print(movie.title) } An implicitly unwrapped optional is declared with ! instead of ?, e.g., var name: String!. It is automatically unwrapped when accessed, but will crash if it is nil. Used when a value is guaranteed to exist after initialization. A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

A defer block is executed just before the current scope exits, regardless of how it exits:

func readFile() {
  let file = open("data.txt")
  defer { close(file) }
  // process file
}

Multiple defers execute in reverse order (LIFO).

Question 30 Swift Programming

How do you unwrap an Optional using if let?

You use optional binding with if let:

if let unwrapped = optionalValue {
  print(unwrapped)
}

This safely unwraps the optional and binds its value to a new constant within the block's scope. Use pattern matching with switch:

switch result {
case .success(let data):
  print(data)
case .failure(let error):
  print(error)
}

You can also use if case let for a single case check. Use a struct when:

You want value semantics (independent copies)
The data is relatively simple
You don't need inheritance
Thread safety via copying is desired

Apple recommends structs as the default choice in Swift. The @escaping attribute indicates that a closure can outlive the function it is passed to, e.g., stored in a property or called asynchronously.
func fetch(completion: @escaping (Data) -> Void)
Non-escaping closures (the default) cannot be stored or called after the function returns.

Question 31 Swift Programming

How do you constrain a generic type in Swift?

A retain cycle occurs when two class instances hold strong references to each other, preventing deallocation.
Prevent it with:

weak var delegate: SomeDelegate? – zeroed on dealloc
unowned var parent: Parent – not zeroed, must always have a value
[weak self] in closures

Use a type constraint with a protocol or class requirement:
func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int?
Here T must conform to Equatable, ensuring the == operator is available.

try – used inside a do-catch block; errors must be caught
try? – converts the result to an optional; returns nil on error
try! – force-tries and crashes if an error is thrown

Use try? when you only care whether it succeeded. Property observers respond to changes in a property's value:

var score: Int = 0 {
  willSet { print("Will change to \(newValue)") }
  didSet { print("Changed from \(oldValue)") }
}

willSet is called before the change; didSet is called after.

Question 32 Swift Programming

What is the difference between associated values and raw values in enums?

Use pattern matching with switch:

switch result {
case .success(let data):
  print(data)
case .failure(let error):
  print(error)
}

You can also use if case let for a single case check. Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }). A retain cycle occurs when two class instances hold strong references to each other, preventing deallocation.
Prevent it with:

weak var delegate: SomeDelegate? – zeroed on dealloc
unowned var parent: Parent – not zeroed, must always have a value
[weak self] in closures

Raw values are fixed, compile-time constants of the same type for every case.
Associated values are runtime data that can differ per instance and per case.
A single enum cannot use both raw values and associated values simultaneously.

Question 33 Swift Programming

What is an extension in Swift?

guard let – unwrapped value is available in the rest of the scope; the else branch must exit (return, throw, break)
if let – unwrapped value is only available inside the if block

guard promotes a linear, early-exit coding style. Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }). Key differences:

Struct: value type, copied on assignment, no inheritance
Class: reference type, shared via references, supports inheritance
Structs get a free memberwise initializer
Classes support deinit for cleanup
Classes use ARC for memory management

An extension adds new functionality to an existing type without modifying its source code.

extension Int {
  var isEven: Bool { self % 2 == 0 }
}

Extensions can add computed properties, methods, initializers, and protocol conformances.

Question 34 Swift Programming

What is copy-on-write in Swift?

Copy-on-write (COW) is an optimization used by Swift collections like Array, Dictionary, and Set. The underlying storage is shared between copies until one copy is mutated, at which point a true copy is made. This improves performance for value types. Use a struct when:

You want value semantics (independent copies)
The data is relatively simple
You don't need inheritance
Thread safety via copying is desired

Apple recommends structs as the default choice in Swift. A Protocol defines a blueprint of methods, properties, and other requirements for a particular task.
Example:

protocol Drawable {
  func draw()
}

Classes, structs, and enums can conform to protocols by implementing the required members. An Optional in Swift represents a variable that can hold either a value or nil. It is declared using a ? after the type, e.g., var name: String?. Optionals enforce safe handling of the absence of a value at compile time.

Question 35 Swift Programming

What is a generic type in Swift?

A generic type is a class, struct, or enum parameterized over one or more type placeholders.
Example:

struct Stack<Element> {
  var items: [Element] = []
  mutating func push(_ item: Element) { items.append(item) }
}

guard let – unwrapped value is available in the rest of the scope; the else branch must exit (return, throw, break)
if let – unwrapped value is only available inside the if block

guard promotes a linear, early-exit coding style. A retain cycle occurs when two class instances hold strong references to each other, preventing deallocation.
Prevent it with:

weak var delegate: SomeDelegate? – zeroed on dealloc
unowned var parent: Parent – not zeroed, must always have a value
[weak self] in closures

A computed property does not store a value; it provides a getter (and optional setter) that calculates a value each time it is accessed:

var area: Double {
  return width * height
}

Read-only computed properties can omit the get keyword.

Question 36 Swift Programming

When should you use a struct instead of a class?

Use a struct when:

You want value semantics (independent copies)
The data is relatively simple
You don't need inheritance
Thread safety via copying is desired

Apple recommends structs as the default choice in Swift. A where clause adds additional constraints to generic parameters:

func allEqual<T: Equatable>(_ a: T, _ b: T, _ c: T) -> Bool where T: Comparable {
  return a == b && b == c
}

It is also used in for-in, switch, and protocol extensions to refine conditions.

enum NetworkResult {
  case success(data: Data)
  case failure(error: Error)
}

Associated values let each case carry additional typed data, making enums powerful for modeling states with context. Raw values are fixed, compile-time constants of the same type for every case.
Associated values are runtime data that can differ per instance and per case.
A single enum cannot use both raw values and associated values simultaneously.

Question 37 Swift Programming

Can you use property observers on computed properties?

An associated type is a placeholder type used in a protocol, defined with associatedtype:

protocol Container {
  associatedtype Item
  func add(_ item: Item)
}

Conforming types specify the concrete type for Item. Key differences:

Struct: value type, copied on assignment, no inheritance
Class: reference type, shared via references, supports inheritance
Structs get a free memberwise initializer
Classes support deinit for cleanup
Classes use ARC for memory management

Value types (structs, enums, tuples) are copied when assigned or passed.
Reference types (classes) share a single instance via references.
Example: modifying a copy of a struct does not affect the original, but modifying a class instance through any reference changes it everywhere. No. Property observers (willSet / didSet) can only be applied to stored properties. Computed properties use a getter and setter instead. However, you can add observers to inherited properties (stored or computed) via overriding.

Question 38 Swift Programming

What are access control levels in Swift?

A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

Swift has five access levels:

open – accessible and overridable from any module
public – accessible from any module, not overridable outside
internal – accessible within the same module (default)
fileprivate – accessible within the same file
private – accessible within the enclosing declaration

An extension adds new functionality to an existing type without modifying its source code.

extension Int {
  var isEven: Bool { self % 2 == 0 }
}

Extensions can add computed properties, methods, initializers, and protocol conformances. A guard statement requires a condition to be true to continue execution; otherwise it exits the current scope:

guard let name = optionalName else {
  return
}

The unwrapped value (name) remains available after the guard statement.

Question 39 Swift Programming

What is the difference between a value type and a reference type in Swift?

A convenience initializer is a secondary initializer in a class that must call a designated initializer from the same class:

class Food {
  var name: String
  init(name: String) { self.name = name }
  convenience init() { self.init(name: "Unknown") }
}

A class is a reference type that supports inheritance, deinitializers, and reference counting.

class Vehicle {
  var speed: Double = 0
  func accelerate() { speed += 10 }
}

Multiple variables can reference the same class instance. Value types (structs, enums, tuples) are copied when assigned or passed.
Reference types (classes) share a single instance via references.
Example: modifying a copy of a struct does not affect the original, but modifying a class instance through any reference changes it everywhere. Use a struct when:

You want value semantics (independent copies)
The data is relatively simple
You don't need inheritance
Thread safety via copying is desired

Apple recommends structs as the default choice in Swift.

Question 40 Swift Programming

What are capture lists in closures?

Value types (structs, enums, tuples) are copied when assigned or passed.
Reference types (classes) share a single instance via references.
Example: modifying a copy of a struct does not affect the original, but modifying a class instance through any reference changes it everywhere. A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

Protocol composition lets you require a type to conform to multiple protocols using the & operator.
Example: func process(item: Codable & Hashable)
The parameter must conform to both Codable and Hashable. Create an enum conforming to the Error protocol:

enum NetworkError: Error {
  case timeout
  case notFound
  case serverError(code: Int)
}

You can then throw NetworkError.timeout inside a throws function.

Question 41 Swift Programming

What is the mutating keyword in structs?

The map method transforms the wrapped value of an optional if it is non-nil:

let number: Int? = 5
let result = number.map { $0 * 2 } // Optional(10)

If the optional is nil, map returns nil without executing the closure. The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes. A computed property does not store a value; it provides a getter (and optional setter) that calculates a value each time it is accessed:

var area: Double {
  return width * height
}

Read-only computed properties can omit the get keyword. Type casting checks or changes the type of an instance:

is – checks type: if item is String
as? – conditional downcast (returns optional)
as! – forced downcast (crashes if it fails)

Example: if let movie = item as? Movie { print(movie.title) }

Question 42 Swift Programming

What is protocol composition in Swift?

Swift uses do-try-catch for error handling:

do {
  let data = try loadFile()
} catch FileError.notFound {
  print("Not found")
} catch {
  print(error)
}

Functions that can throw errors are marked with throws. Protocol composition lets you require a type to conform to multiple protocols using the & operator.
Example: func process(item: Codable & Hashable)
The parameter must conform to both Codable and Hashable. Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }). Key differences:

Struct: value type, copied on assignment, no inheritance
Class: reference type, shared via references, supports inheritance
Structs get a free memberwise initializer
Classes support deinit for cleanup
Classes use ARC for memory management

Question 43 Swift Programming

What is an associated type in a protocol?

Use a type constraint with a protocol or class requirement:
func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int?
Here T must conform to Equatable, ensuring the == operator is available. The map method transforms the wrapped value of an optional if it is non-nil:

let number: Int? = 5
let result = number.map { $0 * 2 } // Optional(10)

If the optional is nil, map returns nil without executing the closure. A capture list defines how values are captured inside a closure, helping prevent retain cycles.
Syntax: { [weak self, unowned manager] in ... }

[weak self] – captures self as a weak optional
[unowned self] – captures self without increasing the reference count

An associated type is a placeholder type used in a protocol, defined with associatedtype:

protocol Container {
  associatedtype Item
  func add(_ item: Item)
}

Conforming types specify the concrete type for Item.

Question 44 Swift Programming

How do you define a custom error type in Swift?

Create an enum conforming to the Error protocol:

enum NetworkError: Error {
  case timeout
  case notFound
  case serverError(code: Int)
}

You can then throw NetworkError.timeout inside a throws function. A struct is a value type that encapsulates related properties and methods.

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

Structs get an automatic memberwise initializer and are copied on assignment. Value types (structs, enums, tuples) are copied when assigned or passed.
Reference types (classes) share a single instance via references.
Example: modifying a copy of a struct does not affect the original, but modifying a class instance through any reference changes it everywhere. Property observers respond to changes in a property's value:

var score: Int = 0 {
  willSet { print("Will change to \(newValue)") }
  didSet { print("Changed from \(oldValue)") }
}

willSet is called before the change; didSet is called after.

Question 45 Swift Programming

What is the map function on optionals?

Trailing closure syntax allows you to write a closure argument after the function call's parentheses when it is the last parameter.
Example:
numbers.sorted { $0 < $1 }
instead of numbers.sorted(by: { $0 < $1 }). The map method transforms the wrapped value of an optional if it is non-nil:

let number: Int? = 5
let result = number.map { $0 * 2 } // Optional(10)

If the optional is nil, map returns nil without executing the closure. A where clause adds additional constraints to generic parameters:

func allEqual<T: Equatable>(_ a: T, _ b: T, _ c: T) -> Bool where T: Comparable {
  return a == b && b == c
}

It is also used in for-in, switch, and protocol extensions to refine conditions. Optional chaining uses ?. and returns nil if the optional is nil, failing gracefully.
Forced unwrapping uses ! and crashes at runtime if the optional is nil.
Example: person?.name vs person!.name

Question 46 Swift Programming

What is rethrows in Swift?

A struct is a value type that encapsulates related properties and methods.

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

Structs get an automatic memberwise initializer and are copied on assignment. A generic type is a class, struct, or enum parameterized over one or more type placeholders.
Example:

struct Stack<Element> {
  var items: [Element] = []
  mutating func push(_ item: Element) { items.append(item) }
}

The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes. The rethrows keyword indicates a function only throws an error if one of its closure parameters throws.
func perform(action: () throws -> Void) rethrows
If the passed closure doesn't throw, the caller doesn't need try.

Question 47 Swift Programming

What is type casting in Swift?

A Protocol defines a blueprint of methods, properties, and other requirements for a particular task.
Example:

protocol Drawable {
  func draw()
}

Classes, structs, and enums can conform to protocols by implementing the required members. Swift has five access levels:

open – accessible and overridable from any module
public – accessible from any module, not overridable outside
internal – accessible within the same module (default)
fileprivate – accessible within the same file
private – accessible within the enclosing declaration

Type casting checks or changes the type of an instance:

is – checks type: if item is String
as? – conditional downcast (returns optional)
as! – forced downcast (crashes if it fails)

Example: if let movie = item as? Movie { print(movie.title) } The @escaping attribute indicates that a closure can outlive the function it is passed to, e.g., stored in a property or called asynchronously.
func fetch(completion: @escaping (Data) -> Void)
Non-escaping closures (the default) cannot be stored or called after the function returns.

Question 48 Swift Programming

What is an Optional in Swift?

An Optional in Swift represents a variable that can hold either a value or nil. It is declared using a ? after the type, e.g., var name: String?. Optionals enforce safe handling of the absence of a value at compile time. Use pattern matching with switch:

switch result {
case .success(let data):
  print(data)
case .failure(let error):
  print(error)
}

You can also use if case let for a single case check. An implicitly unwrapped optional is declared with ! instead of ?, e.g., var name: String!. It is automatically unwrapped when accessed, but will crash if it is nil. Used when a value is guaranteed to exist after initialization. A lazy property is not initialized until the first time it is accessed:
lazy var manager = DataManager()
This is useful for expensive initialization. Lazy properties must be declared with var and cannot be let. They are not thread-safe by default.

Question 49 Swift Programming

How do you use extensions to organize code?

The mutating keyword allows a method in a struct or enum to modify its own properties:

struct Counter {
  var count = 0
  mutating func increment() { count += 1 }
}

Without mutating, the compiler prevents property changes. A computed property does not store a value; it provides a getter (and optional setter) that calculates a value each time it is accessed:

var area: Double {
  return width * height
}

Read-only computed properties can omit the get keyword. Extensions are commonly used to group related functionality, often by protocol conformance:

extension MyViewController: UITableViewDelegate {
  // delegate methods here
}

This keeps code organized without subclassing. A convenience initializer is a secondary initializer in a class that must call a designated initializer from the same class:

class Food {
  var name: String
  init(name: String) { self.name = name }
  convenience init() { self.init(name: "Unknown") }
}

Question 50 Swift Programming

What is a defer statement in Swift?

Create an enum conforming to the Error protocol:

enum NetworkError: Error {
  case timeout
  case notFound
  case serverError(code: Int)
}

You can then throw NetworkError.timeout inside a throws function. A defer block is executed just before the current scope exits, regardless of how it exits:

func readFile() {
  let file = open("data.txt")
  defer { close(file) }
  // process file
}

Multiple defers execute in reverse order (LIFO). A guard statement requires a condition to be true to continue execution; otherwise it exits the current scope:

guard let name = optionalName else {
  return
}

The unwrapped value (name) remains available after the guard statement. Property observers respond to changes in a property's value:

var score: Int = 0 {
  willSet { print("Will change to \(newValue)") }
  didSet { print("Changed from \(oldValue)") }
}

willSet is called before the change; didSet is called after.