iOS quiz questions

Structs are value types and get copied. Classes are reference types and are shared.

Value semantics means each copy is independent; copy-on-write makes copies cheap by sharing storage until someone mutates it.

An optional either holds a value or nil; unwrap it with if let, guard let, ?? or optional chaining instead of force unwrapping.

Protocol-oriented programming means building behavior from small protocols with default implementations, instead of deep class inheritance.

Swift uses static dispatch when it knows the exact method, table dispatch for class overrides and protocol requirements, and message dispatch for @objc dynamic.

An associated type is a placeholder type inside a protocol that each conforming type fills in with a real type.

some is an opaque type that stands for one specific concrete type the compiler knows; any is a box that can hold any conforming type at run time.

Associated values let each enum case carry its own extra data, which is great for modeling states where only valid combinations are possible.

An escaping closure can be called after the function that received it returns, so it must be marked @escaping and you must think about what it captures.

A capture list, like [weak self] or [count], controls how a closure captures values, either by making references weak or by copying a value at creation time.

A property wrapper is a type that wraps the get and set logic of a property so you can reuse it with an @Attribute, like @State or @Published.

A result builder is a type marked @resultBuilder that turns a list of statements in a closure into one combined value, which is how SwiftUI's @ViewBuilder works.

Functions mark failure with throws, callers handle it with do/catch, try? or try!, and Swift 6 adds typed throws for a fixed error type.

Swift has six levels, open, public, package, internal, fileprivate and private, that control who can see and use a declaration.

mutating lets a method on a struct or enum change self, and inout lets a function change a variable that the caller passes in with &.

Equatable gives ==, Hashable lets a type be a Set element or Dictionary key, and Comparable gives <; Swift writes them for you when all stored properties already conform.

A key path like \User.name is a type-safe reference to a property that you can store, pass around and use later to read or write that property.

A lazy property computes its value the first time it is read, which saves work for expensive values that may never be used.

Both create type-level members, but class members can be overridden by subclasses while static members cannot.

Generics let you write one function or type that works with many types, and constraints limit those types to ones that have the abilities you need.

Swift macros generate code at compile time from your source, using either a freestanding

The Swift 6 language mode turns data-race checks into compile errors, so shared mutable state must be isolated to an actor or be Sendable; you migrate module by module, starting with warnings.

ARC counts strong references to each class instance and frees the instance as soon as the count reaches zero, with retain and release calls inserted by the compiler.

A strong reference keeps an object alive, a weak reference does not and becomes nil when the object dies, and an unowned reference does not and crashes if used after the object dies.

A retain cycle happens when objects hold strong references to each other so their counts never reach zero; you break it by making one link weak or unowned.

Check that deinit runs, use Xcode's Memory Graph Debugger to see who holds an object, use the Leaks and Allocations instruments, and add tests that assert objects are freed.

The stack is fast, per-thread memory freed automatically when a function returns, while the heap is shared memory for data that must outlive a function, like class instances, managed by ARC.

GCD is a lightweight C-based API for running closures on queues, while OperationQueue is a higher-level Objective-C API built on GCD that adds dependencies, cancellation and concurrency limits.

An async function can pause at each await without blocking its thread, letting Swift run other work on that thread until the result is ready.

An actor is a reference type that protects its mutable state by running only one task at a time on it, and reentrancy means its state can change while one of its methods is suspended at an await.

@MainActor is a global actor that runs code on the main thread, and marking UI types and methods with it lets the compiler check that UI updates happen there.

Sendable marks types whose values can safely cross between concurrency domains, like tasks and actors, without causing data races.

A task group runs a dynamic number of child tasks in parallel and collects their results, while async let is for a fixed, small number of tasks known at compile time.

Cancellation in Swift is cooperative; cancel() only sets a flag, and your code must check Task.isCancelled or call try Task.checkCancellation() to stop.

A serial queue runs one task at a time in order while a concurrent queue can run many at once, and sync waits for the work to finish while async returns immediately.

A deadlock is when threads wait for each other forever, a data race is unsynchronized access to the same memory with at least one write, and a race condition is a logic bug that depends on timing.

Protect shared mutable state with an actor, a lock or Mutex, a serial queue, or atomics, or avoid sharing it by using immutable value types and main-actor isolation.

AsyncStream turns callback, delegate or notification APIs that produce many values over time into an AsyncSequence you can loop over with for await.

A continuation suspends an async function until a callback calls resume exactly once, which lets you wrap completion-handler APIs as async functions.

A view controller creates its view, loads it once in viewDidLoad, then gets appear and disappear callbacks every time it shows or hides.

The frame is the view's rectangle in its superview's coordinates, while bounds is the same view described in its own coordinates.

Auto Layout solves a set of constraint equations to find each view's frame, and hugging and compression resistance priorities decide which view grows or shrinks first.

A table view keeps a small pool of cells and reuses them for new rows, so you must fully reset each cell or you will see old data.

A diffable data source takes snapshots of section and item identifiers and computes the inserts, deletes and moves for you, so the UI never gets out of sync with the data.

Hit-testing finds the deepest view under a touch, and the responder chain passes unhandled events and actions up from that view to its superviews, view controller, window and app.

UIKit updates constraints, then lays out views, then draws them once per run loop pass, and setNeedsLayout schedules layout for later while layoutIfNeeded runs it right now.

Delegation lets one object hand some decisions or events to another object through a protocol, and the delegate property is weak to avoid a retain cycle.

