# 25 Cau Hoi Phong Van Swift Hang Dau Cho Lap Trinh Vien iOS

> Chuan bi cho phong van iOS voi 25 cau hoi Swift thuong gap nhat: optionals, closures, ARC, protocols, async/await va cac pattern nang cao.

- Published: 2026-01-29
- Updated: 2026-04-12
- Author: SharpSkill
- Tags: swift, ios, interview, career, apple
- Reading time: 15 min

---

Phong van ky thuat iOS kiem tra ky luong ca kien thuc Swift co ban lan nang cao. 25 cau hoi duoi day bao gom nhung chu de thuong duoc cac nha tuyen dung hoi nhat, tu co ban ngon ngu den cac pattern concurrency hien dai.

> **Cach su dung huong dan nay**
>
> Moi cau hoi di kem cau tra loi chi tiet va code vi du. Cac cau hoi duoc sap xep theo do kho tang dan, tu co ban den nang cao.

## Co Ban Swift

### 1. Su khac biet giua `let` va `var` la gi?

`let` khai bao hang so khong the thay doi gia tri sau khi khoi tao, trong khi `var` khai bao bien co the thay doi. Voi kieu tham chieu (class), `let` ngan viec gan lai tham chieu nhung khong ngan viec sua doi chinh doi tuong.

```swift
// Constants.swift

// let = constant, immutable value
let maximumAttempts = 3
// maximumAttempts = 5  // ❌ Compile error

// var = variable, mutable value
var currentAttempt = 0
currentAttempt += 1  // ✅ OK

// Careful with reference types
class User {
    var name: String
    init(name: String) { self.name = name }
}

let user = User(name: "Alice")
user.name = "Bob"  // ✅ OK - modifying object, not reference
// user = User(name: "Charlie")  // ❌ Error - reassignment forbidden
```

**Thuc hanh tot nhat**: su dung `let` mac dinh va chi chuyen sang `var` khi thuc su can thay doi gia tri. Dieu nay giup code de du doan va de hieu hon.

### 2. Giai thich optionals trong Swift

Optionals dai dien cho kha nang vang mat cua mot gia tri. Mot optional co the chua mot gia tri cua kieu duoc chi dinh hoac `nil`. Swift su dung optionals de dam bao an toan tai thoi diem bien dich bang cach bat buoc xu ly ro rang cac truong hop gia tri co the khong ton tai.

```swift
// Optionals.swift

// Declaring an optional with ?
var username: String? = nil  // Can hold a String or nil

// Optional binding with if let (safe unwrapping)
if let name = username {
    print("Hello, \(name)")  // Only executes if username != nil
} else {
    print("Anonymous user")
}

// Guard let for early return
func greet(user: String?) {
    guard let name = user else {
        print("No user provided")
        return  // Early exit if nil
    }
    print("Hello, \(name)")  // name is guaranteed non-nil here
}

// Nil-coalescing operator (??) for default value
let displayName = username ?? "Anonymous"

// Force unwrapping (!) - DANGEROUS, avoid this
// let forced = username!  // Crashes if nil
```

### 3. Su khac biet giua `struct` va `class` la gi?

`struct` la kieu gia tri (duoc sao chep khi gan) trong khi `class` la kieu tham chieu (chia se cung mot instance). Su khac biet co ban nay anh huong den hieu nang, quan ly bo nho va hanh vi code.

```swift
// ValueVsReference.swift

// Struct = value type (copy)
struct Point {
    var x: Int
    var y: Int
}

var p1 = Point(x: 10, y: 20)
var p2 = p1      // Independent copy
p2.x = 100       // Only modifies p2
print(p1.x)      // 10 - p1 unchanged

// Class = reference type (shared)
class Rectangle {
    var width: Int
    var height: Int
    init(width: Int, height: Int) {
        self.width = width
        self.height = height
    }
}

let r1 = Rectangle(width: 10, height: 20)
let r2 = r1      // Same shared instance
r2.width = 100   // Modifies the shared instance
print(r1.width)  // 100 - r1 also modified!
```

