Swift: Nedir, Sözdizimi ve Dilin Temel Kavramları

Swift Nedir?

Swift, Apple tarafından iOS, macOS, watchOS, tvOS ve visionOS için geliştirilmiş çok paradigmalı bir programlama dilidir. Dilin temel hedefleri: güvenlik, hız ve sözdizimsel ifade gücüdür. Swift, LLVM derleyicisini kullanır ve C++ ile karşılaştırılabilir performansa sahip optimize edilmiş makine kodu üretir.

2014'teki lansmanından bu yana Swift, 6 ana sürümden geçti. Swift 6 (2024), eşzamanlı kod izolasyonunun sıkı kontrolü yoluyla eksiksiz bir veri yarışı güvenliği modeli getirdi. GitHub Octoverse 2025'e göre Swift, topluluk büyümesinde ilk 10 dil arasında yer alıyor ve Apple platformlarında benimsenme hızında Rust ve Kotlin'i geride bırakıyor.

Swift açık kaynak ve çapraz platformdur — kaynak kodu GitHub'da (Swift Open Source) yayınlanmıştır. Apple platformlarının yanı sıra Swift, Linux ve Windows'ta sunucu tarafı geliştirme (Vapor, Hummingbird) için kullanılır, ancak ana alanı Apple ekosisteminde mobil ve masaüstü geliştirmedir.

Swift Neden Objective-C'nin Yerini Aldı

Geçişin ana nedenleri: Swift, Objective-C'de mümkün olan hata sınıflarının tamamını ortadan kaldırır. Tür güvenliği, derleme zamanında tür uyuşmazlıklarını önler. Optionals, nil başvuru kaldırmayı ortadan kaldırır. ARC, Objective-C'deki MRC/ARC'nin aksine ilk günden itibaren yerleşiktir. Swift sözdizimi daha kısa ve okunabilirdir — araştırmalar, eşdeğer görevler için Objective-C'ye kıyasla kod hacminde %30-40 azalma göstermektedir.

Sözdizimi ve Temel Yapılar

Temel Swift sözdizimi, tanıdık C benzeri yapıları işlevsel dillerin öğeleriyle birleştirir. Değişkenler var ile, sabitler let ile bildirilir. Derleyici tip çıkarımı kullanır, bu nedenle açık tip ek açıklaması yalnızca belirsizlik durumunda gereklidir.

import Foundation

// Sabitler ve değişkenler
let name = "Swift"
var version = 6.0
var count: Int = 42

// Varsayılan parametreli işlevler
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Erken çıkış için Guard-let
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch ve desen eşleme Swift'te C ve Kotlin'den daha güçlüdür. Switch, tuple'lar, aralıklar, where koşulları ve değer bağlama ile eşleşmeyi destekler. Derleyici tüm durumların kapsamlı bir şekilde kapsandığını kontrol eder — olası tüm değerler kapsanıyorsa default'un olmaması hata değildir.

let point = (x: 3, y: -1)

switch point {
case (0, 0):
    print("Başlangıç noktası")
case let (x, y) where x == y:
    print("X, Y'ye eşittir")
case let (x, y) where abs(y) > x:
    print("Y'nin mutlak değeri X'ten büyüktür")
default:
    print("Nokta (\(point.x), \(point.y))")
}

Optionals ve nil ile Güvenli Çalışma

Optionals, tür sistemi düzeyinde null referans sorununu çözen Swift'in merkezi bir kavramıdır. Optional, iki durumlu bir enum'dur: .none (nil) ve .some(Wrapped). Derleyici, açık kontrol olmadan Optional kullanımını yasaklayarak tüm bir çalışma zamanı hata sınıfını ortadan kaldırır.

var optionalString: String? = "Hello"
optionalString = nil  // izin verilir

// Optional Binding — güvenli çıkarma
if let text = optionalString {
    print("Metin: \(text)")
} else {
    print("Değer yok")
}

// Optional Chaining — özelliklere güvenli erişim
let length = optionalString?.count ?? 0

// Nil-coalescing operatörü
let greeting = optionalString ?? "Default"

