Swift 4 Sabitler #9

Swift’te C, C++, Java ve C’deki gibi sabitlerin türleri yoktur. Sabitler değişkenlere atanırken onlar için uygunluk değerlendirmesi yapılmaktadır. Sabitler Swift’te 5 gruba ayrılmaktadır:

  1. Tamsayı Sabitleri (Integer Literals)
  2. Gerçek Sayı Sabitleri (Floating Point Literals)

3) Stringler (String Literals)
 4) Bool Sabitleri (Boolean Literals)
 5) Nil Sabiti (Nil Literals)

Noktası olmayan sayılar tamsayı sabitleridir. Tamsayı sabitleri deafult olarak 10'luk sistemde yazılmış gibi ele alınır. Tamsayı sabitleri Swift’te 2'lik sistemde, 8'lik sistemde ve 16'lık sistemde de belirtilebilirler. Şöyle ki:

  • Sayı 0b ile başlatılarak yazılırsa sayının 2'lik sistemde (binary) yazılmış olduğu kabul edilir.

Örneğin: 20

var x = 0b1010101 // 2lik sistemde

- Sayı 0o ile başlatılarak yazılırsa sayının 8'lik (octal) sistemde yazıldığı kabul edilir. Örneğin:

var x = 0o12345 // 8'lik sistemde

- Sayı eğer 0x ile başlatılarak yazılırsa sayının 16'lık sistemde (hexadecimal) yazıldığı kabul edilir. Sayının kaçlık sistemde yazıldığının tür bakımından bir önemi yoktur.

Swift’te sabit yazarken rakamlar arasına istenildiği kadar ‘_’ karakteri konulabilir. Bu kural gruplama yoluyla okunabilirliği artırmak için düşünülmüştür.

Örneğin:

Sayı nokta içeriyorsa böyle sabitlere gerçek sayı sabitleri denilmektedir. Gerçek sabitleri üstel biçimde ya da 16'lık sistemde belirtilebilirler. 16'lık sistemde belirtme yapılırken üstel kısım p ile 10'luk sistemde belirtme yapılırken e ile gösterilmektedir. p’nin yanındaki üstel sayı 2'nin üzeri olarak 16'lık sistemde e’nin yanındaki sayı ise 10'un üzeri olarak 10'luk sistemde yazılmak zorundadır. Örneğin:

1.23e-4
100e30
-100E30 // -100 * 10 üzeri
30 0x123.3Fp4 // 0x123.3F * 2 üzeri 4

String’ler iki tırnak içerisinde yazılan karakterlerden oluşmaktadır. Bool sabit olarak yalnızca true ve false anahtar sözcükleri bulunmaktadır. nil anahtar sözcüğü nil sabit belirtir.

Swift’te Character türünden sabitler de iki tırnak ile belirtilmektedir. Pekiyi iki tırnak içerisine biz tek bir karakter yazarsak bu String sabit olarak mı yoksa Character sabiti olarak mı değerlendirilecektir? İşte eğer biz var ya da let bildiriminde hiç tür belirtmemişsek default olarak Swift’te iki tırnak içerisinde bulunan tek karakter String olarak değerlendirilir.

Örneğin:

var a = “a” // a String türünden

Eğer biz türü Character olarak belirlemişsek bu durumda iki tırnak içerisindeki tek karakter Character sabiti olarak değerlendirilir.

Örneğin:

var ch: Character = “a” // geçerli

Tabi iki tırnak içerisinde birden fazla karakter varsa zaten o sabitin Character olma olasılığı yoktur.

Örneğin:

var ch: Character = “ab” // error!

Swift’te sabitlerin türü yoktur. Biz bir sabiti var ya da let bildirimi ile ya da daha sonra bir değişkene atıyorsak sabit o değişkenin sınırları içerisinde kalıyorsa sanki o türdenmiş gibi işlem görür, sorun oluşmaz. Kalmıyorsa error oluşur.

Seçeneksel (Optional) Türler ve nil Sabiti

Swift’te het T türünün T? biçiminde temsil edilen (tür belirten sözcükle ‘?’ karakteri bitişik yazılmak zorundadır) seçeneksel T biçimi vardır. Örneğin Int türünün seçeneksel biçimi Int? biçimindedir. String türünün seçeneksel biçimi String? biçimindedir. T? türünden bir değişken hem T türünün tüm değerlerini tutabilir hem de nil özeli değerini tutabilir.

Örneğin:

var a: Int?
a = 10 // geçerli
a = nil // geçerli

Pekiyi nil sabitinin anlamı nedir? nil sözcük olarak null ile eşanlamlıdır (yani hiçbirşey, boş, yok gibi anlamlara geliyor). Bir değişkenin içerisinde nil varsa o değişkenin içerisinde geçerli bir değer yok gibi düşünülmelidir. Örneğin:

func foo() -> Int? {
//… 
}

Biz bu foo fonksiyonunu çağırdığımızda bundan elde edeceğimiz her Int değeri bizim için anlamlı olabilir. Ancak bu fonksiyon başarısız da olabilir. İşte örneğin fonksiyon başarısız olmuşsa bize nil değerini verebilir. O halde bizim bu fonksiyonu çağırdıktan sonra geri döndürülen değerin nil olup olmadığını kontrol etmemiz gerekir.