**Khi nao su dung loai nao**:
- **Struct**: du lieu don gian, gia tri immutable, khong can ke thua
- **Class**: danh tinh quan trong, can ke thua, hanh vi dung chung

### 4. Pattern matching voi `switch` hoat dong nhu the nao?

`switch` trong Swift rat manh me va co tinh exhaustive: phai bao phu tat ca cac truong hop co the. No ho tro pattern matching tren kieu, range, tuple va dieu kien bo sung voi `where`.

```swift
// PatternMatching.swift

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

func handleError(_ error: NetworkError) {
    switch error {
    case .timeout:
        print("Request timed out")

    case .serverError(let code) where code >= 500:
        print("Critical server error: \(code)")

    case .serverError(let code):
        print("Server error: \(code)")

    case .noConnection:
        print("No connection")
    }
    // No default needed: all cases covered
}

// Pattern matching on ranges and tuples
let point = (x: 5, y: 10)
switch point {
case (0, 0):
    print("Origin")
case (let x, 0):
    print("On X axis at \(x)")
case (0...10, 0...10):
    print("In the 10x10 square")
default:
    print("Elsewhere")
}
```

### 5. Giai thich closures va cu phap cua chung

Closures la cac khoi code doc lap co the nam bat va luu tru tham chieu den cac bien tu ngu canh xung quanh. Chung tuong duong voi lambda hoac ham an danh trong cac ngon ngu khac.

```swift
// Closures.swift

// Full syntax
let add: (Int, Int) -> Int = { (a: Int, b: Int) -> Int in
    return a + b
}

// Shorthand syntax (inferred types, implicit return)
let multiply: (Int, Int) -> Int = { $0 * $1 }

// Trailing closure syntax
let numbers = [3, 1, 4, 1, 5]
let sorted = numbers.sorted { $0 > $1 }  // [5, 4, 3, 1, 1]

// Closure capturing a variable
func makeCounter() -> () -> Int {
    var count = 0  // Captured variable
    return {
        count += 1  // Closure "closes over" count
        return count
    }
}

let counter = makeCounter()
print(counter())  // 1
print(counter())  // 2 - count remembered between calls
```

> **Ngu nghia capture**
>
> Closures mac dinh nam bat bien theo tham chieu. De nam bat theo gia tri, su dung capture list: `{ [count] in ... }`.

## Quan Ly Bo Nho va ARC

### 6. ARC (Automatic Reference Counting) hoat dong nhu the nao?

ARC tu dong quan ly bo nho bang cach dem so strong references den moi instance cua class. Khi so dem giam ve 0, instance do duoc giai phong. Khac voi garbage collection, ARC mang tinh tat dinh va co the du doan.

```swift
// ARC.swift

class Person {
    let name: String

    init(name: String) {
        self.name = name
        print("\(name) is initialized")
    }

    deinit {
        print("\(name) is deallocated")
    }
}

// Demonstrating lifecycle
var person1: Person? = Person(name: "Alice")  // refCount = 1
var person2 = person1                          // refCount = 2
person1 = nil                                  // refCount = 1 (not deallocated)
person2 = nil                                  // refCount = 0 → deinit called
// Output: "Alice is deallocated"
```

### 7. Retain cycle la gi va cach phong tranh?

Retain cycle xay ra khi hai doi tuong giu strong reference lan nhau, ngan can viec giai phong bo nho. Tu khoa `weak` va `unowned` duoc su dung de pha vo vong tron nay.

```swift
// RetainCycle.swift

class Department {
    let name: String
    var manager: Employee?  // Strong reference

    init(name: String) { self.name = name }
    deinit { print("Department \(name) deallocated") }
}

class Employee {
    let name: String
    // weak prevents retain cycle - can become nil
    weak var department: Department?

    init(name: String) { self.name = name }
    deinit { print("Employee \(name) deallocated") }
}

// Without weak: retain cycle → memory leak
// With weak: proper deallocation
var dept: Department? = Department(name: "Engineering")
var emp: Employee? = Employee(name: "Bob")
dept?.manager = emp
emp?.department = dept

dept = nil  // ✅ Deallocated thanks to weak
emp = nil   // ✅ Deallocated
```

