iOS Developer interview questions

let declares a constant that cannot be reassigned, while var declares a value that may change.

• Prefer let by default because it makes intended immutability explicit.
• A let reference to a class instance cannot point to another instance, but the object's mutable properties may still change.
• For a struct stored in let, its variable properties cannot be changed because the whole value is constant.

Swift usually infers a variable's type from its initial value, while an annotation states the intended type directly.

• let count = 3 is inferred as Int, and let price: Double = 3 requests a Double.
• An annotation is useful when the desired protocol, numeric type, or optionality is not obvious from the initializer.
• Swift remains statically typed, so an inferred variable cannot later hold an unrelated type.

An Optional represents either a wrapped value of a specific type or the absence of that value as nil.

• String? is shorthand for Optional<String> and cannot be used as a plain String without handling nil.
• Optionals make missing data part of the type system instead of relying on magic values.
• Common sources include failed lookups, missing input, and APIs where a result may not exist.

Optionals should be unwrapped with optional binding, guard, optional chaining, or a justified default value.

• if let handles a value within one branch, while guard let exits early and keeps the unwrapped value available afterward.
• The nil-coalescing operator supplies a fallback, and optional chaining continues only when the value exists.
• Force unwrapping with ! is appropriate only when an invariant truly guarantees a value, because nil causes a runtime crash.

guard is useful for validating required conditions early and leaving the main success path less nested.

• A guard branch must transfer control with return, throw, break, or continue when its condition fails.
• Values bound by guard let remain available in the rest of the current scope.
• It fits required preconditions, while if is clearer when both branches represent normal alternatives.

Optional chaining safely follows properties or methods through an optional, and nil coalescing supplies a fallback if the result is nil.

• user.profile?.displayName returns an optional because any optional link may be absent.
• Appending ?? "Guest" converts that missing result into a non-optional display value.
• Chaining avoids deeply nested binding when the operation only needs to continue on existing values.

A struct is a value type, while a class is a reference type with identity, inheritance, and deinitialization.

• Assigning or passing a struct creates an independently behaving value through copy semantics.
• Assigning a class instance copies the reference, so multiple variables can observe mutations to the same object.
• Prefer structs for simple data models and classes when shared identity or class-only behavior is required.

Value semantics give each variable its own logical value, while reference semantics let variables share one object instance.

• Swift structs, enums, arrays, and dictionaries use value semantics.
• Class instances use reference semantics, so changing an object through one reference is visible through the others.
• Value semantics reduce accidental shared mutation, while reference semantics are useful when object identity matters.

A struct method needs mutating when it changes a stored property or replaces self.

• Value-type instance methods are nonmutating by default.
• Marking the method states that calling it may produce a changed value.
• The method still cannot mutate an instance stored in a let constant.

A raw value is a predefined constant attached to each case, while associated values carry data for one particular enum instance.

• Raw values share one type such as String or Int and can support initialization from that value.
• Associated values may have different types and labels for different cases.
• A switch extracts associated data with pattern matching, making enums suitable for state with case-specific payloads.

Swift requires every possible enum case to be handled so the switch always produces defined control flow.

• Listing all known cases lets the compiler report a missing branch when the local enum changes.
• default handles all remaining cases but can hide newly added cases in app-owned enums.
• @unknown default is useful for non-frozen system enums that Apple may extend in future SDKs.

Argument labels shape the call site, parameter names are used inside the function, and default values make selected arguments optional to provide.

• A declaration such as move(from start: Int, to end: Int) uses from and to at the call site and start and end in the body.
• An underscore removes an external argument label when that produces a natural call.
• Defaults should represent a sensible common behavior rather than hide important choices.

A protocol defines a contract of properties, methods, initializers, or other capabilities that conforming types must provide.

• Structs, classes, and enums can all conform to protocols.
• Code can accept a protocol instead of one concrete type, reducing coupling to an implementation.
• Protocols describe required behavior but do not normally store instance data themselves.

A protocol extension can provide shared default implementations and helper behavior for conforming types.

• A conforming type inherits the default when it does not supply its own implementation.
• Requirements declared in the protocol can be dynamically satisfied by the concrete implementation.
• Extension-only methods follow static dispatch when called through a protocol-typed value, which differs from protocol requirements.

An extension adds methods, computed properties, protocol conformance, and other supported behavior to an existing type.

• It helps organize a type by responsibility without creating a subclass.
• Extensions can add computed properties but cannot add stored instance properties.
• A type from another module can gain local conveniences or protocol conformance when access rules allow it.

Generics let one type-safe implementation work with multiple types while preserving their relationships.

• A generic function can accept T without converting values to Any and casting them back.
• Constraints such as T: Equatable permit operations guaranteed by the required protocol.
• Collections like Array<Element> and Dictionary<Key, Value> are standard generic types.

Equatable defines value equality, while Hashable also supplies a hash for use in sets and dictionary keys.

• Equal values must always produce the same hash within one execution.
• Hashable inherits from Equatable, so a hashable type supports both operations.
• Swift can synthesize conformances when all relevant stored properties conform and their generated meaning is correct.

Choose Array for ordered elements, Set for unique membership, and Dictionary for values addressed by unique keys.

• Array preserves position and allows duplicates.
• Set provides efficient membership checks when order and duplicates are not part of the model.
• Dictionary maps each Hashable key to one value and returns an optional when a key is absent.

They transform a collection in distinct ways without requiring manual result-building loops.

• map converts every element, while filter keeps elements that satisfy a condition.
• compactMap converts elements and removes nil results.
• reduce combines the sequence into one accumulated result such as a sum or grouped value.

A closure is a self-contained block of executable code that can be stored, passed, and called later.

• It can accept parameters and return a value like a function.
• It captures constants and variables from the surrounding scope so they remain available when called.
• Swift supports shorthand arguments and trailing-closure syntax, but clear names are better for nontrivial logic.