SwiftUI — temel kavramlar: View, State ve Data Flow

SwiftUI Nedir?

SwiftUI — UIKit'ten kökten farklı olan Apple'ın bildirimsel UI çerçevesi. Denetleyiciler, görünümler oluşturmak ve yaşam döngülerini manuel olarak yönetmek yerine, geliştirici arayüzü bildirimler olarak tanımlar: ekranda ne olması gerektiği, nasıl oluşturulacağı değil. SwiftUI, reaktivite ilkesine dayanır: arayüz, durumun bir fonksiyonudur. Durum değiştiğinde, SwiftUI otomatik olarak tüm bağımlı View'ların body'sini yeniden hesaplar ve ekranın yalnızca değişen kısımlarını günceller. SwiftUI, iOS 13+, iPadOS 13+, macOS 10.15+, watchOS 6+, tvOS 13+ ve visionOS 1+'da kullanılabilir. SwiftUI kodu çapraz platformdur: tek bir dosya, minimum platform uyarlamalarıyla iPhone, iPad, Mac ve Apple Watch'ta çalışır. Apple WWDC Session 101'e (2024) göre SwiftUI, App Store'daki standart UI kalıplarının %90'ından fazlasını kapsar.

SwiftUI vs UIKit

UIKit — imperatif çerçeve (2008): geliştirici bir UIViewController oluşturur, viewDidLoad'da alt görünümleri yapılandırır, UITableView için delegate/datasource uygular ve reloadData veya setNeedsLayout aracılığıyla ekranı günceller. SwiftUI, denetleyicileri basit View yapılarıyla, delegeleri bindings ve onChange ile, Auto Layout'u HStack/VStack/ZStack ve değiştiricilerle (padding, frame, offset) değiştirir. UIKit, ARC aracılığıyla manuel bellek yönetimi gerektirir; SwiftUI, referans sayımı gerektirmeyen yapılar kullanır. SwiftUI'nin performansı UIKit ile karşılaştırılabilir: çerçeve, minimum değişiklik kümeleri için bir diffing algoritması kullanır. IT Sectr'de SwiftUI, iOS 17+ hedefli yeni projeler için kullanılır; iOS 14–15 desteği olan projeler, sınırlı SwiftUI uyumluluğu nedeniyle UIKit gerektirir.

SwiftUI Bildirimsel Sözdizimi

SwiftUI'de arayüz, ViewBuilder — bir dizi View'ı bir tuple veya Group'a dönüştüren result builder aracılığıyla tanımlanır. Değiştiriciler (.padding(), .font(), .foregroundColor()) orijinal nesneyi değiştirmek yerine değiştirilmiş ayarlarla yeni View'lar oluşturur. Her değiştirici yeni bir View döndürür ve zincirlemeye olanak tanır. ViewBuilder, if/else, switch, ForEach'i destekler — ayrı denetleyiciler olmadan koşullu ve döngüsel oluşturma. SwiftUI'de View bir value type'dır (struct), öngörülebilir davranış sağlar ve yarış koşullarını ortadan kaldırır.

View Protokolü ve computed property body

View — tek bir gereksinimi olan bir protokol: some View türünde computed property body. View'a uyan her yapı, body'de ekranın kendi bölümünü tanımlar. some View türü, döndürülen View'ın somut türünü gizleyen opak bir dönüş türüdür (VStack, HStack, ZStack, Text, Image vb. yığınlama). Swift derleyicisi, somut türü derleme zamanında çıkarır ve tür silme olmadan doğrudan çağrıların performansını korur.

import SwiftUI

struct GreetingView: View {
    var name: String
    
    var body: some View {
        VStack(spacing: 12) {
            Text("Merhaba, \(name)!")
                .font(.largeTitle)
                .foregroundColor(.primary)
            
            Text("SwiftUI'ye hoş geldiniz")
                .font(.body)
                .foregroundColor(.secondary)
        }
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
                .fill(.ultraThinMaterial)
        )
    }
}

GreetingView yapısı bir name parametresi alır ve dikey bir yığında iki metin bloğu görüntüler. .font, .foregroundColor, .padding ve .background değiştiricileri görünümü yapılandırır. SwiftUI, giriş parametreleri (name) her değiştiğinde body'yi çağırır — yeniden çizim yalnızca değişen kısımlar için gerçekleşir. Örnek, .ultraThinMaterial ile RoundedRectangle kullanır — SwiftUI'ye yerleşik bir bulanıklık arka planı.

@State: SwiftUI'de Yerel Durum

@State — tek bir View'e ait yerel durumu bildiren bir property wrapper. SwiftUI, State belleğini otomatik olarak yönetir: değer değiştiğinde body yeniden çizilir, ancak yalnızca bu State'i kullanan View'lar için. State, basit türler (String, Int, Bool, enum) için gerçeğin kaynağıdır. Karmaşık veri modelleri için @State kullanmayın — bunun yerine @StateObject ve @ObservedObject kullanın. State özel olmalı ve View içinde saklanmalı, bileşenler arasında iletilmemelidir.