### 8. Su khac biet giua `weak` va `unowned` la gi?

Ca hai deu pha vo retain cycle, nhung voi cac dam bao khac nhau. `weak` la optional va tro thanh `nil` neu doi tuong duoc tham chieu bi giai phong. `unowned` gia dinh doi tuong luon ton tai va se crash neu truy cap sau khi giai phong.

```swift
// WeakVsUnowned.swift

class Customer {
    let name: String
    var card: CreditCard?

    init(name: String) { self.name = name }
}

class CreditCard {
    let number: String
    // unowned because a card always exists with its customer
    unowned let customer: Customer

    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
    }
}

// Card cannot exist without customer
let customer = Customer(name: "Alice")
customer.card = CreditCard(number: "1234", customer: customer)
// If customer is deallocated, accessing card.customer would crash
```

**Quy tac**: su dung `weak` mac dinh. Chi su dung `unowned` khi dam bao lifetime cua doi tuong tham chieu bang hoac dai hon.

## Protocols va Generics

### 9. Giai thich protocols trong Swift

Protocols dinh nghia hop dong (cac thuoc tinh va phuong thuc bat buoc) ma cac kieu tuan thu phai trien khai. Protocols cho phep da hinh va la nen tang cua Protocol-Oriented Programming (POP) trong Swift.

```swift
// Protocols.swift

// Protocol definition
protocol Drawable {
    var color: String { get set }  // Required property (read/write)
    func draw()                     // Required method
}

// Protocol extension with default implementation
extension Drawable {
    func draw() {
        print("Default drawing in \(color)")
    }
}

// Protocol conformance
struct Circle: Drawable {
    var color: String
    var radius: Double

    // draw() inherits default implementation
}

struct Square: Drawable {
    var color: String
    var side: Double

    // Override default implementation
    func draw() {
        print("Square \(color) with side \(side)")
    }
}

// Polymorphic usage
let shapes: [Drawable] = [Circle(color: "red", radius: 5), Square(color: "blue", side: 10)]
shapes.forEach { $0.draw() }
```

### 10. Associated type la gi?

Associated types cho phep protocols dinh nghia kieu generic se duoc xac dinh boi kieu tuan thu. Co che nay lam cho cac protocols nhu `Collection` tro nen linh hoat.

```swift
// AssociatedTypes.swift

// Protocol with associated type
protocol Container {
    associatedtype Item  // Type defined by conformant
    var items: [Item] { get set }
    mutating func add(_ item: Item)
    func count() -> Int
}

// Implementation with Item = String
struct StringBox: Container {
    typealias Item = String  // Optional, Swift can infer
    var items: [String] = []

    mutating func add(_ item: String) {
        items.append(item)
    }

    func count() -> Int { items.count }
}

// Implementation with Item = Int
struct IntStack: Container {
    var items: [Int] = []

    mutating func add(_ item: Int) {
        items.append(item)
    }

    func count() -> Int { items.count }
}
```

### 11. Generics hoat dong nhu the nao?

Generics cho phep viet code linh hoat, tai su dung duoc voi bat ky kieu nao. Generics tranh trung lap code dong thoi van dam bao an toan kieu tai thoi diem bien dich.

```swift
// Generics.swift

// Generic function
func swap<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

// Type constraint with where
func findIndex<T: Equatable>(of item: T, in array: [T]) -> Int? {
    for (index, element) in array.enumerated() {
        if element == item { return index }  // Equatable required for ==
    }
    return nil
}

// Generic struct
struct Queue<Element> {
    private var elements: [Element] = []

    mutating func enqueue(_ element: Element) {
        elements.append(element)
    }

    mutating func dequeue() -> Element? {
        guard !elements.isEmpty else { return nil }
        return elements.removeFirst()
    }
}

var intQueue = Queue<Int>()
intQueue.enqueue(1)
intQueue.enqueue(2)
print(intQueue.dequeue())  // Optional(1)
```

