Fonksiyonlar ve closure'lar

Uygulamanda bilet fiyatını on farklı yerde hesapladığını düşün. Kurallar değiştiğinde on yeri düzeltmen gerekir ve birini mutlaka unutursun. Çözüm bir fonksiyondur: kodu bir kez yazar, ona bir ad verir ve gereken her yerde çağırırsın. print, sorted(), map gibi hazır fonksiyonları zaten kullandın; şimdi kendi fonksiyonlarını yazacaksın.

Fonksiyon tanımlamak

Fonksiyon func anahtar sözcüğüyle başlar. Parantez içine parametreler türleriyle birlikte yazılır, -> işaretinden sonra da döndürülen değerin türü gelir. return sonucu geri gönderir. Fonksiyonun gövdesi tek bir ifadeden oluşuyorsa return sözcüğünü yazmayabilirsin.

func greet(name: String) -> String {
    return "Hello, \(name)!"
}

func square(_ x: Int) -> Int {
    x * x
}

print(greet(name: "Aysel"))
print(square(7))
print(square(square(2)))

Hello, Aysel!
49
16

Argüman etiketleri ve varsayılan değerler

Swift'te çağrı bir cümle gibi okunsun diye her parametrenin iki adı olabilir: argüman etiketi (çağırırken yazılır) ve parametre adı (fonksiyonun içinde kullanılır). travel(from start: String, to end: String) fonksiyonu travel(from: "Baku", to: "Shaki") diye çağrılır. Etiket istemiyorsan yerine _ yazılır; square(7) tam olarak böyle çalışır.

Bir parametreye varsayılan değer verilebilir: çağırırken onu atlarsan bu değer kullanılır. Aşağıda bilet 12 yaşından küçükler için 5, öğrenciler için 7,5, diğer herkes için 10 manattır.

func travel(from start: String, to end: String) {
    print("Travelling from \(start) to \(end)")
}

func ticketPrice(for age: Int, isStudent: Bool = false) -> Double {
    if age < 12 {
        return 5.0
    } else if isStudent {
        return 7.5
    }
    return 10.0
}

travel(from: "Baku", to: "Shaki")
print(ticketPrice(for: 8))
print(ticketPrice(for: 20))
print(ticketPrice(for: 20, isStudent: true))

Travelling from Baku to Shaki
5.0
10.0
7.5

Closure'lar

Swift, closure'ları adım adım kısaltmana izin verir: türleri bağlamdan çıkarır, tek ifadede return istemez ve parametrelere $0, $1 adlarıyla erişmeye izin verir. Aşağıda aynı sıralama dört kez, giderek kısalarak yazılmıştır:

let double = { (x: Int) -> Int in
    return x * 2
}
print(double(5))

let numbers = [5, 2, 9, 1]
print(numbers.sorted(by: { (a: Int, b: Int) -> Bool in
    return a > b
}))
print(numbers.sorted(by: { a, b in a > b }))
print(numbers.sorted { $0 > $1 })
print(numbers.sorted(by: >))

10
[9, 5, 2, 1]
[9, 5, 2, 1]
[9, 5, 2, 1]
[9, 5, 2, 1]

Sondaki closure'lar

Bir closure fonksiyonun son argümanıysa parantezden sonra yazılabilir; buna sondaki closure (trailing closure) denir. numbers.sorted { $0 > $1 } ve prices.map { $0 * 2 } tam olarak böyle yazılmıştır. Closure alan kendi fonksiyonunu da yazabilirsin; parametresinin türü () -> Void gibi bir fonksiyon türüdür.

func repeatTask(times: Int, task: () -> Void) {
    for _ in 1...times {
        task()
    }
}

repeatTask(times: 3) {
    print("Hip hip hooray!")
}

func apply(_ value: Int, _ operation: (Int) -> Int) -> Int {
    operation(value)
}

func triple(_ x: Int) -> Int {
    x * 3
}

print(apply(4) { $0 + 10 })
print(apply(4, triple))

Hip hip hooray!
Hip hip hooray!
Hip hip hooray!
14
12

Closure'lar oluşturuldukları yerdeki değişkenleri hatırlar (İngilizcesiyle capture, yakalama). Aşağıdaki makeCounter, her çağrıda bir artan bir sayaç döndürür: count değişkeni fonksiyon bittikten sonra da closure'ın içinde yaşamaya devam eder.

func makeCounter() -> () -> Int {
    var count = 0
    return {
        count += 1
        return count
    }
}

let counter = makeCounter()
print(counter())
print(counter())
print(counter())

1
2
3