Swift · Complete Question Bank

All Swift Interview Questions

Practice the complete collection of Swift interview questions including theory, coding, MCQs and real interview problems.

Total Questions: 108Topics: 11Complete interview preparation

Overview

Questions

108

Full database

Topics

Categorised

Difficulty

Mixed Levels

Easy Hard

All Swift Interview Questions (108)

Scroll through every important Swift question asked in real interviews. Includes MCQs, subjective questions, and coding prompts.

1. What is the difference between `let` and `var` in Swift?

Difficulty: EasyType: MCQTopic: Swift Fundamentals

`let` declares a constant, `var` declares a mutable variable
`let` declares a variable, `var` declares a constant
`let` and `var` are interchangeable
`let` is used for classes, `var` is used for structs

In Swift `let` is used to define a constant whose value cannot change after assignment, whereas `var` defines a variable whose value can change. Using `let` whenever possible signals intent and improves safety.

Correct Answer: `let` declares a constant, `var` declares a mutable variable

2. What does the `?` after a type name signify in Swift, e.g., `Int?`?

Difficulty: EasyType: MCQTopic: Swift Fundamentals

The value must always be present
The value may be nil (absent)
It's a forced unwrapped optional

Continue your preparation

Browse more Swift questions, explore related subjects, or practice full interview sets to strengthen your preparation.

Swift subject page•All subjects

Master Interviews Anywhere, Anytime

All Swift Interview Questions

Overview

1. What is the difference between `let` and `var` in Swift?

2. What does the `?` after a type name signify in Swift, e.g., `Int?`?

Continue your preparation

3. Which statement is true about `struct` vs `class` in Swift?

4. What is the purpose of a `guard` statement in Swift?

5. Which of these best describes a closure in Swift?

6. What does Swift's type inference mean?

7. Which feature allows you to call a method or access property on an optional that might be nil, returning nil if the optional is nil?

8. What does the `defer` statement do in Swift?

9. Explain how error handling works in Swift with `throw`, `try`, `catch` and how you would define a custom error.

10. Describe value semantics vs reference semantics in Swift and why this distinction matters when choosing `struct` vs `class`.

11. Explain Swift's access control levels (`open`, `public`, `internal`, `fileprivate`, `private`) and when you would use each in your codebase.

12. In Swift, which statement about structs is correct?

13. Which statement about classes in Swift is true?

14. According to Apple's documentation, which guideline is recommended when choosing between struct and class?

15. What is the difference between value semantics and reference semantics in Swift?

16. Which of the following is a limitation of structs compared to classes in Swift?

17. When do you need to mark a method as `mutating` inside a Swift struct?

18. Which operator checks whether two references refer to the exact same class instance in Swift?

19. Which mechanism underpins the performance optimisation for many Swift value types such as Array, when multiple copies appear but actual duplication is delayed until needed?

20. When designing a Swift object model, how do you decide whether to use a struct or a class? Provide guidelines and reasoning.

21. Provide a code example in Swift that demonstrates the difference between value semantics (struct) and reference semantics (class). Then explain the implications of using one versus the other in multi-threaded or shared-state scenarios.

22. Explain how memory management differs between structs and classes in Swift, and what effects this has on performance or design.

23. What is a protocol in Swift?

24. What is the purpose of `associatedtype` in a Swift protocol?

25. What does a protocol extension allow you to do in Swift?

26. What is a generic type in Swift?

27. What is protocol composition in Swift?

28. Which Swift feature allows a function to hide the concrete return type while still specifying its protocol conformance?

29. What is `typealias` used for in a Swift protocol?

30. What is protocol-oriented programming (POP) in Swift?

31. Explain how generics and protocol constraints work together in Swift and provide an example.

32. Differentiate between using `associatedtype` in a protocol and using a generic placeholder in a generic type. When would you choose each?

33. How do protocol extensions provide default implementations in Swift, and what are some pitfalls to be aware of?

34. What does ARC stand for in Swift and what is its role?

35. Which statement correctly describes weak vs unowned references in Swift?

36. What is a retain cycle (also called strong reference cycle) in Swift and why is it problematic?

37. Which of the following describes the `DispatchQueue.main` vs `DispatchQueue.global()` in Swift concurrency?

38. What is a race condition in concurrent Swift code?

39. Which Swift feature introduces a high-level way to manage mutable state safely across concurrency domains?

40. Why do we often use `[weak self]` inside closures in Swift classes?

41. Explain structured concurrency in Swift using async/await, tasks, and actors.

42. Compare how memory management works for value types (struct/enums) and reference types (classes) in Swift.

43. What are common concurrency pitfalls in Swift and how can you mitigate them (for example deadlocks, race conditions, priority inversion)?

44. What does marking a Swift function with `throws` indicate?

45. What is the purpose of a `do-catch` block in Swift?

46. What is the difference between `try?` and `try!` in Swift?

47. When is the `defer` block executed in Swift?

48. What does the `Codable` protocol in Swift provide?

49. Which `Error` type is thrown by JSON decoding when the data doesn’t match the model in Swift’s `Codable` interface?

50. Which data type is **not** directly supported by `UserDefaults` in Swift?

51. Compare using `Codable` to persist simple models vs using `CoreData` for complex object graphs in Swift. Provide reasoning and trade-offs.

52. Explain how error propagation works in Swift when calling multiple throwing functions and how you would design an API accordingly.

53. Describe how you would handle data migration when your persistent model changes (e.g., adding fields) using `Codable` or `CoreData` in Swift.

54. When would you use the Keychain rather than `UserDefaults` for persistence in Swift, and what are some best practices for storing sensitive data?

55. What is a higher-order function in Swift?

56. Which of these describes what `map` does in Swift?

57. What does the `filter` function do in Swift?

58. How does the `reduce` function in Swift work?

59. Which statement correctly describes a closure capture list in Swift?

60. What is a key-path in Swift and how can it assist higher-order functional code?

61. Which statement best captures immutability in functional programming as applied in Swift?

62. What benefit does a `lazy` collection or sequence provide when using higher-order functions in Swift?

63. How would you create a custom higher-order function in Swift that takes a closure and returns another function? Provide an example and explanation.

64. Explain function composition in Swift (combining functions) and how it helps build reusable pipelines of operations on data.

65. Differentiate between `map`, `flatMap` and `compactMap` in Swift, with examples of when to use each.

66. What key concept differentiates SwiftUI from older UI frameworks like UIKit?

67. Why are views defined as `struct`s rather than `class` in SwiftUI?

68. Which property wrapper would you use when storing view–local mutable state in SwiftUI?

69. What is the difference between `@State` and `@Binding` in SwiftUI?

70. Which container is recommended in SwiftUI for stack-based navigation in iOS 16 and later?

71. What is a `ViewModifier` in SwiftUI and why would you create a custom one?

72. How does the Combine framework integrate with SwiftUI for reactive data flows?

73. Compare SwiftUI and UIKit: what are the advantages, limitations and when would you choose one over the other?

74. Explain the differences between `@StateObject`, `@ObservedObject` and `@EnvironmentObject` in SwiftUI, and how you decide which to use in view architecture.

75. What are some performance considerations when building SwiftUI apps and how do you mitigate potential issues?

76. Which architectural pattern separates an app into Model, View and Controller roles?

Master Interviews
Anywhere, Anytime

50. Which data type is not directly supported by `UserDefaults` in Swift?