### 12. Giai thich protocol `Codable`

`Codable` (bi danh cua `Encodable & Decodable`) cho phep tu dong chuyen doi cac kieu Swift sang va tu cac dinh dang nhu JSON. Compiler tu dong tao ra implementation neu tat ca cac thuoc tinh deu la Codable.

```swift
// Codable.swift

struct User: Codable {
    let id: Int
    let name: String
    let email: String
    let createdAt: Date

    // CodingKeys to map different JSON names
    enum CodingKeys: String, CodingKey {
        case id
        case name
        case email
        case createdAt = "created_at"  // snake_case → camelCase
    }
}

// JSON decoding
let json = """
{
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com",
    "created_at": "2026-01-15T10:30:00Z"
}
""".data(using: .utf8)!

let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601

do {
    let user = try decoder.decode(User.self, from: json)
    print(user.name)  // "Alice"
} catch {
    print("Decoding error: \(error)")
}

// Encoding to JSON
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let data = try encoder.encode(user)
```

## Concurrency va async/await

### 13. async/await trong Swift hoat dong nhu the nao?

`async/await` don gian hoa code bat dong bo bang cach cho phep cac thao tac non-blocking duoc viet theo trinh tu. Ham `async` co the tam dung ma khong chan thread, cho phep cac task khac chay.

```swift
// AsyncAwait.swift

// Asynchronous function
func fetchUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!

    // await suspends execution until response
    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse,
          httpResponse.statusCode == 200 else {
        throw NetworkError.invalidResponse
    }

    return try JSONDecoder().decode(User.self, from: data)
}

// Calling from async context
func loadUserProfile() async {
    do {
        let user = try await fetchUser(id: 42)
        print("User: \(user.name)")
    } catch {
        print("Error: \(error)")
    }
}

// Calling from synchronous context with Task
func buttonTapped() {
    Task {
        await loadUserProfile()
    }
}
```

### 14. Actor la gi?

Actors la kieu tham chieu bao ve trang thai noi bo khoi truy cap dong thoi. Actors dam bao chi mot task tai mot thoi diem co the truy cap cac thuoc tinh mutable, loai bo data races.

```swift
// Actors.swift

// Actor protects its state automatically
actor BankAccount {
    private var balance: Double = 0

    func deposit(_ amount: Double) {
        balance += amount  // Automatic thread-safe access
    }

    func withdraw(_ amount: Double) -> Bool {
        guard balance >= amount else { return false }
        balance -= amount
        return true
    }

    func getBalance() -> Double {
        return balance
    }
}

// Usage - await required to access actor
let account = BankAccount()

Task {
    await account.deposit(100)
    let success = await account.withdraw(30)
    let balance = await account.getBalance()
    print("Balance: \(balance)")  // 70
}
```

### 15. Giai thich `Task` va `TaskGroup`

`Task` tao mot don vi cong viec bat dong bo. `TaskGroup` cho phep chay nhieu task song song va thu thap ket qua cua chung.

```swift
// TaskGroup.swift

// Simple Task
let task = Task {
    return await fetchUser(id: 1)
}
let user = try await task.value

// TaskGroup for parallelization
func fetchMultipleUsers(ids: [Int]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        // Launch all requests in parallel
        for id in ids {
            group.addTask {
                try await fetchUser(id: id)
            }
        }

        // Collect results as they complete
        var users: [User] = []
        for try await user in group {
            users.append(user)
        }
        return users
    }
}

// All 3 requests run in parallel
let users = try await fetchMultipleUsers(ids: [1, 2, 3])
```

### 16. `@MainActor` hoat dong nhu the nao?

`@MainActor` dam bao code chay tren main thread. Dieu nay thiet yeu cho cac cap nhat giao dien nguoi dung luon phai thuc thi tren main thread.

