iOS – Swift Dersleri (Fonksiyonlar (Functions))

Merhaba Arkadaşlar,
Mobilhanem’deki swift paylaşımlarımıza fonksiyonlar ile devam ediyoruz. Bu paylaşımımızda fonksiyon tanımı, fonksiyon tanımlama, çağırma, fonksiyon parametreleri ve dönüş değerleri, parametre isimleri ve tipleri ile ilgili bilgiler bulacaksınız.

İlk olarak fonksiyonun tanımı ile başlayalım: Fonksiyon’u “belirli bir iş yapan kod parçası, bloğu” olarak tanımlayabiliriz. Fonksiyonun yaptığı işi tanımlayan bir ismi olması tercih edilir ve projenin diğer yerlerinden bu isim ile çağrılır. Swift’te her fonksiyonun parametre ve dönüş tiplerinden oluşan bir tanımı (tipi) vardır.

Fonksiyon tanımlama ve çağırma

Fonksiyonlar opsiyonel olarak; aldığı parametreler ve fonksiyonun işi bittikten sonra döneceği değer olan dönüş tipinden oluşur. Örnek olarak aşağıdaki fonksiyonu inceleyelim:

func sayHello(personName: String) -> String {
    let greeting = "Hello, " + personName + "!"  //fonksiyonun parametresi olan personName değeri kullanılarak greeting sabiti oluşturuluyor
    return greeting  //return ifadesi ile fonksiyondan greeting sabiti dönülüyor
}

Yukarıdaki örnekte sayHello fonksiyonun ismini, personName parametresini, “->” işareti yanındaki String ifadesi de dönüş tipini belirtir. Fonksiyon aşağıdaki gibi çağrılır:

print(sayHello("Anna"))
// ekran çıktısı "Hello, Anna!"
print(sayHello("Brian"))
// ekran çıktısı "Hello, Brian!"

Bir fonksiyon değişik parametreler ile birden fazla kere çağrılabilir. Yukarıdaki örnekten fonksiyon “Anna” ve “Brian” parametreleri ile çağrıldığında neler olduğunu görebiliriz. Yukarıdaki fonksiyonu daha da basitleştirmek için aşağıdaki gibi de yazabiliriz:

func sayHelloAgain(personName: String) -> String {
    return "Hello again, " + personName + "!"
}

Fonksiyon Parametreleri ve Dönüş Değerleri

//Bir fonksiyonun hiç parametresi olmayabilir: 
func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())
// ekran çıktısı "hello, world"


//fonksiyonun birden fazla parametresi olabilir:
func sayHello(personName: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return sayHelloAgain(personName)
    } else {
        return sayHello(personName)
    }
}
//personName parametresine "Tim" değeri geçilirken, alreadyGreeted parametresine true değeri geçiliyor.
print(sayHello("Tim", alreadyGreeted: true))
// ekran çıktısı "Hello again, Tim!"


//fonksiyonun return tipi olmayabilir, dönüş tipi olmadığı için -> işaretini koymuyoruz:
func sayGoodbye(personName: String) {
    print("Goodbye, \(personName)!")
}
sayGoodbye("Dave")
// ekran çıktısı "Goodbye, Dave!"


//fonksiyonun dönüş tipi önemsenmeyebilir:
func printAndCount(stringToPrint: String) -> Int {
    print(stringToPrint)
    return stringToPrint.characters.count
}
func printWithoutCounting(stringToPrint: String) {
    printAndCount(stringToPrint)
}
printAndCount("hello, world")
// ekran çıktısı "hello, world" ve dönüş değeri 12
printWithoutCounting("hello, world")
// ekran çıktısı "hello, world" dönüş değeri yok

//yukarıdaki örnekte her iki fonksiyonu çağrılmasında da ekran çıktısı aynı.
//printAndCount fonksiyonu bir dönüş tipine sahip olmasına rağmen bu dönüş değeri kullanılmıyor.


//fonksiyonun birden fazla dönüş değeri olabilir:
//bir dizi'yi parametre olarak alan ve bu dizideki en küçük ve en büyük değeri dönen fonksiyon örneği:
func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin { currentMin = value } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

//aşağıdaki şekilde çağrılabilir:
let bounds = minMax([8, -6, 2, 109, 3, 71])  //bounds sabitinin tipi daha önceki paylaşımlarımızda değindiğimiz tuple'dır.
print("en küçük \(bounds.min) ve en büyük \(bounds.max)")
// ekran çıktısı "en küçük -6 ve en büyük 109"

