Swift'e Giriş: Optionals, Guard Let ve If Let Kullanımı

Merhaba! Flutter ile mobil uygulama geliştirmeyi öğrendikten sonra, iOS'a özel uygulamalar için Swift öğrenmeye karar verdim. İlk günümde en çok kafamı karıştıran ama aynı zamanda Swift'in en güzel özelliklerinden biri olan Optionals konusunu öğrendim.

Optional Nedir?

Swift'te bir değişken ya değer içerir ya da hiçbir şey içermez. Bu "hiçbir şey" durumunu ifade etmek için nil kullanılır. Ancak Swift'te bir değişkenin nil olabilmesi için Optional olarak tanımlanması gerekir.

// Normal bir String - nil olamaz
var name: String = "Ahmet"

// Optional String - nil olabilir
var surname: String? = nil
surname = "Balaman"

Dart'ta ? operatörünü gördüğümüz gibi, Swift'te de aynı şekilde çalışıyor. Ancak Swift'te Optional unwrapping konusu çok daha detaylı.

Optional Unwrapping Yöntemleri

1. Force Unwrapping (!)

En basit ama aynı zamanda en tehlikeli yöntem. Eğer değer nil ise uygulama crash olur:

var age: Int? = 25

// Tehlikeli! Eğer age nil olsaydı crash olurdu
print(age!)  // 25 yazdırır

Bu yöntemi sadece %100 emin olduğunuz durumlarda kullanmalısınız. Ben genelde kullanmamaya çalışıyorum.

2. If Let - Güvenli Unwrapping

Benim en çok kullandığım yöntem. Değer varsa unwrap edip kullan, yoksa hiçbir şey yapma:

var email: String? = "[email protected]"

if let userEmail = email {
    print("Email: \(userEmail)")
    // Burada userEmail artık Optional değil, direkt String
} else {
    print("Email bulunamadı")
}

Dart'taki null-safety'ye çok benziyor aslında. Ancak Swift'te daha açık bir şekilde yazmamız gerekiyor.

3. Guard Let - Erken Çıkış

Fonksiyonlarda kullanılan ve benim çok sevdiğim bir yöntem. Değer yoksa fonksiyondan erken çık:

func printUserInfo(name: String?, age: Int?) {
    guard let userName = name else {
        print("İsim bulunamadı")
        return
    }
    
    guard let userAge = age else {
        print("Yaş bulunamadı")
        return
    }
    
    // Burada hem userName hem userAge güvenli şekilde kullanılabilir
    print("\(userName) - \(userAge) yaşında")
}

printUserInfo(name: "Ahmet", age: 25)
printUserInfo(name: nil, age: 25)  // "İsim bulunamadı" yazdırır

Guard let'in güzel yanı, kod okunabilirliğini artırması. "Eğer bu değer yoksa çık, varsa devam et" mantığı çok net.

If Let vs Guard Let - Hangisini Ne Zaman Kullanmalı?

İlk başta ikisinin de aynı işi yaptığını düşünüyordum ama aslında farklı kullanım alanları var:

If Let Kullan:

• Opsiyonel bir değere göre alternatif işlemler yapacaksan
• Değer varsa bir şey yap, yoksa başka bir şey yap mantığı

if let discount = getDiscount() {
    totalPrice = totalPrice - discount
} else {
    // İndirim yok, normal fiyattan devam
    applyNormalPrice()
}

Guard Let Kullan:

• Fonksiyonun devam edebilmesi için bir değere ihtiyaç varsa
• Değer yoksa erken return yapman gerekiyorsa
• Kod okunabilirliğini artırmak istiyorsan

func processPayment(amount: Double?, cardNumber: String?) {
    guard let paymentAmount = amount else {
        print("Ödeme tutarı gerekli")
        return
    }
    
    guard let card = cardNumber else {
        print("Kart numarası gerekli")
        return
    }
    
    // Ödeme işlemi
    chargeCard(card: card, amount: paymentAmount)
}

Nil Coalescing Operator (??)

Dart'ta da gördüğümüz bir operatör. Eğer değer nil ise varsayılan bir değer kullan:

var userName: String? = nil
var displayName = userName ?? "Misafir"

print(displayName)  // "Misafir" yazdırır

Bu operatörü özellikle UI'da çok kullanıyorum. Örneğin kullanıcı profil resmi yoksa varsayılan resim göster gibi.

Optional Chaining

Birden fazla Optional değeri zincirleme şekilde kontrol etmek için:

class User {
    var profile: Profile?
}

class Profile {
    var address: Address?
}

class Address {
    var city: String?
}

let user = User()
let cityName = user.profile?.address?.city ?? "Bilinmiyor"

Eğer zincirde herhangi bir adım nil ise, tüm sonuç nil olur. Dart'taki ?. operatörüyle aynı mantık.

İlk İzlenimlerim

Swift'in Optional sistemi ilk başta biraz zorlayıcı gelse de, aslında kodu çok daha güvenli hale getiriyor. Dart'taki null-safety'den sonra bu kavramlara alışık olduğum için adapte olmam daha kolay oldu.

Guard let özellikle benim favorim oldu. Kod okunabilirliğini inanılmaz artırıyor ve "happy path" mantığını çok güzel uyguluyor.

Şimdi sırada SwiftUI ile basit bir uygulama yapmaya çalışacağım. SwiftUI'ın Flutter'ın widget sistemiyle benzer olduğunu söylüyorlar, bakalım nasıl olacak!

Sonuç

Eğer siz de Swift öğreniyorsanız, Optional kavramını iyi anlamanızı tavsiye ederim. İlk başta karmaşık gelebilir ama iOS geliştirmede her yerde karşınıza çıkacak. Force unwrapping (!) yerine if let veya guard let kullanmaya alışın, uygulamanız daha kararlı olacaktır.

Bir sonraki yazıda SwiftUI ile ilk deneyimlerimi paylaşacağım. Görüşmek üzere!