```swift
// MainActor.swift

// UI class annotated with @MainActor
@MainActor
class UserViewModel: ObservableObject {
    @Published var user: User?
    @Published var isLoading = false
    @Published var error: String?

    func loadUser() async {
        isLoading = true  // ✅ On main thread automatically

        do {
            // Network operation on background thread
            user = try await fetchUser(id: 42)
        } catch {
            self.error = error.localizedDescription
        }

        isLoading = false  // ✅ Automatic return to main thread
    }
}

// Or for a specific function
func updateUI() async {
    await MainActor.run {
        // This block runs on main thread
        label.text = "Updated"
    }
}
```

## Pattern va Kien Truc

### 17. Giai thich pattern Delegate

Pattern Delegate cho phep mot doi tuong uy quyen mot so trach nhiem nhat dinh cho doi tuong khac. Day la pattern rat pho bien trong UIKit (UITableViewDelegate, UITextFieldDelegate, v.v.).

```swift
// DelegatePattern.swift

// 1. Define the delegate protocol
protocol DownloadManagerDelegate: AnyObject {
    func downloadDidStart()
    func downloadDidProgress(_ progress: Double)
    func downloadDidComplete(data: Data)
    func downloadDidFail(error: Error)
}

// 2. Class that uses the delegate
class DownloadManager {
    // weak to avoid retain cycles
    weak var delegate: DownloadManagerDelegate?

    func startDownload(url: URL) {
        delegate?.downloadDidStart()

        // Simulated download
        Task {
            for progress in stride(from: 0.0, to: 1.0, by: 0.1) {
                try await Task.sleep(nanoseconds: 100_000_000)
                delegate?.downloadDidProgress(progress)
            }
            delegate?.downloadDidComplete(data: Data())
        }
    }
}

// 3. Class that implements the delegate
class ViewController: UIViewController, DownloadManagerDelegate {
    let manager = DownloadManager()

    override func viewDidLoad() {
        super.viewDidLoad()
        manager.delegate = self  // Register as delegate
    }

    func downloadDidStart() { print("Started") }
    func downloadDidProgress(_ progress: Double) { print("\(progress * 100)%") }
    func downloadDidComplete(data: Data) { print("Complete") }
    func downloadDidFail(error: Error) { print("Error: \(error)") }
}
```

### 18. Pattern MVVM la gi?

MVVM (Model-View-ViewModel) tach rieng logic trinh bay khoi view. ViewModel cung cap du lieu co the quan sat ma View hien thi, ma khong can biet chi tiet cua View.

```swift
// MVVM.swift

// Model
struct Article: Identifiable {
    let id: UUID
    let title: String
    let content: String
    let publishedAt: Date
}

// ViewModel
@MainActor
class ArticleListViewModel: ObservableObject {
    @Published private(set) var articles: [Article] = []
    @Published private(set) var isLoading = false
    @Published var errorMessage: String?

    private let repository: ArticleRepository

    init(repository: ArticleRepository = .shared) {
        self.repository = repository
    }

    func loadArticles() async {
        isLoading = true
        errorMessage = nil

        do {
            articles = try await repository.fetchArticles()
        } catch {
            errorMessage = "Failed to load articles"
        }

        isLoading = false
    }
}

// View (SwiftUI)
struct ArticleListView: View {
    @StateObject private var viewModel = ArticleListViewModel()

    var body: some View {
        Group {
            if viewModel.isLoading {
                ProgressView()
            } else {
                List(viewModel.articles) { article in
                    Text(article.title)
                }
            }
        }
        .task { await viewModel.loadArticles() }
    }
}
```

### 19. Giai thich dependency injection

Dependency injection la viec cung cap cac dependency cua doi tuong tu ben ngoai thay vi tao chung ben trong. Cach tiep can nay cai thien kha nang test va giam su phu thuoc.

