# iOS Geliştiricileri İçin En Önemli 25 Swift Mülakat Sorusu

> iOS mülakatlarına hazırlık: En sık sorulan 25 Swift sorusu — optionals, closures, ARC, protokoller, async/await ve ileri düzey kalıplar detaylı açıklamalarla.

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

---

iOS teknik mülakatları, Swift dilinin hem temel hem de ileri düzey kavramlarını kapsamlı şekilde sınar. Bu 25 soru, işe alım yöneticilerinin en sık sorduğu konuları kapsamaktadır — dil temelllerinden modern eşzamanlılık kalıplarına kadar.

> **Bu rehber nasıl kullanılır**
>
> Her soru, kod örnekleri içeren ayrıntılı bir yanıt sunmaktadır. Sorular, temel kavramlardan ileri düzey konulara doğru artan zorluk sırasına göre düzenlenmiştir.

## Swift Temelleri

### 1. `let` ve `var` arasındaki fark nedir?

`let`, başlatıldıktan sonra değeri değiştirilemeyen bir sabit tanımlar; `var` ise değiştirilebilir bir değişken tanımlar. Referans tipler (sınıflar) söz konusu olduğunda `let`, referansın yeniden atanmasını engeller ancak nesnenin kendisinin değiştirilmesini engellemez.

```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
```

**En iyi uygulama**: Varsayılan olarak `let` kullanılmalı, yalnızca değişiklik gerektiğinde `var` tercih edilmelidir. Bu yaklaşım kodu daha öngörülebilir ve analizi daha kolay hale getirir.

### 2. Swift'te optionals nedir?

Optionals, bir değerin bulunmama olasılığını temsil eder. Bir optional, belirtilen türde bir değer ya da `nil` içerebilir. Swift, derleme zamanında güvenliği sağlamak için optionals kullanır ve değerin mevcut olmayabileceği durumların açıkça ele alınmasını zorunlu kılar.

```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. `struct` ve `class` arasındaki fark nedir?

`struct`, atama sırasında kopyalanan değer tipidir; `class` ise aynı örneği paylaşan referans tipidir. Bu temel ayrım performansı, bellek yönetimini ve kodun davranışını doğrudan etkiler.

```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!
```

**Hangisi ne zaman kullanılmalı**:
- **Struct**: Basit veriler, değişmez değerler, kalıtım gerekmiyorsa
- **Class**: Nesne kimliği önemliyse, kalıtım gerekliyse, paylaşılan davranış söz konusuysa

### 4. `switch` ile kalıp eşleştirme (pattern matching) nasıl çalışır?

Swift'teki `switch` güçlü ve kapsamlıdır — tüm olası durumları kapsamak zorundadır. Tipler, aralıklar, tuple'lar üzerinde kalıp eşleştirme ve `where` ile ek koşullar desteklenir.

```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. Closure nedir ve söz dizimi nasıldır?

Closure'lar, çevrelerindeki bağlamdan değişkenlere referansları yakalayan ve saklayan bağımsız kod bloklarıdır. Diğer dillerdeki lambda ya da anonim fonksiyonların Swift karşılığıdır.

```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
```

> **Yakalama semantiği**
>
> Closure'lar varsayılan olarak değişkenleri referans ile yakalar. Değer ile yakalamak için yakalama listesi kullanılmalıdır: `{ [count] in ... }`.

## Bellek Yönetimi ve ARC

### 6. ARC (Automatic Reference Counting) nasıl çalışır?

ARC, her sınıf örneğine olan güçlü referansları sayarak belleği otomatik olarak yönetir. Sayaç sıfıra düştüğünde örnek serbest bırakılır. Çöp toplama (garbage collection) mekanizmasından farklı olarak ARC deterministik ve öngörülebilirdir.

```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 nedir ve nasıl önlenir?

Retain cycle, iki nesnenin birbirine güçlü referans tutması sonucu her ikisinin de bellekten serbest bırakılamaması durumudur. `weak` ve `unowned` anahtar kelimeleri bu döngüleri kırar.

```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. `weak` ve `unowned` arasındaki fark nedir?

Her ikisi de retain cycle'ları kırar ancak farklı garantiler sunar. `weak` opsiyoneldir ve referans verilen nesne serbest bırakıldığında `nil` olur. `unowned` ise nesnenin her zaman var olduğunu varsayar ve serbest bırakıldıktan sonra erişilirse çökmeye neden olur.

```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
```

**Kural**: Varsayılan olarak `weak` kullanılmalıdır. `unowned` yalnızca referans verilen nesnenin yaşam süresinin eşit veya daha uzun olduğu garanti edildiğinde tercih edilmelidir.

## Protokoller ve Generics

### 9. Swift'te protokoller nedir?

Protokol, uyumlu tiplerin uygulaması gereken bir sözleşme (gerekli özellikler ve metotlar) tanımlar. Polimorfizmi mümkün kılar ve Swift'teki Protokol Yönelimli Programlama (POP) yaklaşımının temelini oluşturur.

```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 nedir?

Associated types, protokollerin uyumlu tipler tarafından belirlenecek jenerik tipler tanımlamasını sağlar. Bu mekanizma, `Collection` gibi protokollerin esnekliğinin temelini oluşturur.

```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 nasıl çalışır?

Generics, herhangi bir tip ile çalışabilen esnek ve yeniden kullanılabilir kod yazmayı sağlar. Tip güvenliğini derleme zamanında koruyarak kod tekrarını ortadan kaldırır.

