Swift Function Kullanımı

Merhaba arkadaşlar ,
mobilhanem.com sitemiz için anlattığımız/yayınladığımız Swift Dersleri serimize bu yazımızda Swift Function Kullanımı ile devam edeceğiz. Bir önceki yazımızda Swift Queue Kullanımı konusundan bahsetmiştik. Bu derse başlamadan önce xcode’u kurmak ve playground  üzerinde swift kodu yazabilmek için bu dersimizi okumanızı tavsiye ederim.

Swift Function Nedir ?

Function kelime kaşığı olarak işlev, fonksiyon demektir. Yazılarımı buraya kadar takip ettiyseniz fonksiyon kullanımına aşinasınız demektir. Şimdi ise biraz daha derine inip özelliklerini inceleyeceğiz. Peki bu fonksiyon nedir ? Fonksiyonlar, bir işi birden fazla yerde yapacağımız zaman yardımımıza koşan yapılardır. Örneğin, bir hesap makinesi uygulaması geliştiriyoruz. Burada fonksiyon kullanımı çok işimize yaracaktır. Uygulamalarda tekrar eden kodların olması iyi bir şey değildir. Hesap makinesi için bir hesapla isimli fonksiyon yazıp içine hesaplanacak olan sayıları ve yapılacak olan işlemi (toplama, çarpma..) verdikten sonra bize sonucunu döndürmesini sağlayabiliriz. Bu sayede çok daha az kod yazarak uygulamamızı gerçekleştirmiş oluruz.

Function Nasıl Tanımlanır?

Swift dilinde fonksiyonlar func keyword ‘ü ile belirtilir. Bunun ardından sırasıyla fonksiyonun ismi ,eğer paremetre alıyorsa Paremetre ve tipleri , ardından fonksiyon değer döndürüyorsa döndüreceği değerin tipi şeklinde tanımlanır.

Parametre Almayan Fonksiyonlar

Bu fonksiyonlar input olarak bir değer almazlar ve aşağıdaki gibi tanımlanırlar ,

func yasOrtalamasıBul(){
    let yas1 = 20
    let yas2 = 24
    let ortalama = (yas1 + yas2) / 2
    print(ortalama)
}

Peki yazdığımız bu yasOrtalamasıBul fonksiyonunu nasıl çağırabiliriz ?

yasOrtalamasıBul()

Şeklinde fonksiyonumuzu çağırabiliriz. Eğer yazdığımız bir fonksiyonu çağırmazsak fonksiyon hiçbir zaman çalışmaz. yasOrtalamasıBul fonksiyonumuzda yas1 ve yas2 isimli iki değişkenimiz vardır ve bu değişkenlerin ortalaması ortalama isimli bir değişkende tutulmaktadır. Ortalama ise yas1 ve yas2 değişkenlerini toplayıp 2 ye bölünerek hesaplanmaktadır. Şimdi de bu değerleri fonksiyonumuza parametre olarak nasıl verebileceğimizi görelim.

Parametre Alan Fonksiyonlar

Paremetre alan fonksiyonlar belirli bir sayıda parametre alırlar ve o parametreleri fonksiyon içerisinde kullanırlar. Şimdi ise daha karışık bir işlem üzerinde örneğimizi gerçekleştirelim ,

func hesapla(islem:String,sayi1:Int,sayi2:Int){
    switch islem {
    case "topla":
        print((sayi1 + sayi2))
    case "çarp":
        print((sayi1 * sayi2))
    case "ortalama":
        print((sayi1 + sayi2)/2)
    default:
        print("Geçersiz işlem")
    }
}