```swift
// DependencyInjection.swift

// Protocol for abstraction
protocol UserServiceProtocol {
    func fetchUser(id: Int) async throws -> User
}

// Real implementation
class UserService: UserServiceProtocol {
    func fetchUser(id: Int) async throws -> User {
        // Real API call
        let url = URL(string: "https://api.example.com/users/\(id)")!
        let (data, _) = try await URLSession.shared.data(from: url)
        return try JSONDecoder().decode(User.self, from: data)
    }
}

// ViewModel with injection
class ProfileViewModel: ObservableObject {
    private let userService: UserServiceProtocol

    // Constructor injection
    init(userService: UserServiceProtocol = UserService()) {
        self.userService = userService
    }

    func loadProfile(id: Int) async {
        // Uses injected service
    }
}

// Mock for testing
class MockUserService: UserServiceProtocol {
    func fetchUser(id: Int) async throws -> User {
        return User(id: id, name: "Test User", email: "test@test.com")
    }
}

// In tests
let viewModel = ProfileViewModel(userService: MockUserService())
```

### 20. Cach trien khai pattern Singleton?

Singleton dam bao mot class chi co duy nhat mot instance co the truy cap toan cuc. Trong Swift, su dung thuoc tinh static va initializer private.

```swift
// Singleton.swift

class NetworkManager {
    // Single globally accessible instance
    static let shared = NetworkManager()

    // Private initializer prevents creating other instances
    private init() {
        // Initial configuration
    }

    private let session = URLSession.shared

    func request<T: Decodable>(_ url: URL) async throws -> T {
        let (data, _) = try await session.data(from: url)
        return try JSONDecoder().decode(T.self, from: data)
    }
}

// Usage
let user: User = try await NetworkManager.shared.request(url)
```

> **Chu y voi Singleton**
>
> Singleton tao ra trang thai toan cuc gay kho khan cho viec test va giam su phu thuoc. Nen uu tien su dung dependency injection khi co the.

## Khai Niem Nang Cao

### 21. Giai thich `@escaping` cho closures

Mot closure la `@escaping` khi no co the duoc goi sau khi ham nhan no da tra ve. Dieu nay pho bien voi cac callback bat dong bo va luu tru closure.

```swift
// Escaping.swift

class DataLoader {
    // Storage of completion handlers
    private var completionHandlers: [() -> Void] = []

    // @escaping because closure is stored and called later
    func loadData(completion: @escaping () -> Void) {
        completionHandlers.append(completion)

        DispatchQueue.global().async {
            // Async work...
            Thread.sleep(forTimeInterval: 1)

            DispatchQueue.main.async {
                // Closure called after loadData returns
                completion()
            }
        }
    }

    // Non-escaping by default: closure called before return
    func transform(data: Data, using transformer: (Data) -> String) -> String {
        return transformer(data)  // Called immediately
    }
}

// With @escaping, watch for retain cycles
class ViewController {
    var loader = DataLoader()
    var data: String?

    func load() {
        loader.loadData { [weak self] in  // [weak self] avoids retain cycle
            self?.data = "Loaded"
        }
    }
}
```

### 22. `@propertyWrapper` la gi?

Property wrappers dong goi logic luu tru va truy cap cua mot thuoc tinh. Co che nay cho phep tai su dung cac pattern nhu validation, logging, hoac persistence.

```swift
// PropertyWrapper.swift

// Property wrapper for positive values only
@propertyWrapper
struct Positive {
    private var value: Int = 0

    var wrappedValue: Int {
        get { value }
        set { value = max(0, newValue) }  // Force positive
    }

    // Projected value accessible via $
    var projectedValue: Bool {
        value > 0
    }

    init(wrappedValue: Int) {
        self.wrappedValue = wrappedValue
    }
}

// Usage
struct Player {
    @Positive var score: Int = 0
    @Positive var health: Int = 100
}

var player = Player()
player.score = -50   // Becomes 0 (clamped)
print(player.score)  // 0
print(player.$score) // false (projectedValue)

player.score = 100
print(player.$score) // true
```

### 23. Giai thich result builders

Result builders cho phep xay dung cac gia tri phuc tap voi cu phap khai bao. Day la co che dang sau cu phap DSL cua SwiftUI.