```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. `Codable` protokolü nedir?

`Codable` (`Encodable & Decodable` için takma ad), Swift tiplerinin JSON gibi formatlara ve bu formatlardan otomatik olarak dönüştürülmesini sağlar. Tüm özellikler Codable ise derleyici uygulamayı otomatik olarak üretir.

```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)
```

## Eşzamanlılık ve async/await

### 13. Swift'te async/await nasıl çalışır?

`async/await`, bloklamayan işlemlerin sıralı biçimde yazılmasına olanak tanıyarak asenkron kodu basitleştirir. `async` olarak işaretlenen bir fonksiyon, iş parçacığını bloklamadan askıya alınabilir ve diğer görevlerin çalışmasına izin verir.

```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 nedir?

Actor'ler, iç durumlarını eşzamanlı erişime karşı koruyan referans tiplerdir. Herhangi bir anda yalnızca tek bir görevin değiştirilebilir özelliklerine erişebilmesini garanti ederek veri yarışlarını ortadan kaldırır.

```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. `Task` ve `TaskGroup` nedir?

`Task`, bir asenkron iş birimi oluşturur. `TaskGroup` ise birden fazla görevi paralel olarak çalıştırıp sonuçlarını toplamayı sağlar.

```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` nasıl çalışır?

`@MainActor`, kodun ana iş parçacığında çalışmasını sağlar. Daima ana iş parçacığında gerçekleşmesi gereken kullanıcı arayüzü güncellemeleri için kritik öneme sahiptir.

```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"
    }
}
```

## Kalıplar ve Mimari

### 17. Delegate kalıbı nedir?

Delegate kalıbı, bir nesnenin belirli sorumluluklarını başka bir nesneye devretmesini sağlar. UIKit'te yaygın olarak kullanılır (UITableViewDelegate, UITextFieldDelegate vb.).

```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. MVVM kalıbı nedir?

MVVM (Model-View-ViewModel), sunum mantığını görünümden ayırır. ViewModel, View'ın görüntülediği gözlemlenebilir verileri sunar ancak View'ın uygulama detaylarını bilmez.

```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. Dependency Injection nedir?

Dependency Injection, bir nesnenin bağımlılıklarını kendi içinde oluşturmak yerine dışarıdan sağlamayı ifade eder. Test edilebilirliği artırır ve bileşenler arasındaki bağımlılığı azaltır.

```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. Singleton kalıbı nasıl uygulanır?

Singleton, bir sınıfın yalnızca tek bir global erişilebilir örneğe sahip olmasını sağlar. Swift'te özel başlatıcı ile birlikte statik bir özellik kullanılarak gerçekleştirilir.

```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)
```

> **Singleton kullanırken dikkat**
>
> Singleton'lar test etmeyi ve bileşenlerin ayrıştırılmasını zorlaştıran global durum oluşturur. Mümkün olduğunda dependency injection tercih edilmelidir.

## İleri Düzey Kavramlar

### 21. Closure'larda `@escaping` ne anlama gelir?

Bir closure, onu alan fonksiyon geri döndükten sonra çağrılabiliyorsa `@escaping` olarak işaretlenir. Bu durum asenkron callback'lerde ve closure saklama senaryolarında sıkça karşılaşılır.

```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` nedir?

Property wrapper'lar, bir özelliğin saklanma ve erişim mantığını kapsüller. Doğrulama, loglama veya kalıcı saklama gibi kalıpların yeniden kullanılmasını sağlar.

```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. Result builder nedir?

Result builder'lar, bildirimsel söz dizimi ile karmaşık değerler oluşturmayı sağlar. SwiftUI'ın DSL söz diziminin temelini bu mekanizma oluşturur.

```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` ve opaque types nasıl çalışır?

`some`, opaque (donuk) bir tip tanımlar: tam tip derleyici tarafından bilinir ancak çağıran taraftan gizlenir. Associated type'lara sahip protokoller için zorunludur ve optimizasyonlara olanak tanır.

```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. Swift makroları nedir?

Makrolar (Swift 5.9+), derleme zamanında kod üretir. Tip güvenliğini ve hata ayıklama kolaylığını koruyarak tekrarlayan kodu azaltır.

```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
}
```

> **Makro hata ayıklama**
>
> Xcode'da bir makroya sağ tıklayıp "Expand Macro" seçeneği ile üretilen kodu görmek mümkündür. Analiz ve hata ayıklama için oldukça faydalıdır.

## Sonuç

Bu 25 soru, iOS mülakatlarında başarılı olmak için her Swift geliştiricisinin hakim olması gereken temel konuları kapsamaktadır. ARC ile bellek yönetiminden modern eşzamanlılık kalıplarına kadar her kavram, Swift ekosisteminin ayrılmaz bir parçasıdır.

### Tekrar Kontrol Listesi

- Optionals ve farklı unwrapping yöntemlerinin kavranması
- Değer tipleri ile referans tipleri arasındaki farkın anlaşılması
- Retain cycle'ların weak/unowned ile tespit edilmesi ve çözülmesi
- Eşzamanlılık için async/await ve actor kullanımı
- Delegate, MVVM ve Dependency Injection kalıplarının uygulanması
- Protokoller, generics ve Codable bilgisi
- İleri düzey kavramlar: property wrapper, result builder, makrolar

### Ek Kaynaklar

Resmi Swift dokümantasyonu, bu konuları derinlemesine öğrenmek için en güvenilir kaynaktır. Kişisel projeler ve kodlama egzersizleri ile düzenli pratik yapmak, bu kavramların pekiştirilmesine yardımcı olur.

---

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