Optional Chaining (?.) operatörü ile isteğe bağlı bir değerin yöntemlerini güvenle çağırmaya ve özelliklerine erişmeye olanak tanır. Zincir nil ile kesilirse, tüm ifadenin sonucu nil olur. Nil-coalescing (??) varsayılan bir değer sağlar ve yer tutucu metin görüntülemek için UI kodunda yaygın olarak kullanılır.

Protokoller ve Uzantılar

Protokoller Swift'te bir sözleşme tanımlar — bir dizi özellik ve yöntem. Java arayüzlerinin aksine, Swift protokolleri protokol uzantıları (protocol extensions) aracılığıyla varsayılan uygulamalara sahip olabilir. Bu, sınıf kalıtımı yerine Apple tarafından önerilen yaklaşım olan Protokol Odaklı Programlamanın temelidir.

protocol NamedEntity {
    var name: String { get }
    func description() -> String
}

// Uzantı yoluyla varsayılan uygulama
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Uzantı yoluyla uygunluk
extension String: NamedEntity {
    var name: String { return self }
}

Protokol Uzantıları, her uyumlu türü değiştirmeden bir protokole yöntem eklemeye olanak tanır. Bu, ortak yardımcı programlar eklemek için özellikle yararlıdır: Sequence için map, filter, reduce veya JSON serileştirme için Codable. Apple birçok çerçeveyi (SwiftUI, Combine) uzantılı protokoller üzerine inşa etti.

Closure'lar ve İşlevsel Zincirler

Closure'lar Swift'te, dış bağlamdan değişkenleri yakalayan anonim işlevlerdir. Sözdizimsel olarak closure'lar Kotlin'deki lambda'lara benzer ancak daha esnek bir sözdizimine sahiptir: trailing closure, kısa argüman adları ($0, $1) ve autoclosures.

// Bağlam yakalamalı closure
let numbers = [5, 3, 8, 1, 9]

// Trailing closure syntax
let sorted = numbers.sorted { $0 < $1 }

// İşlevsel zincir
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// İşlev parametresi olarak closure
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

@escaping closure'lar, closure işlev dönüşünden sonra yürütüldüğünde kullanılır — tipik olarak ağ istekleri ve eşzamansız işlemler için. @autoclosure bir ifadeyi otomatik olarak bir closure'a sarar ve assert ile kısa devre mantığında kullanılır.

Yapılar ve Sınıflar: Karşılaştırma

struct ve class arasındaki seçim, bir Swift modeli tasarlarken verilen ilk kararlardan biridir. Apple, varsayılan olarak struct (değer türü) kullanılmasını ve yalnızca kalıtım veya referans kimliği gerektiğinde class'a (referans türü) geçilmesini önerir.

Değer türleri (struct) çok iş parçacıklı ortamlarda daha güvenlidir — her iş parçacığı bağımsız bir kopya alır. Referans türleri (class) UIKit (UIView, UIViewController) ile çalışmak için gereklidir; burada referans kimliği ve sistem sınıflarından kalıtım gerekir.

ARC Bellek Yönetimi

ARC (Automatic Reference Counting), referans türleri için Swift'in bellek yönetim sistemidir. Derleyici, çalışma zamanında retain/release çağrıları ekleyerek bir nesneye olan güçlü referansların sayısını izler. Sayaç sıfıra ulaştığında nesne hemen serbest bırakılır.

ARC'nin ana sorunu döngüsel referanslardır (retain cycles). İki nesne birbirine güçlü referanslar tuttuğunda, bellek asla serbest bırakılmaz. Çözüm, zayıf referanslar (weak, serbest bırakıldığında otomatik olarak nil olur) ve sahipsiz referanslardır (unowned, nesnenin canlı olduğunu garanti eder).

class ProfileViewController: UIViewController {
    var onLogout: (() -> Void)?
    
    func setupHandler() {
        // [weak self] retain cycle'ı önler
        onLogout = { [weak self] in
            guard let self else { return }
            self.dismiss(animated: true)
        }
    }
}

Closure'larda döngüsel referansları önlemek için [weak self] kullanın ve guard let self = self else { return } ile birlikte kullanın. Bu kural UIKit'te özellikle önemlidir; ViewController özelliklerine güçlü referanslar tutar ve bu özelliklerin içindeki closure'lar ViewController'a başvurur.