import SwiftUI

struct CounterView: View {
    @State private var count = 0
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Sayı: \(count)")
                .font(.system(size: 48, weight: .bold))
            
            Button(action: { count += 1 }) {
                Label("Artır", systemImage: "plus.circle")
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

Başlangıç count değeri = 0. Her düğmeye basıldığında count artar; SwiftUI otomatik olarak tüm CounterView'ı (tüm View'lar) yeniden çizer. UIKit'te benzer bir senaryo IBOutlet, IBAction ve manuel label.text güncellemeleri gerektirirdi. @State, belirli bir State değiştiğinde yalnızca View'ın yeniden çizilmesini sağlar — SwiftUI'nin diffing algoritması ağaçtaki minimum değişiklikleri bulur.

@Binding: View'lar Arasında Çift Yönlü İletişim

@Binding — bir View ile View'in sahip olmadığı veriler arasında çift yönlü bağlantı oluşturan bir property wrapper. Binding, State'e (veya başka bir gerçeğin kaynağına) bir referanstır ve alt View'in üstte depolanan değeri okumasına ve değiştirmesine olanak tanır. Binding, $ ön ekiyle belirtilir: $count, alt View'a bir Binding<Int> iletir. Binding olmadan, alt View üstün verilerini değiştiremez — yalnızca okuyabilir.

import SwiftUI

struct StepperControl: View {
    @Binding var value: Int
    let range: ClosedRange<Int>
    
    var body: some View {
        HStack {
            Button(action: { if value > range.lowerBound { value -= 1 } }) {
                Image(systemName: "minus.circle")
            }
            Text("\(value)")
                .frame(minWidth: 40)
            Button(action: { if value < range.upperBound { value += 1 } }) {
                Image(systemName: "plus.circle")
            }
        }
    }
}

struct ParentView: View {
    @State private var quantity = 5
    
    var body: some View {
        StepperControl(value: $quantity, range: 1...10)
    }
}

ParentView, State quantity'ye sahiptir ve $quantity aracılığıyla Binding iletir. StepperControl değeri değiştirebilir ve üstteki quantity otomatik olarak senkronize olur. Binding, verilerin bir kopyası değil, gerçeğin kaynağına bir köprüdür. Üst verilerini değiştirmesi gereken özel denetimler, düzenleyiciler ve yeniden kullanılabilir bileşenler için @Binding kullanın.

@ObservedObject ve @StateObject: Harici Veri Modelleri

@StateObject — ObservableObject'a uyan bir sınıfın örneğini oluşturmak ve sahiplenmek için property wrapper. View, yaşam döngüsü başına bir kez nesneyi oluşturur ve @Published özellikleri değiştiğinde yeniden çizilir. @ObservedObject — benzer bir sarmalayıcı, ancak View nesneye sahip değildir — nesne View dışında oluşturulur ve saklanır (bir başlatıcı aracılığıyla iletilir). Apple, View hiyerarşisinde gerçeğin kaynağı için @StateObject ve bağımlılık enjeksiyonu için @ObservedObject önerir.

import SwiftUI
import Combine

class UserSettings: ObservableObject {
    @Published var username: String = "Guest"
    @Published var isLoggedIn = false
}

struct ProfileView: View {
    @StateObject private var settings = UserSettings()
    
    var body: some View {
        VStack {
            TextField("Username", text: $settings.username)
                .textFieldStyle(.roundedBorder)
            
            Toggle("Logged In", isOn: $settings.isLoggedIn)
            
            if settings.isLoggedIn {
                Text("\(settings.username), hoş geldiniz!")
                    .font(.headline)
            }
        }
        .padding()
    }
}

UserSettings — iki @Published özelliğine sahip bir ObservableObject. ProfileView, @StateObject aracılığıyla nesneye sahiptir. username veya isLoggedIn'deki değişiklikler ProfileView'ı otomatik olarak yeniden çizer. @Published, SwiftUI'yi değişikliklerden haberdar etmek için Combine Publisher kullanır. Alt View'lara settings iletmek için @ObservedObject kullanın:

SwiftUI'de Data Flow: Tam Resim

Apple, SwiftUI'de dört Data Flow seviyesi tanımlar: @State (yerel, value type), @Binding (çift yönlü), @StateObject/@ObservedObject (ObservableObject ile reference type), @EnvironmentObject (global, ortam aracılığıyla enjekte edilir). EnvironmentObject, başlatıcıda açık aktarım olmadan tüm View hiyerarşisi boyunca veri iletmeye olanak tanır. Ek olarak, @AppStorage UserDefaults ile çalışır, @SceneStorage sahne durumuyla, @FetchRequest Core Data ile çalışır. Data Flow seviyesinin seçimi uygulama mimarisini belirler: basit ekranlar State/Binding kullanır, modüler olanlar ObservedObject kullanır, büyük ölçekli olanlar EnvironmentObject + Redux benzeri çözümler (TCA, Composable Architecture) kullanır.