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)