hesapla isimli fonksiyonumuzu oluşturduk . hesapla fonksiyonumuz paremetre olarak 3 farklı değer almaktadır. Bunlardan birincisi yapılacak olan işlem ve bu değişkenin tipi String olacaktır diğer paremetrelerimiz ise birinci sayı ve ikinci sayıdır ve tipleri Int ‘tir. Paremetre olarak alınacak değerlerin isimlerine sırasıyla islem, sayi1 ve sayi2 dedik. Switch case yapısı ile input olarak verilen islem değerini kontrol ederek girilen islemin ne olduğunu anlayıp ona göre o işlemi gerçekleştiren bir fonksiyon yazmış olduk. Parametre olarak  islem değerine “topla” girilirse eğer ilk case ‘imize girecek ve parametre olarak verilen sayi1 ve sayi2 değerlerini toplayıp print komutu ile ekrana bastıracaktır. Şimdi de bu işlemi yapması için fonksiyonumuzu çağıralım ,

hesapla(islem: "topla", sayi1: 10, sayi2: 20)

Ve konsolda 30 değerini gördük fonksiyonumuz toplama işlemi için düzgün çalışıyor . Şimdi de ortalama bulması için fonksiyonumuzu çağıralım ,

hesapla(islem: "ortalama", sayi1: 13, sayi2: 15)

islem değerine “ortalama” değerini girdik ve hesapla fonksiyonumuzda en son case ‘imize girecek ve paremetre olarak verdiğimiz sayi1 ve sayi2 ‘nin değerlerini toplayıp 2 ‘ye bölecek ve ardından konsola yazdıcaktır. Ve konsolumuzda 14 sayısını gördük fonksiyonumuz düzgün çalıştı. Eğer fonksiyonumuzu hiç çağırmamış olsaydık hiç bir işlem yapılmamış olacaktı.

Fonksiyonların Parametre İsimleri

Yukarıda yaptığım örnekte local parametre isimleri kullandım. Bu fonksiyonu tanımlarken kullandığımız parametrelerin isimleri, fonksiyon çağırılırkende kullanılan isimlerin aynı olmasıdır. hesapla fonksiyonumuzu tanımlarken 3 adet parametre girmiştik bunlar islem, sayi1 ve sayi2 idi. Ve çağırırkende yine aynı parametre isimlerini kullanmıştık.

External Parametre

Şimdi ise external parametre ekleyerek fonksiyonumuzu oluşturalım ve çağıralım böylelikle aradaki farkı çok daha net görebilirsiniz,

func hesapla(YapilacakOlanIslem islem:String, BirinciSayi sayi1:Int, IkinciSayi sayi2:Int){
    switch islem {
    case "topla":
        print((sayi1 + sayi2))
    case "çarp":
        print((sayi1 * sayi2))
    case "ortalama":
        print((sayi1 + sayi2) / 2)
    default:
        print("Geçersiz işlem")
    }
}

Gördüğünüz gibi pek bir farkı yok sadece input olarak alacağımız parametre isimlerimizin önüne, fonksiyonumuzu çağırırken daha anlamlı olması için gözükmesini istediğimiz değerleri giriyoruz ve daha açıklayıcı ve daha kullanışlı bir hale geliyor. Şimdi fonksiyonumuzu çağıralım ve nasıl gözüktüğünü görelim ,

hesapla(YapilacakOlanIslem: "topla", BirinciSayi: 10, IkinciSayi: 20)

Gördüğünüz gibi parametrelerin önüne ne yazdıysak fonksiyonumuzu çağırdığımız zamanda o yazdığımız değerler karşımıza çıktı.

Parametre İsmi Belirtmemek

Fonksiyonunuzu çağırırken hiç bir değer görmek istemiyorsanız _ sembolü kullanarak bu işlemi gerçekleştirebilirsiniz.

func hesapla(_ islem:String, _ sayi1:Int, sayi2:Int){
    switch islem {
    case "topla":
        print((sayi1 + sayi2))
    case "çarp":
        print((sayi1 * sayi2))
    case "ortalama":
        print((sayi1 + sayi2) / 2)
    default:
        print("Geçersiz işlem")
    }
}

sayi2 parametresinde diğerlerindeki gibi _ sembolü kullanmadı aradaki fark böylelikle daha iyi belli olur. Hemen fonksiyonumuzu çağıralım ,