Örneğin:

var result = foo()
if result != nil { //…
}
else {
//… }

Seçeneksel bir türün içerisindeki değer nil ile == ve != operatörleriyle karşılaştırılabilmektedir.

Swift’te Java ve C#’a benzemeyen biçimde referans türlerine biz nil yerleştiremeyiz. Onlara nil yerleştirebilmemiz için onların da seçeneksel bildirilmiş olması gerekir. Örneğin, Sample bir sınıf belirtiyor olsun:

var s: Sample //…
s = nil

Fakat örneğin:

var s: Sample? //…
// error!
s = nil // geçerli
T? türünden T türüne otomatik dönüştürme yoktur, halbuki T türünden T? türüne otomatik dönüştürme vardır. Pekiyi T? türünden bir değişkenin içerisindeki değeri nasıl alırız? Bu işleme Swift terminolojisinde “unwrapping” denilmektedir. Bunun için tek operandlı son ek ! operatörü kullanılır.
Örneğin:
var a: Int?, b: Int
a = 10 // geçerli
b = a // error
b = a! // geçerli

Pekiyi ya T? türünden değişkenin içerisinde nil varsa ne olur? İşte bu durumda program çalışırken “unwrapping” noktasında “exception” oluşur. Örneğin:

var a: Int?, b: Int
a = nil // geçerli
b = a! // geçerli, fakat exception oluşacak

O halde biz T? türünddeki değişkenin içerisinde nil olmadığından emin olurak onu “unwrap” yapmalıyız. Örneğin:

var a: Int?, b: Int
a = nil
if a != nil { b = a!
}
else {
//….
}
// geçerli

Bu işlemi bir arada yapmak için if deyimine bir özellik eklenmiştir. Bu özellik if deyiminin anlatıldığı yerde ele alınacaktır.

Ayrıca seçeneksel türlere ilişkin “seçeneksel zincir oluşturma” siminde bir erişim biçimi de vardır. Fakat bu erişim biçimi sınıf ve yapılarla ilgili olduğu için orada ele alınacaktır.

Aslında T? türü Swift’in standart kütüphanesindeki Optional<T> türü ile eşdeğerdir. Yani

var x: Int?
bildirimi ile aslında,
var x: Optional<Int>

bildirimi eşdeğerdir. Başka bir deyişle biz T? yerine eşdeğer olarak Optional<T> de kullanbiliriz. Optional<T> türü Swift’in standart kütüphanesinde enum biçiminde bildirilmiştir. enum türü ileride ele alınacaktır.

Swift’te Farklı Türlerin Birbirlerine Atanması ve Farklı Türlerin İşleme Sokulması

Swift’te otomatik dönüştürme kavramı yoktur. Bilindiği gibi Java, C# gibi dillerde bilgi kaybına yol açmayan dönüştürmeler (yani atamalar) otomatik yapılmaktadır. Örneğin C# ve Java’da int türünden bir değer long türünden bir değişkene atanabilir. Bu durumda error oluşmaz. Halbuki Swift’te bu işlem error’e yol açar.

Örneğin:

var a: Int8 = 10, b: Int32
b = a // Java ve C#’ta geçerli, Swift’te error!

Eğer biz bunu gerçekten yapmak istiyorsak teemel türlerin başlangıç metotları yoluyla (yani nesne yaratarak) yapmalıyız. Bu işlem bir tür dönüştürmesi (type cast) fakat şimdilik öyleymiş gibi düşünebilirsiniz. Örneğin:

var a: Int8 = 10, b: Int32
b = Int32(a) // bir çeşit cast gibi düşünülebilir
print(b)

Benzer biçimde biçimde büyük türden küçük türe de bu biçimde atama yapabiliriz.

Örneğin:

var a: Int8, b: Int32 = 10 
a = Int8(b)
print(a)

Fakat böylesi bir dönüştürme sırasında kaynak değer hedef türün sınırları içerisinde kalmıyorsa çalışma zamanı

sırasında exception oluşur.

Örneğin:

var a: Int8, b: Int32 = 1000
a = Int8(b) // program başarılı derlenir, fakat exception oluşur
print(a)

Swift’te farklı türleri de işleme sokamayız. Örneğin C# ve Java’da biz int bir değerle double bir değeri toplayabiliriz. Bu dillerde “işlem öncesi otomatik tür dönüştürmesiyle” küçük tür büyük türe dönüştürülür ve sonuç büyük tür türünen çıkar. Halbuki Swift’te böyle bir işlem geçerli değildir, error’le sonuçlanır.

Örneğin:

var a: Int = 10, b: Double = 20, c: Double 
c = a + b // error!

Bu işlem Swift’te şöyle yapılmalıdır

var a: Int = 10, b: Double = 20, c: Double 
c = Double(a) + b // geçerli

Like what you read? Give Özcan Akkoca a round of applause.

From a quick cheer to a standing ovation, clap to show how much you enjoyed this story.