Fonksiyon Parametre İsimleri

Fonksiyon parametreleri external ve local parametre isimlerine sahip olabilir. External parametre isimleri fonksiyonun çağrıldığı yerde, local parametre isimleri de fonksiyonun içinde kullanılır. Örneğin:

//aşağıdaki örnekte kullanılan parametrelerin external ve local parametre isimleri aynıdır:
func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // firstParameterName ve secondParameterName parametreleri sırasıyla 
    // 1. ve 2. parametreleri ifade eder.
}
//aşağıdaki gibi çağrılır:
someFunction(1, secondParameterName: 2)

//bu örnekte de external parametre kullanıyoruz:
func sayHello(to person: String, and anotherPerson: String) -> String {
    //person ve anotherPerson parametreleri local parametreler ve 
    //fonksiyonun içinde kullanılıyorlar
    return "Hello \(person) ve \(anotherPerson)!"
}

//fonksiyon aşağıdaki gibi çağrılıyor. to ve and parametre isimleri external parametre isimleri.
print(sayHello(to: "Bill", and: "Ted"))
// ekran çıktısı "Hello Bill ve Ted!"

Parametrelerin default değer alması sağlanabilir. fonksiyon çağrılırken ilgili parametre gönderilmez ise default değeri ile işlem görür:

func someFunction(parameterWithDefault: Int = 12) {
    print(parameterWithDefault)
}
someFunction(6) // ekran çıktısı 6
someFunction() // ekran çıktısı 12

Variadic Parametreler

Belirli bir tipte sıfır veya daha fazla (değişken) miktarda parametre alan fonksiyon. Örnek olarak; parametre olarak verilen Double değerlerinin ortamalasını dönen bir fonksiyon yazalım:

func aritmetikOrtalama(numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// parametre olarak verilen 5 sayısının ortalamasını döner -> 3.0
arithmeticMean(3, 8.25, 18.75)
// parametre olarak verilen 3 sayısının ortalamasını döner -> 10.0

//NOT: bir fonksiyon en fazla bir tane variadic parametreye sahip olabilir.

Sabit ve Değişken Parametreler

Bir fonksiyon içinde fonksiyonun parametresini değiştirmeye çalışırsak derleyici hata verir. Böyle bir ihtiyaç; parametre olarak gelen değerin, fonksiyon içinde başka bir değişkene kopyalanarak kullanılmasıyla giderilebilir. Bu tür bir kopyalama işlemi yapmadan, parametre üzerinde değişiklik yapıp bu parametreyi fonksiyon içinde kullanmak istersek aşağıdaki gibi bir yöntem izleyebiliriz:

//string parametresinin başına var ifadesi koyarak bu parametreyi fonksiyon içinde değiştirilebilir hale getirebiliriz: 
func alignRight(var string: String, totalLength: Int, pad: Character) -> String {
    let amountToPad = totalLength - string.characters.count
    if amountToPad < 1 {
        return string
    }
    let padString = String(pad)
    for _ in 1...amountToPad {
        string = padString + string
    }
    return string
}
let originalString = "hello"
let paddedString = alignRight(originalString, totalLength: 10, pad: "-")
// paddedString değeri "-----hello"
// originalString degeri hala "hello" olarak duruyor.

In-Out Parametresi

Bir fonksiyona parametre olarak gönderdiğimiz değişkenin değerinin fonksiyon tarafından değiştirilmesi yalnızca inout parametresi ile mümkündür:

func swapTwoInts(inout a: Int, inout b: Int) {
            let temporaryA = a
            a = b
            b = temporaryA
        }
        
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, b: &anotherInt)
print("someInt degeri \(someInt), ve anotherInt degeri \(anotherInt)")
//ekran çıktısı "someInt degeri 107, ve anotherInt degeri 3"

//NOT: inout parametrelerini gönderirken & işareti ile gönderiyoruz.

Bu paylaşımımızda Swift’te fonksiyonlar ile ilgili bilgiler vermeye çalıştık. Mobilhanem‘de Swift paylaşımlarına devam edeceğiz. Bizi takipte kalın. Soru ve yorumlarınız için aşağıdaki formu kullanabilirsiniz.

Swift ile ilgili tüm paylaşımlarımıza buradan ulaşabilirsiniz.

iOS – Swift Dersleri (Methods)

Kaynak: developer.apple.com