The @State wrapper owns data inside a view, @Binding gives a child read-write access to someone else's data, @Bindable makes bindings to an @Observable object, and @Environment reads shared values from above.

The @Observable macro makes a class track reads and writes of each property, so SwiftUI only updates views that read the changed property, while ObservableObject updates every observer on any change.

SwiftUI uses identity to decide if a view is the same one as before, and identity controls how long state lives and whether changes animate or reset.

Wrap UIKit views with UIViewRepresentable or UIViewControllerRepresentable, and host SwiftUI inside UIKit with UIHostingController or UIHostingConfiguration.

NavigationStack drives navigation from data, so you push by appending values to a path and map each value type to a screen with navigationDestination.

Keep body cheap, make each view depend on as little data as possible, keep identities stable, use lazy containers, and measure with the SwiftUI instrument.

A SwiftUI view struct is created and thrown away often, but its state lives as long as its identity, and onAppear, onDisappear and task tie work to when it is shown.

MVC is simple but leads to huge view controllers, MVVM moves logic into a testable view model, VIPER splits a screen into many small roles, and TCA uses one state, actions and a reducer.

A coordinator owns navigation, so view controllers do not know about each other and screens become reusable and easy to test.

Dependency injection means an object gets its dependencies from outside instead of creating them, which makes code easy to test and change.

Split the app into local Swift packages with clear layers, like core, features and interfaces, so builds are faster, boundaries are enforced and teams can work in parallel.

A singleton gives one shared instance through a global access point, which is convenient but hides dependencies, shares mutable state and makes testing hard.

Build a URLRequest, call try await session.data(for:), check the HTTP status code, then decode the data, and choose a session configuration for caching, timeouts or background transfers.

Codable lets the compiler generate encoding and decoding code, and you customize it with CodingKeys, decoder strategies or a hand-written init(from:).

Let URLCache handle HTTP caching with Cache-Control and ETag headers, and add your own memory and disk cache for decoded, downsampled images.

REST uses many resource URLs and is simple to cache, GraphQL uses one endpoint where the client picks the fields it needs, and WebSockets keep a two-way connection open for real-time data.

Use UserDefaults for small settings, the Keychain for secrets, files for documents and caches, and SwiftData, Core Data or SQLite for structured data you query.

Each managed object context belongs to one queue, so you work inside perform, use the view context only on the main thread, and pass NSManagedObjectID values between contexts instead of objects.

SwiftData is Apple's Swift-first persistence framework where you mark classes with @Model, read them with @Query and save through a ModelContext, built on Core Data's proven storage.

An app moves between not running, inactive, active, background and suspended states, with AppDelegate handling process-level events and SceneDelegate handling each window's UI lifecycle.

iOS suspends apps quickly, so you use beginBackgroundTask for short finishing work, BGTaskScheduler for deferred tasks, background URLSession for transfers, and special background modes for audio, location or VoIP.

The app asks for permission, registers with APNs to get a device token, sends the token to its server, and the server sends a JSON payload to APNs, which delivers it to the device.

Universal links are normal https links that open your app when a verified apple-app-site-association file on your domain lists it, while custom URL schemes are unverified and any app can claim them.

Swift Testing uses @Test functions with expect and require macros, parameterized tests and parallel runs by default, while XCTest uses XCTestCase subclasses and XCTAssert functions, and both can live in the same target.

Hide each dependency behind a protocol or closure, inject it, and in tests pass a test double such as a stub that returns fixed data or a spy that records calls.

XCUITest drives the app from a separate process through accessibility, so you find elements by accessibility identifiers, wait for them instead of sleeping, and control app state with launch arguments.

Measure cold launch with Instruments, XCTest metrics and the Xcode Organizer, then cut pre-main work like dynamic frameworks and static initializers and defer everything not needed for the first frame.

Stutters are hitches where a frame misses its deadline, usually from main thread work in cell setup, image decoding, layout or offscreen rendering, so you measure with Instruments and move or remove that work.

Use Time Profiler for slow code, Allocations and Leaks for memory, Animation Hitches for stutters, the SwiftUI and Swift Concurrency instruments for those frameworks, and signposts to mark your own code.

Do less work and do it at better times, by batching network calls, using low location accuracy, avoiding timers and polling, letting the system schedule background work, and measuring with the energy tools.

Store small secrets like tokens in the Keychain with the right accessibility class, protect files with Data Protection, and use the Secure Enclave and biometrics for the most sensitive keys.

ATS forces secure HTTPS connections by default, and pinning goes further by only trusting specific server keys, which you set with NSPinnedDomains in Info.plist or check yourself in a URLSession delegate.

A certificate proves who signed the app, the provisioning profile says which app, devices and entitlements that certificate may use, and iOS refuses to run code whose signature or profile does not match.

A target is what you build, a build configuration is a set of build settings like Debug or Release, and a scheme says which targets and configurations to use when you run, test, profile or archive.

Run build, lint and tests on every pull request on a macOS runner, and on main or a tag archive a signed build, bump the build number and upload it to TestFlight automatically.

Combine is Apple's reactive framework where publishers emit values over time, operators transform them, and subscribers receive them, with AnyCancellable controlling how long a subscription lives.

Give every element a clear label, value and trait for VoiceOver, support Dynamic Type, keep good contrast and large tap targets, respect Reduce Motion, and test with VoiceOver and Accessibility Inspector.