Swift 4 Deyimler, if, For, While, Switch #11

Bu bölümde Swift’teki temel deyimler ele alınacaktır. Swift’teki deyimlerde genel olarak anahtar sözcüklerden sonraki parantezler zorunlu değildir. Ancak deyimleri bloklamak (tek deyim olsa bile) zorunlu tutulmuştur. Her ne kadar deyimlerde parantez kullanımı kabul edilse de Swift stiline alışmak için parantezler kullanılmayacaktır.

if Deyimi

if deyiminin genel biçimi şöyledir:

if [(] <Bool türden ifade [)] { //…
}
 [
 else {
//… }
]

Görüldüğü gibi if anahtar sözcüğünden sonra parantezler zorunlu değildir. Fakat if deyiminde ki ifade Bool türden olmak zorundadır. if’in doğruysa ve yanlışsa kısmı bloklanmak zorundadır. if deyiminin yine else kısmı olmak zorunda değildir.

Örneğin:

print(“Lütfen bir sayı giriniz:”, terminator:””)
var val: Int = Int(readLine()!)!
if val % 2 == 0 { print(“girilen değer çift”)
} else {
 print(“girilen değer tek”)
}

else-if için blok açmaya gerek yoktur. else anahtar sözcüğünden sonra hemen if gelebilir.

Örneğin:

print(“Lütfen bir sayı giriniz:”, terminator:””)
var val: Int = Int(readLine()!)!
if val == 1 { print(“bir”)
}
 else if val == 2
print(“iki”) }
else if val == 3 print(“üç”)
}
 else {
print(“diğer
{ {
bir sayı”)
}

Örneğin ikinci derece bir denklemin köklerini bulan bir fonksiyon şöyle yazılabilir:

import Swift
import Foundation
func dispRoots(a: Double, b: Double, c: Double) {
let delta: Double = b * b — 4 * a * c
if delta < 0 {
print(“kök yok”)
} else {
}
}
var x1, x2:Double
var a = 5.0, b = 4.0, c = 3.0
var delta:Double = b * b — 4 * a * c
x1 = (-b + sqrt(delta)) / (2 * a)
x2 = (-b — sqrt(delta)) / (2 * a)
dispRoots(a: a, b: b, c: c)

Malesef Swift’in standart kütüphanesinde temel matematiksel işlemleri yapan fonksiyonlar henüz yoktur. (Muhtemelen unutulmuştur) Bu yüzden örneğimizde Cocoa’dan gelen sqrt fonksiyonu kullandık.

if deyiminin seçeneksel türlerle kullanılan değişik bir biçimi de vardır. Bu biçimde if anahtar sözcüğünü bir bildirim izler. Bu bildirimde değişkene seçeneksel bir türden ilk değer vermek zorunludur. Eğer bu seçeneksel türe verilen ilkdeğer nil değilse if doğrudan sapar, nil ise yanlıştan sapar.

Örneğin:

import Swift
import Foundation
func mysqrt(a: Double) -> Double? {
if a < 0 {
return nil
}
return sqrt(12)
}
if let result = mysqrt(a: 22) {
print(“\(result)”)
}
else {
print(“negatif sayıların gerçek kökü olmaz!”)
}

Tabi burada bildirim let yerine var anahtar sözcüğüyle yapılabilirdi. Eğer bildirim var ile yapılırsa biz bildirilen değişkene if deyiminin doğruysa kısmında değer atayabiliriz. Her hülükarda burada bildirilen değişkenin faaliyet alanı if’in doğruysa kısmına ilişkindir.

Bu biçimdeki if deyiminde verilen ilk değerin seçeneksel türe ilişkin olması zorunludur. Ayrıca bildirimdeki türün artık seçeneksel olmadığını da vurgulayalım. Yani örneğimizdeki result Double türündendir, Double? türünden değildir. Tabi istenirse bildirim sırasında tür de açıkça belirtilebilir:

if let result: Double = mysqrt(a: 22) {
print(“\(result)”)
}
else {
print(“negatif sayıların gerçek kökü olmaz!”)
}

Yukarıdaki ifadenin eşdeğeri şöyle oluşturulabilir:

var val = -23.0
var result: Double?
result = mysqrt(a: val)
if result != nil {
print(“\(result!)”)
}
else {
print(“negatif sayıların gerçek kökü olmaz!”)
}

Döngü Deyimleri

Swift’te üç döngü deyimi vardır: while döngüleri, for döngüleri ve for-in döngüleri. Yine while döngüleri kendi aralarında “kontrolün başta yapıldığı while döngüleri” ve “kontrolün sonda yapıldığı while döngüleri” biçiminde ikiye ayrılmaktadır.

Kontrolün başta Yapıldığı while Döngüleri

Swift’te while döngüleri koşul sağlandığı sürece yinelemeye yol açar. Genel biçimi şöyledir:

while [(] <Bool türden ifade> [)] {
//…
}

while anahtar sözcüğünden sonra Bool bir türden bir ifadenin bulundurulması zorunludur. Döngü bu ifade true olduğu sürece yinelemeye yol açar. Yine genel biçimden görüldüğü gibi ifadedeki parantezler zorunlu değildir. Ancak döngü deyimlerinin bloklanması zorunludur. Örneğin:

var i: Int = 0
while i < 10 {
print(“\(i) “, terminator:””)
i += 1
}
print(“”)

Kontrol Sonda Yapıldığı while Döngüleri (repeat-while)

Kontrolün sonda yapıldığı while döngüleri Swift 2.0'a kadar diğer dillerde olduğu gibi do-while anahtar sözcükleriyle kuruluyordu. Ancak swift 2.0'da do-while yerine repeat-while anahtar sözcükleri tercih edilmiştir. Semantik bir değişiklik yoktur. Döngünün genel biçimi şöyledir:

repeat {

//…

} while [(] <Bool türden ifade> [)]

Örneğin:

var i = 1
repeat {
print(i)
i += 1
} while i < 10
print(i)

for Döngüleri

for döngüleri diğer dillerdeki for döngülerine çok benzemektedir. Genel biçimleri şöyledir:

for [(] [ifade1]; [ifade2]; [ifade3] [)] {
//…
}

Sonsuz döngü while ile de oluşturulabilirdi:

while true {

//…

}

break ve continue Deyimleri

C, C++ Java ve C#’ta olduğu gibi break deyimi döngü deyiminin kendisini sonlandırmak için, continue ise döngünün içerisindeki deyimi sonlandırmak için (yani yeni bir yinelemeye geçmek için kullanılır.)

Örneğin:

var val: Int
for ;; {
print(“Bir sayı giriniz:”, terminator: “”)
val = Int(readLine()!)!
if val == 0 {
break
}
print(val * val)
}

Burada programın akışı break deyimini gördüğünde döngü sonlanır. Örneğin:

import Foundation
var val: Double
for ;; {
print(“Bir sayı giriniz:”, terminator: “”)
val = Double(readLine()!)!
if val == 0 {
break
}
if val < 0 {
print(“negatif sayıların gerçek kökleri yoktur!”)
continue
}
print(sqrt(val))
}

Burada programın akışı continue anahtar sözcüğünü gördüğünde döngü yeni bir yinelemeye girer.

İç içe döngülerde break ve continue deyimleri yalnızca kendi döngüsü için işlem yapar. Ancak Swift’te Java’da olduğu gibi etiketli break ve continue deyimleri de vardır. Böylece iç içe döngü de break ya da continue kullanırken hangi döngüden çıkılacağı ya da hangi döngü için sonraki yinelemenin yapılacağı belirtilebilir. Etiketler döngü deyimlerinin başına getirilmek zorundadır.

switch Deyimi

Swift’in switch deyimi C, C++, Java ve C#’ınkinden oldukça farklıdır. Deyimin genel biçimi şöyledir:

switch ifade {

case <ifade listesi>:

//…

case <ifade listesi>:

//…

case <ifade listesi>:

//…

default:

//…

}

switch deyimi case bölümlerinden ve default bölümünden oluşur. Deyim şöyle çalışmaktadır: Derleyici switch anahtar sözcüğünün yanındaki ifadenin değerini hesaplar. Sonra yukarıdan aşağıya doğru case bölümlerini inceler. Akışı ilk uygun olan case bölümüne aktarır. Eğer uygun case bölümü bulunamazsa default bölüm çalıştırılır. Örneğin:

var val: Int
print(“Bir sayı giriniz:”, terminator:””)
val = Int(readLine()!)!
switch val {
case 1:
print(“bir”)
case 2:
print(“iki”)
case 3:
print(“üç”)
default:
print(“diğer”)
}

Yukarıdaki örnekte ilk göze çarpan şey muhtemelen case bölümlerinin break’siz sonlandırılmış olmasıdır. Gerçekten de Swift’in switch deyiminde break olmasa da case bölümleri akış diğer case bölümüne geldiğinde otomatik sonlandırılır. (Yani başka bir deyişle case bölümlerinin sonunda sanki break varmış gibi bir etki söz konusu olmaktadır.) Default durumda switch deyiminde “fall through” yoktur. Ancak case bölümlerinde fallthrough anahtar sözcüğü kullanılırsa akış aşağıya doğru düşer. Örneğin:

var val: Int
print(“Bir sayı giriniz:”, terminator:””)
val = Int(readLine()!)!
switch val {
case 1:
print(“bir”)
fallthrough
case 2:
print(“iki”)
fallthrough
case 3:
print(“üç”)
fallthrough
default:
print(“diğer”)
}

fallthrough anahtar sözcüğünün case bölümlerinin sonuna yerleştirilmesi zorunlu tutulmamıştır. Ancak uygunsuz yerleşimlerde derleyiciler uyarı mesajı verebilirler.

Örneğin:

case 1:
ifade1
fallthrough // warning
ifade2
case 2:
//…

Tabi bir koşul altında da fallthrough uygulanabilir. Örneğin:

case 1:
ifade1
if koşul {
fallthrough
}
ifade2
case 2:
//…

Swift’in switch deyiminde tüm olasılıklar case içerisinde değerlendirilmek zorundadır. (Swift’in resmi dokümanlarında bu durum “exhaustive” sözcüğüyle ifade ediliyor). Yani başka bir deyişle switch ifadesinin her değeri için blok içerisinde çalıştırılacak bir kodun bulunması gerekir. Bu durum default bölümün kullanılma olasılığını artırmaktadır. Örneğin:

var val: Int
print(“Bir sayı giriniz:”, terminator:””)
val = Int(readLine()!)!
switch val { // error: switch must be exhaustive, consider adding a default clause
case 1:
print(“bir”)
case 2:
print(“iki”)
case 3:
print(“üç”)
}

Yukarıdaki switch deyimi derleme sırasında error oluşturacaktır. Çünkü val’ın alacağı değerlerin hepsi işlenmiş durumda değildir. Deyime eklenecek default bölümü geri kalan tüm değerlerin işleneceğini belirttiğinden error’ü ortadan kaldıracaktır.

Swift’in switch deyiminde default bölüm sonda bulunmak zorundadır. (Halbuki C, C++, Java ve C#’ta default bölüm herhangi bir yerde bulunabilir.)

Swift’te switch deyiminin case bölümleri sabit ifadesi olmak zorunda değildir. (Bu durumda aynı değere sahip case bölümlerinin olup olmadığının derleme aşamasında denetlenemeyeceğine dikkat ediniz.) Derleyici case bölümlerine sırasıyla bakar, ilk uygun case bölümünü çalıştırrır. Örneğin:

var x: Int, y: Int, val: Int
print(“x:”, terminator:””)
x = Int(readLine()!)!
print(“y:”, terminator:””)
y = Int(readLine()!)!
print(“val:”, terminator:””)
val = Int(readLine()!)!
switch val {
case x:
print(“birinci case”)
case y:
print(“ikinci case”)
default:
print(“hiçbiri”)
}

Swift’in switch deyiminin case bölümlerinde birden fazla değer bulundurulabilir. Bu durumda değerler ‘,’ atomu ile birbirinden ayrılmalıdır. Örneğin:

var val: Int
print(“Bir sayı giriniz:”, terminator:””)
val = Int(readLine()!)!
switch val {
case 1, 2, 3:
print(“bir ya da iki ya da üç”)
case 4, 5, 6:
print(“dört ya da beş ya da altı ya da yedi”)
default:
print(“hiçbiri”)
}

case bölümleri aralık da içerebilir.

Örneğin:

var val: Int
print(“Bir sayı giriniz:”, terminator:””)
val = Int(readLine()!)!
switch val {
case 1…3:
print(“bir ya da iki ya da üç”)
case 4…6:
print(“dört ya da beş ya da altı”)
default:
print(“hiçbiri”)
}

Örneğin:

var val: Int
print(“Bir sayı giriniz:”, terminator:””)
val = Int(readLine()!)!
switch val {
case 1…3, 7, 8:
print(“bir ya da iki ya da üç ya da yedi ya da sekiz”)
case 4…6, 9…10:
print(“dört ya da beş ya da altı ya da dokuz ya da on”)
default:
print(“hiçbiri”)
}

Swift’in switch deyiminde switch anahtar sözcüğünün yanındaki kontrol ifadesi gerçek sayı türlerine ilişkin olabilir, String türüne ilişkin olabilir case ifadeleri de gerçek sayı türlerinden ya da String türünden olabilir. Örneğin:

var name: String
print(“Bir isim giriniz:”, terminator: “”)
name = readLine()!
switch name {
case “Ali”:
print(“Ali seçildi”)
case “Veli”:
print(“Veli seçildi”)
case “Selami”:
print(“Selami seçildi”)
default:
print(“Bilinmeyen bir kişi seçildir”)
}

Swift’in switch deyiminde case bölümleri where koşul cümlesi ile oluşturulabilir.

Örneğin:

var val: Double
print(“Bir sayı giriniz:”, terminator:””)
val = Double(readLine()!)!
switch val {
case let x where x > 10 && x < 20:
print(“x 10 ile 20 arasında”)
case let x where x >= 20 && x < 30:
print(“x 20 ile 30 arasında”)
default:
print(“hiçbiri”)
}
One clap, two clap, three clap, forty?

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