hesapla("topla", 2, sayi2: 4

Gördüğünüz gibi islem ve sayi1 parametreleri için fonksiyon çağırıldığı anda bir etiket gözükmemiştir fakat sayi2 ‘nin local parametre ismi gözükmektedir. Bunun sebebi ise sayi2 için _ sembolünü kullanmamış olmamızdır.

Default Parametreler

Default parametreler, fonksiyona parametre olarak verilen değerler içerisinden birine değer verilmediği zaman belirli bir değeri kullanması için verilen değerlerdir. Hemen kullanıcının adını ve soyadını parametre olarak alıp konsola bastıran bir fonksiyon yazalım ,

func adSoyad(ad: String, soyad: String = "Belirtilmemiş") {
    print("Ad -> ",ad)
    print("Soyad ->",soyad)
}

adSoyad isimli fonksiyonumuz parametre olarak ad ve soyad almaktadır. Fakat burada soyad parametresine default olarak bir değer atanmıştır. Bu kullanıcı eğer soyadını girmez ise soyad değişkenine  bizim tarafımızdan belirlenen “Belirtilmemiş” değeri yazılmaktadır.

adSoyad(ad: "Taha")

Bu fonksiyonu yukarıdaki gibi çağırırsak fonksiyonumuz hata vermez. Eğer default parametre olarak değer girmemiş olsaydık hata ile karşılaşacaktık. Ve bu şekilde fonksiyonumuzu çağırdığımızda şu şekilde bir çıktı ile karşılaşırız ,

Ad ->  Taha

Soyad -> Belirtilmemiş

Peki soyad parametresi olarakta kullanabilir miyiz ? Tabi ki de kullanabiliriz,

adSoyad(ad: "Taha", soyad: "Buyruk")

Bu şekilde çağırdığımızda ise default olarak verdiğimiz “Belirtilmemiş” değeri göz ardı edilecek ve input olarak verilmiş olan “Buyruk” değeri ekrana bastırılacaktır. Bu şekilde çağırdığımızda ise çıktımız şu şekilde olacaktır ,

Ad ->  Taha

Soyad -> Buyruk

Variadic Parametreler

Fonksiyonun belirli bir tipte 0 veya daha fazla miktarda parametre alabilmesine imkan sağlar. Verilen sayılardan en küçüğünü bulup konsola yazdıran bir fonksiyon yazalım fakat gireceğimiz sayıların her birini parametre olarak vermeyeceğiz,

func enKucuguBul(sayilar: Int...) {
    var enKucuk: Int = 1000
    for sayi in sayilar {
        if sayi < enKucuk {
            enKucuk = sayi
        }
    }
    print("En küçük sayı -> ", enKucuk)
}

Şeklinde fonksiyonumuzu oluşturduk, input olarak vereceğimiz sayılarımıza local parametre olarak sayalar ismini verdik böylece fonksiyon çağırıldığında ve fonksiyonun içerisinde bu girilen değerlere sayilar ismi ile erişebileceğiz. Ve burada ki önemli olan nokta kaç adet sayı gireceğimizin belli olmaması ve gireceğimiz her bir sayı için ayrı bir parametre belirtmek zorunda olmayışımızdır. Bunuda local parametremizi yazıp ardından girilecek olan değerlerin tipini yazıp ardından … koyarak sağlamış olduk. Fonksiyonun içerisinde ise yapılanları kısaca açıklayalım, enKucuk isimli bir değişken oluşturduk ve değer olarak 1000 değerini verdik. Ve ardından girilen sayilar içerinde bir döndü yaptık ve ve sayilar içerisindeki her bir sayıya sayi ismini verdik. Ve basit bir if yapısı ile sayi < enKucuk koşulunu kontrol ettik eğer o anda ki sayi değeri önceden tanımladığımız enKucuk değişkenin değerinden küçük ise enKucuk değişkeninin değerini o anda ki sayi değeri yaptık ve böylece enKucuk sayıyı bulabildik.

In-Out Parametreler

In-Out parametleri, fonksiyonumuzda parametreleri yazdıktan sonra parametre tipinden hemen önce inout keyword ‘ü yazılır. Peki ne işe yarar ? inout keyword ‘ü ile fonksiyon dışında tanımlanmış olan değişkenler fonksiyonlara parametre olarak gönderilince değerlerinin değiştirilmesi sağlanır. Bu keyword belirtilmez ise fonksiyon dışında tanımlanmış olan değişkenler fonksiyona parametre olarak gönderilince fonksiyon içerisinde değerleri değiştirilemez.

func degerleriDegistir(_ a: inout Int, _ b: inout Int) {
    let geciciA = a
    a = b
    b = geciciA
}

degerleriDegistir isimli fonksiyonumuz parametre olarak verilen iki değeri bir biriyle değiştiriyor. Burada önemli olan nokta ise geriye her hangi bir değer döndürmüyor ama parametre olarak verilen değerler bir biri ile değişmiş oluyor. Şimdi değerlerini değiştireceğimiz değişkenlerimizi tanımlayalım ,

var sayi1 = 18
var sayi2 = 47

sayi1 ve sayi2 değişkenlerimizi tanımladık ve 18, 47 değerlerini atadık. Şu an sayi1 ‘in değeri 18, sayi2 ‘nin değeri ise 47 dir. Şimdi bu iki değişkeni degerleriDegistir isimli fonksiyonumuza input olarak verelim ve bakalım neler olacak.

degerleriDegistir(&sayi1, &sayi2)

Fonksiyonu tanımlarken inout keyword ‘ünü kullandığımız için fonksiyonu çağırıdığımızda verdiğimiz inputlarda & sembolü kullanılması zorunludur. Ve şimdi de print ile sonucumuzu yazdıralım ,

print("sayi1 -> \(sayi1), sayi2 -> \(sayi2)")

Çıktımız ise aşağıdaki gibidir ,

sayi1 -> 47, sayi2 -> 18

sayi1 ve sayi2 ‘nin değerleri birbiriyle değişmiş oldu.

Değer Döndüren Fonksiyonlar

Yukarıda anlattığım fonksiyonların hepsi değer döndürmeyen fonksiyonlardır. Yani fonksiyon çağırılır ve fonksiyon işlemlerini yapar ardından program akışına devam eder. Değer döndüren fonksiyonlar ise çağırılır ve fonksiyon işlemlerini yapar ve ardından döndürülmek üzere belirtilen değeri çağırıldığı yere döndürür. Değer döndürmeyen fonksiyonlara şimdide bir örnek verelim ,

func selamalama(isim: String){
    let selamlamaMesaji = "Merhaba , benim adım \(isim)"
    print(selamlamaMesaji)
}

selamlama isimli fonksiyonumuz String türünde bir parametre almaktadır ve bu parametreyede isim denmiştir. Ardından selamalamaMesaji isimli değişkenimizi oluşturduk ve  konsola yazacağımız mesajı bu değişkenimize atadık. Ve print komutu ile konsola bastırdık. Ve bu fonksiyonu aşağıdaki gibi çağırdık ,

selamalama(isim: "Taha")

Şimdi ise bu fonksiyonu geriye selamlamaMesaji değişkenini döndürecek şekilde yazalım,

func selemalama(isim: String) -> String{
    let selamlamaMesaji = "Merhaba , benim adım \(isim)"
    return selamlamaMesaji
}

Eğer fonksiyonumuz geriye değer döndürecekse alacağı parametreleri yazdıktan sonra “-> Geriye Dönecek Değerin Tipi” yazmamız gerekmektedir. Yukarıdaki gibi selamlamaMesaji değişkenimizi oluşturduktan sonra return keyword ‘ü ile geriye döndüreceğimiz değişkenimizi geriye döndürmüş olduk . Fonksiyonu yazarkenki belirttiğimiz dönüş tipi ile geriye döndürdüğümüz değişkenin tipi uyuşmak zorundadır aksi taktirde derleyicimiz hata verir. Geriye sadece değişken döndürmek zorunda değiliz , bu fonksiyonu bir başka şekildede yazabiliriz ,

func selemalama(isim: String) -> String{
    return "Merhaba , benim adım \(isim)"
}

Şeklinde de yazabiliriz. selamlamaMesaji değişkenini kullanmamış olduk daha az kod ile aynı işide yapmış olduk. Evet şimdi de u yazdığımız fonksiyonu nasıl cağırabileceğimizi görelim ,

print(selemalama(isim: "Taha"))

Şeklinde print komutunun içerisinde fonksiyonumuzu çağırdık ve fonksiyonumuzdan geriye dönen değeri print komutu ile ekrana bastırmış olduk . Fonksiyonumuzdan geriye dönen değeri bir başka değişkene atayıp ardından o değişkeni print komutu ilede konsola bastırabilirdik,

var mesaj = selemalama(isim: "Taha")
print(mesaj)

mesaj değişkenine selamlama fonksiyonumuzdan dönen değeri atamış olduk ve mesaj değişkeninide print komutu ile konsola bastırmış olduk.

Geriye Birden Çok Değer Döndüren Fonksiyonlar

Fonksiyonlar birden çok parametre alabildiği gibi geriye birden çok değer de döndürebilirler. Elimizde bir dizimizin olduğunu düşünelim ve bu dizinin maksimum ve minimum değerlerini bulmamız gerekmektedir. Fakat bu işlemi tek bir yerde değil bir çok yerde de yapacağımız için fonksiyon yazmamız gerekmektedir. İlk olarak yazacağımız fonksiyon parametre olarak bir dizi alacaktır ve geriye iki farklı değer döndürecektir. Bunlardan biri maksimum değer diğeri ise minimum değer olacaktır. Fonksiyonumuzu yazalım ,

func maksimumVeMinimumBul(dizi: [Int]) -> (enKucuk: Int, enBuyuk: Int) {
    var suankiMin = dizi[0]
    var suankiMax = dizi[0]
    for deger in dizi[1..<dizi.count] {
        if deger < suankiMin {
            suankiMin = deger
        } else if deger > suankiMax {
            suankiMax = deger
        }
    }
    return (suankiMin, suankiMax)
}

Eğer karmaşık geldiyse korkmayın sakın 🙂 Fonksiyonumuzun ismini maksimumVeMinimumBul olarak yazdık. Ve ardından parametre olarak dizi alacağını ve alacağı bu dizinin türünün Int olacağını [Int] yazarak belirttik. Ve -> sembolünü koyarak geriye ne değer döndüreceğini ve dönecek değerlerinin tipini yazdık. (enKucuk: Int, enBuyuk: Int) Dönecek olan değişkenlerimizin isimleri enKucuk ve enBuyuk ‘tur ve bunların tipi de Int olmak zorundadır.

Sonrasında ise basit bir algoritma ile dizi içerisindeki en büyük ve en küçük sayıları bulmayı başardık.

Dizi İçerisindeki En Büyük Ve En Küçük Elemanı Bulma

İlk aşamada en büyük(suankiMax) ve en küçük(suankiMin) sayı olarak dizinin ilk sırasındaki(0. index ‘inde ki) elemanı kabul ettik. Sonrasında dizinin bir sonraki elemanını suankiMin değeri ile kıyasladık eğer o anda karşılaştırılan elemanın değeri daha küçük ise, suankiMin değerini dizinin o anda karşılaştırılmış olan elemanının değerine eşitledik. Eğer değil ise aynı değer ile suankiMax değeri ile dizinin o andaki elemanının değerini karşılaştırdık , o anda karşılaştırılan deger suankiMax degerinden büyük ise suankiMax değerini o anda karşılaştırılmış olan elmanın değerine eşitledik ve bu işlemi dizinin bütün elemanlarını  yaptık ve bu işlemler bittikten sonra dizinin en büyük ve en küçük elemanlarını bulmuş olduk. return keyword ‘ü ile daha öncedende belirttiğimiz gibi suankiMin ve suankiMax değerlerini geriye döndürdük.

Şimdide yazdığımız fonksiyonu çağıralım ,

let degerler = maksimumVeMinimumBul(dizi: [18, -26, 23, 19, 3, 81])
print("En küçük sayı -> \(degerler.min)  En büyük sayı -> \(degerler.max)")

Fonksiyonumuzdan 2 adet değer dönmektedir bu dönen değerleri oluşturduğumuz degerler isimli değişkenimize atadık. Ve ardından print komutu ile ekrana bastırdık . Ekranan bastırırken degerler.min ve degerler.max diye bastırabildik. degerler değişkeninin içerisinde hem min hem max değerleri bulunmaktadır. Bu yüzden degerler değişkeninin hangi değerini bastıracağımızı .min ve .max ile belirtmek zorundayız. Belirtmez isek iki değeri de aynı anda konsola bastırır.

Burada yazdığımız min ve max kelimeleri fonksiyonumuz tanımlarken belirttiğimiz dönüş değerlerinin isimleridir.

Bu işlemleri tek bir değişken üzerinden yapmayabilir iki farklı değişlen üzerindende yapabiliriz ,

let enBuyukDeger = maksimumVeMinimumBul(dizi: [18, -26, 23, 19, 3, 81]).max
let enKucukDeger = maksimumVeMinimumBul(dizi: [18, -26, 23, 19, 3, 81]).min

print("En küçük sayı -> \(enKucukDeger)  En büyük sayı -> \(enBuyukDeger)")

Şeklinde de yapabilirdik. Burada yaptığımız ise , fonksiyonumuzdan geriye dönen iki farklı değer (min , max) değerlerini fonksiyon geriye değer döndürür döndürmez hangi değerini kullanmak istiyor ise .max veya .min  diyerek istediğimiz değeri istediğimiz bir değişkene atamaktır.

Swift’te Fonksiyon Overload Özellikleri

Bir çok programlama dillerinde olduğu gibi Swift ‘te de aynı isimli fonksiyonlar bulunabilir. Ama aşağıdaki özelliklerden en az birinin sağlanması gerekmektedir.

• Parametre sayılarının farklı olması
• Parametre türlerinin farklılığı
• External Parametre isimlerin farklılığı
• Geri dönüş türlerinin farklılığı

Şimdi de bu durumları inceleyelim.

Parametre Sayılarının Farklı Olması

func insanlarinOzellikleri(ad: String, soyad: String){
    print(ad,soyad)
}

func insanlarinOzellikleri(ad: String, soyad: String, yas: Int){
    print(ad,soyad,yas)
}

İki fonksiyonumuzun ismide insanlarinOzellikleri ‘dir fakat aldıkları parametre sayıları farklı olduğu için her hangi bir sorun yoktur. İki fonksiyonu kullandığımızda derleyici hatası ile karşılaşmayız.

Parametre Türlerinin Farklılığı

func insanlarinOzellikleri(ad: String, soyad: String, yas: Int){
    print(ad,soyad,yas)
}

func insanlarinOzellikleri(ad: String, soyad: String, yas: Double){
    print(ad,soyad,yas)
}

Bu iki fonksiyonun isimleri insanlarinOzellikleri ‘dir. Ve aldıkları parametrelerde sırasıyla ad, soyad ve yas ‘tır her şeyleri aynı olmasına rağmen bu iki fonksiyonu kullanabilmekteyiz derleyicimiz hiç bir hata vermemektedir. Bunun sebebi is aldıkları yas parametresinin türlerinin farklı olmasıdır. İlk sırada yazılmış olan fonksiyon yas parametresini Int türünde alırken altta yazılmış olan fonksiyon Double türünde almaktadır.

External Parametre İsimlerin Farklılığı

func insanlarinOzellikleri(ad: String, soyad: String, yas: Double){
    print(ad,soyad,yas)
}

func insanlarinOzellikleri(Isim ad: String,SoyIsim soyad: String,Yas yas: Double){
    print(ad,soyad,yas)
}

Bu iki fonksiyonda ise farklı olan sadece fonksiyon çağrıldığı zaman gözüken parametre isimleridir. İlk fonksiyon aşağıdaki gibi çağırılır,

insanlarinOzellikleri(ad: "Taha", soyad: "Buyruk", yas: 24.5)

İkinci fonksiyon ise ,

insanlarinOzellikleri(Isim: "Taha", SoyIsim: "Buyruk", Yas: 24.5)

Şeklinde çağırılır. Derleyicimiz her hangi bir hata vermez. Burada fonksiyonların ikisindede aynı işi yaptığımız için mantıksız duruyor 🙂

Geri Dönüş Türlerinin Farklılığı

func insanlarinOzellikleri(ad: String, soyad: String, yas: Double) -> Double{
    print(ad,soyad,yas)
    return 24.5
}

func insanlarinOzellikleri(ad: String, soyad: String, yas: Double) -> Int{
    print(ad,soyad,yas)
    return 24
}

Burada ise bütün özelliklerimiz aynı fakat tek farklı olan fonksiyonların dönüş tipleridir. İlk fonksiyonumuz Double değer döndürürken ikinci fonksiyonumuz ise Int türünde değer döndürmektedir. Ve bu da kodumuzun derlenmesine engel değildir.

Fonksiyon Tipleri

func ikiDegeriCarp(_ a: Int, _ b: Int) -> Int {
    return a * b
}

Parametre olarak verilen iki değeri çarpıp sonucunu döndüren bir fonksiyon tanımladık. Bu fonksiyonun tipi (Int, Int) -> Int ‘dır.  Ve bu fonksiyon şöyle okunur,  iki adet Int türünde parametre alan ve Int türünde değer döndüren bir fonksiyondur.

func selamlama() {
    print("Herkese merhaba")
}

selamlama fonksiyonun tipi ise () -> Void. Ve şu şekilde okunur, parametresi olmayan ve Void değerini döndüren bir fonksiyondur. (Değer döndürmez)

Fonksiyon Tiplerini Kullanma

Swift dilinde bir değişkene veya sabite, fonksiyon tanımlayabiliriz. Yukarıda yazdığımız ikiDegeriCarp isimli fonksiyonu bir değişkene atayalım ,

var matematikFonksiyonu: (Int, Int) -> Int = ikiDegeriCarp

matematikFonksiyonu isimli değişkenimiz ikiDegeriCarp isimli fonksiyonu işaret etmektedir. Peki bu matematikFonksiyonu değişkenini nasıl kullanabiliriz ?

print("Sonuç -> \(matematikFonksiyonu(3, 7))")

Ve bize çıktı olarak ,

Sonuç -> 21 vermektedir.

Şimdi de iki sayıyı toplayan bir toplama fonksiyonu yapalım ve bu yazdığımız fonksiyonu matematikFonksiyonu değişkenine atayalım.

func ikiDegeriTopla(_ a: Int, _ b: Int) -> Int {
    return a + b
}

Fonksiyonumuzu oluşturduk . Fonksiyonumuzun tipi ve okunuşu ikiDegeriCarp isimli fonksiyon ile aynıdır. Şimdide fonksiyonumuzu matematikFonksiyonu değişkenine atayalım ,

matematikFonksiyonu = ikiDegeriTopla

Ve artık matematikFonksiyonu değişkenimiz ikiDegeriCarp fonksiyonunu değil ikiDegeriTopla fonksiyonunu işaret etmektedir. Şimdi de sonucumuzu görelim ve input olarak aynı değerleri girelim ,

print("Sonuç -> \(matematikFonksiyonu(3, 7))")

Ve bize sonuç olarak ,

Sonuç -> 10 verdi. Bu iki değeri çarpmak yerine toplamış oldu.

Ve artık Swift Function Kullanımı dersimizin sonuna gelmiş bulunmaktayız. Umarım buraya kadar takip etmişsinizdir 🙂 Eğer kafanıza takılan bir şey var ise yorum kısmından sorunuzu sorabilirsiniz.

print(“The question of whether a computer can think is no more interesting than the question of whether a submarine can swim. “)

print(“Edsger Dijkstra“)