Swift 4 Tuple’lar #13

Tuple’lar özellikle fonksiyonel dillerde çok karşılaştığımız türlerdendir. Bir tuple bir ya da birden fazla değişkenin oluşturduğu topluluktur. Tuple’lar kullanımı kolaylaştırılmış yapılara benzetilebilir. Tuple’lar tipik olarak parantezler içerisinde eleman türleri belirtilerek bildirilir. Örneğin:

var a: (Int, Double)

Burada a ilk elemanı Int, ikinci elemanı Double türden bir tuple’dır. Tuple’a değer atama parantezler içerisinde değer listesi belirtilerek yapılır. Örneğin:

var t: (Int, Double)

t = (100, 2.4)

print(t)

Tuple elemanlarına nokta operatörü ve elemanın indeks numarasıyla erişilir. İlk eleman sıfırıncı indekstedir, diğerleri bunu izlemektedir. Örneğin:

var t: (Int, Double)
t = (100, 2.4)
print(t.0) // 100
print(t.1) // 2.4

Tuple elemanlarına isim de verilebilir. Bu durumda erişim sırasında bu isimler de kullanılabilir.

Örneğin:

var pt: (x: Double, y: Double)
pt = (10.2, 4.5)
print(pt.x)
print(pt.y)

Örneğin:

var per: (name: String, no: Int)
per = (“Ali Serçe”, 123)
print(“\(per.name), \(per.no)”)

Tuple elemanlarının türleri belirtilmeyebilir. Bu durumda derleyici verilen ilk değerlerden tuple elemanlarının türlerini tespit eder.

Örneğin:

var a = (10, 20.2)
print(a.dynamicType) // (Int, Double)

Tuple elemamlarına isim ilkdeğer verilirken de verilebilir. Örneğin:

var a = (x: 10.2, y: 4.5)
print(a.x)
print(a.y)

Aynı türden ve aynı eleman isimli iki tuple birbirine atanabilmektedir. Örneğin:

var a: (x: Double, y: Double)
var b: (x: Double, y: Double)
a = (10.2, 3.2)
b = a // geçerli

Örneğin:

var a: (x: Double, y: Double)
var b: (z: Double, k: Double)
a = (10.2, 3.2)
b = a // error! Eleman isimleri aynı değil

Örneğin:

var a: (x: Double, y: Double)
a = (z: 10.2, k: 5.3) // error! eleman isimleri aynı değil

Örneğin:

var a: (name: String, no: Int) = (“Ali Serçe”, 345)
var b = (name: “Kaan Aslan”, no: 123)
a = b // geçerli

Tuple elemanlarına isim verilmemişse isim koşulunun sağlandığı kabul edilir. Örneğin:

var a = (x: 10, y: 20)
var b: (Int, Int)
b = a // geçerli
a = b // geçerli

İsimsiz elemanları joker gibi düşünebilirsiniz. İsimli elemanlara sahip tuple’larla isimsiz elemanlara sahip tuple’lar tür uyumu sağlandıktan sonra her zaman birbirlerine atanabilir. İsimli bir tuple isimsiz bir tupla’a atandığında artık atamanın yapıldığı hedef tuple isimsiz kabul edilir. Örneğin:

var pt1: (x: Int, y: Int) = (10, 20)
var pt2: (Int, Int)
pt2 = pt1
print(“\(pt1.x), \(pt1.y)”)
print(“\(pt2.x), \(pt2.y)”) // error
print(“\(pt2.0), \(pt2.1)”) // geçerli

Ancak atama işlemi bildirim ile ve tür belirtilmeden yapılıyorsa bu durumda eleman isimleri de atanan tarafa aktarılmaktadır. Örneğin:

var pt1: (x: Int, y: Int) = (10, 20)
var pt2 = pt1
print(“\(pt1.x), \(pt1.y)”)
print(“\(pt2.x), \(pt2.y)”) // geçerli

Tuple’ların belli elemanlarına isim verip belli elemanlarına isim vermeyebiliriz. Örneğin:

var rect: (Int, Int, width: Int, height: Int) = (10, 20, 100, 100)

Tabii tuple’ın elemanına isim vermiş olsak bile biz yine o elemanı indeksli bir biçimde (yani numarayla) kullanabiliriz.

Tuple elemanları let ile bildirilirse elemanların değerleri değiştirilemez. Örneğin:

let a = (10, 20.2)
a.0 = 20 // error
a.1 = 12.3 // error

Bir tuple ters bir işlemle ayrıştırılabilir (decompose edilebilir). Bunun için değişkenlerin isimleri parantezler içerisine yazılarak atama yapılmalıdır. Örneğin:

var pt = (10, 20)
var (x, y) = pt // decompose işlemi
print(x) // 10
print(y) // 20
Bunun eşdeğeri şöyledir:
var pt: (Int, Int) = (10, 20)
var x: Int = pt.0, y: Int = pt.1

Yukarıdaki ayrıştırma (decompose) işleminin aynı zamanda bir bildirim olduğuna dikkat ediniz. Örneğin:

var a = (10, 20)
var (x, y) = a // decompose işlemi
var x, y: Int // error! x ve y zaten bildirilmiş

Ayrıştırma işlemi bildirim değil atama yoluyla da yapılabilir. Örneğin:

var pt: (Int, Int) = (10, 20)
var x: Int, y: Int
(x, y) = pt // geçerli

Ayrıştırma işleminde bazı elemanlar istenmiyorsa onun yerine ‘_’ karakteri konulur. Örneğin:

var rect: (x: Int, y: Int, width: Int, height: Int) = (10, 20, 100, 100)
var (x, y, _, _) = rect

Şüphesiz tuple’ın elemanları başka bir tuple türünden olabilir. Örneğin:

var rect: (pt: (x: Int, y: Int), width: Int, height: Int) = ((10, 20), 100, 200)
print(“x = \(rect.pt.x), y = \(rect.pt.y), width = \(rect.width), \(rect.height)”)

Tuple’lar özellikle bir fonksiyonun birden fazla değerle geri döndürüleceği durumlarda tercih edilmektedir. Örneğin:

import Foundation
func getRoots(a: Double, _ b: Double, _ c: Double) -> (Double, Double)?
{
let delta = b * b — 4 * a * c
if delta < 0 {
return nil
}
let x1 = (-b + sqrt(delta)) / (2 * a)
let x2 = (-b — sqrt(delta)) / (2 * a)
return (x1, x2)
}
var a: Double, b: Double, c: Double
print(“a:”, terminator: “”)
a = Double(readLine()!)!
print(“b:”, terminator: “”)
b = Double(readLine()!)!
print(“c:”, terminator: “”)
c = Double(readLine()!)!
var result = getRoots(a, b, c)
if result == nil {
print(“gerçek kök yok”)
}
else {
print(“x1 = \(result!.0), x2 = \(result!.1)”)
}
One clap, two clap, three clap, forty?

By clapping more or less, you can signal to us which stories really stand out.