```swift
// ResultBuilder.swift

// Result builder definition
@resultBuilder
struct StringBuilder {
    static func buildBlock(_ components: String...) -> String {
        components.joined(separator: " ")
    }

    static func buildOptional(_ component: String?) -> String {
        component ?? ""
    }

    static func buildEither(first component: String) -> String {
        component
    }

    static func buildEither(second component: String) -> String {
        component
    }
}

// Function using the builder
func buildGreeting(@StringBuilder _ content: () -> String) -> String {
    content()
}

// Usage with declarative syntax
let greeting = buildGreeting {
    "Hello"
    "and"
    "welcome"
    if Bool.random() {
        "!"
    } else {
        "."
    }
}
print(greeting)  // "Hello and welcome !" or "Hello and welcome ."
```

### 24. `some` va opaque types hoat dong nhu the nao?

`some` khai bao opaque type: kieu chinh xac duoc compiler biet nhung an khoi nguoi goi. Dieu nay thiet yeu cho protocols co associated types va cho phep toi uu hoa.

```swift
// OpaqueTypes.swift

// Without some: error because Collection has associated type
// func makeCollection() -> Collection { ... }  // ❌ Error

// With some: exact type is hidden but consistent
func makeArray() -> some Collection {
    return [1, 2, 3]  // Always returns the same concrete type
}

// Used in SwiftUI for body
struct ContentView: View {
    var body: some View {  // Exact type inferred but hidden
        VStack {
            Text("Hello")
            Text("World")
        }
    }
}

// Difference with any (existential)
func processAny(_ collection: any Collection) {
    // Can accept different types, runtime overhead
}

func processSome(_ collection: some Collection) {
    // Type fixed at compile time, no overhead
}
```

### 25. Giai thich Swift macros

Macros (Swift 5.9+) sinh code tai thoi diem bien dich. Macros giam boilerplate dong thoi van dam bao an toan kieu va kha nang debug.

```swift
// Macros.swift

// Freestanding macro: generates an expression
let (x, y) = #unwrap(optionalX, optionalY)
// Expands to: guard let x = optionalX, let y = optionalY else { ... }

// Attached macro: modifies a declaration
@Observable  // Macro that generates Observable boilerplate
class UserModel {
    var name: String = ""
    var email: String = ""
}
// Automatically generates @ObservationTracked, ObservationRegistrar, etc.

// Macro for Codable with customization
@Codable
struct Product {
    let id: Int
    @CodableKey("product_name") let name: String  // Renames JSON key
    @CodableIgnored var cache: Data?              // Excludes from coding
}

// Creating a custom macro
@attached(member, names: named(init))
public macro AutoInit() = #externalMacro(module: "MyMacros", type: "AutoInitMacro")

@AutoInit
struct Point {
    let x: Int
    let y: Int
    // init(x: Int, y: Int) generated automatically
}
```

> **Debug macros**
>
> Trong Xcode, click chuot phai vao macro roi chon "Expand Macro" de xem code duoc sinh ra. Huu ich cho viec hieu va debug.

## Ket Luan

25 cau hoi nay bao gom nhung kien thuc nen tang ma moi lap trinh vien Swift can nam vung de thanh cong trong phong van iOS. Tu quan ly bo nho voi ARC den cac pattern concurrency hien dai, moi khai niem deu hoa nhap trong he sinh thai Swift.

### Danh Sach Kiem Tra

- Nam vung optionals va cac phuong phap unwrapping khac nhau
- Hieu su khac biet giua kieu gia tri va kieu tham chieu
- Biet cach nhan dien va giai quyet retain cycles voi weak/unowned
- Su dung async/await va actors cho concurrency
- Trien khai cac pattern Delegate, MVVM va Dependency Injection
- Hieu protocols, generics va Codable
- Nam cac khai niem nang cao: property wrappers, result builders, macros

### Tai Lieu Tham Khao Bo Sung

De tim hieu sau hon, tai lieu chinh thuc cua Swift van la nguon tham khao hang dau. Thuc hanh thuong xuyen voi cac du an ca nhan va bai tap code giup cung co kien thuc ve cac khai niem nay.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/vi/blog/ios/top-25-swift-interview-questions