Fonksiyonlar - 3

Fonksiyonlar - 3

Variable Parametreler

Fonksiyona verilen parametreye bir atama yapılamaz.

Çözümü;

func variable(sayi:Int)

{sayi= sayi * sayi} //HATA

func variable(var sayi:Int){

sayi = sayi * sayi}

Nested Fonksiyonlar

İç içe fonksiyonlar olarak bilinir. Örnek olarak;

Kullanıcının gireceği pozitif ya da negatif sayı 0'a doğru sıralı sayması.

func nestedFonksiyon(var sayi:Int){

func azalt() //Kullanıcının pozitif değer girmesi

{ while sayi>0{

sayi = sayi -1

print(sayi)}}

func arttir() //Kullanıcının negatif değer girmesi

{ while sayi<0{

sayi = sayi + 1

print(sayi)}}

if sayi>0{

azalt()}

else if sayi<0{

arttir()}

}

                                                                              4

nestedFonksiyon(Int(testFieldSayi.text!)!) -----> 3

                                                                              2

                                                                              1

                                                                              0

//minimum ve maksimum eleman bulma [2,-3,7,9,100,5,-11] 7 elemanlı count: 7

func minMaxBul(array:[Int]) -> (min:Int,max:Int){

var minimum = array[0]

var maksimum = array[0]

for value in array[1..<array.count]{

if value < minimum{

minimum = value

}else if value > maksimum{

maksimum = value

}

}

return(minimum,maksimum)

}

let sayilar = minMaxBul(array: [2,-3,7,9,100,5,-11])

print(sayilar.min)------> -3

print(sayilar.max)-----> 100

func sum(a:Int, b:Int) -> Int{

return a+b

}

var topla:(Int,Int) -> Int = sum

print(“Sonuç = \(topla(2,3))”)

//Sonuç = 5

Fonksiyonlar Türünden Değişkenlerin Bildirilmesi

Swift’te fonksiyon türleri kategori olarak referans türlerine ilişkindir. Yani bir fonksiyon türünden değişken bir fonksiyonun adresini tutar.

Aynı türden iki fonksiyon değişkeni birbirine atandığında aslında bunların içerisindeki adresler birbirlerine atanmaktadır.

func foo(a: Int) -> Int{

return a * a

}

var f: (Int) -> Int

var g: (Int) -> Int

var result: Int

f = foo // geçerli

result = f(10)

print(result) // 100

g = f // geçerli

result = g(10)

print(result) // 100

Bir fonkisyon değişkeni yapı ya da sınıfların içerisindeki metotlarında adreslerini tutabilir. Bu durumda bizim ilgili değişkene sınıf ya da yapı değişkeni ile metot ismini nokta operatörü ile birleştirerek vermemiz gerekir.

Örneğin:

struct Sample {

var a:Int

init(a: Int){

self.a = a

}

func disp(){

print(a)

}}

var t: Sample = Sample(a: 10)

var f: () -> Void = t.disp

f() // t.disp() ile aynı anlamda

Örneğin:

struct Sample {

var a:Int

init(a: Int){

self.a = a

}

func disp(str: String){

print(“\(str): \(a)”)

}}

var t: Sample = Sample(a: 10)

var f: (String) -> Void = t.disp

f(“Value”) // t.disp(“Value”) ile aynı anlamda

Benzer biçimde statik metotlar da fonksiyon değişkenlerine sınıf ismi belirtilerek atanmalıdır:

struct Sample {

static func foo(){

print(“foo”)}}

var f: () -> Void = Sample.foo

f() // Sample.foo() ile eşdeğer

Bir fonksiyonun parametre değişkeni bir fonksiyon türünden olabilir. Örneğin:

func foo(a: Int, f: (Int) -> Int){

var result: Int

result = f(a)

print(result)}

func square(a: Int) -> Int{

return a * a}

foo(10, f: square)

Örneğin:

func forEachString(strs: [String], _ f: (String) -> ()){

for str in strs {

f(str)}}

func disp(str: String){

print(str)}

let names = [“Ali”, “Veli”, “Selami”, “Ayşe”, “Fatma”]

forEachString(names, disp)

Fonksiyonların Değişken Olarak Kullanılması (Function Type)

var obj: (Int, Int) -> Bool

func Karsilastir(a: Int, b: Int) -> Bool {

if a < b {

return true

} else {

return false } }

obj = Karsilastir

var s = obj(4, 9)