SECTION

Swift Dili Özellikleri


Operatörler

Sabitler (Constants) VE Değişkenler (Variables)

Sabit bir program içinde değeri değişmeyen verilerdir ve Swift dilinde “let” sözcüğü ile belirtilir. Değişken ise program içinde değeri gerekiyorsa sürekli olarak değiştirilebilen veri yapısıdır ve var sözcüğü ile belirtilir.

Swift Dilinde Operatörler

Atama Operatörü:  

“=” atama operatörü ile sabitler ya da değişkenlere değer atamak mümkündür. “let” sözcüğü “sabit”, “var” sözcüğü ise “değişken” tanımlamak için kullanılır.

ÖRNEK:

                          

import Foundation

let a=7;

var b=8;

var c=a+b;

print("a=",a)

print("b=",b)

print("c=",c)

Kodun Çıktısı:

                          

a = 7

b = 8

c = 15

Bu programda a sabitine 7, b değişkenine 8 değeri atanmış ve c değişkeni ise ikisinin toplamı olarak hesaplanmıştır.

Tekli (Unary) Operatörler

Bu bölümde tekli operatörlerde, negatifini alma (-), pozitifini alma (+), artım (++) ve azalım (--) operatörlerini inceleyeceğiz. Negatifini alma operatörü (-) tek bir operand üzerinde etkili olduğu için iki operand ile işleme giren (-) sembolü ile karıştırılmamalıdır.

ARİTMETİKSEL OPERATÖRLER

Swift dilinde 4 adet matematiksel operatör mevcuttur:

Aritmetik Operatörler İşlevi
+ Toplama
- Çıkarma
/ Bölme
* Çarpma

İşlemlerde öncelik sırası soldan sağa, önce çarpma ve bölme sonra toplama ve çıkarma şeklindedir. Parantezler ile öncelik sıraları değiştirilebilir.

ÖRNEK:

                          

import Foundation

var a=7;

var b=8;

var c=a+b;

var d=a/b;

var e=a*b;

var f=a*b-c+d;

print("a=",a)

print("b=",b)

print("c=",c)

print("d=",d)

print("e=",e)

print("f=",f)

KODUN ÇIKTISI:

                          

a= 7

b= 8

c= 15

d= 0

e= 56

f= 41

7/8 işleminin sonucu her iki operand’da (7 ve 8)  int (tamsayı) türünde olduğu için 0 çıkmıştır. Eğer bu ondalık sayı olsaydı sonuç da ondalık sayı olurdu. 

ÖRNEK:

                          

import Foundation

var a=7.0;

var b=8.0;

var d=a/b;

print("a=",a)

print("b=",b)

print("d=",d)

KODUN ÇIKTISI:

                          

a= 7.0

b= 8.0

d= 0.875

Birden Çok Değişkene Değer Atama

Let ya da var tanımı ile birden çok değişkene değer atanabilir.

ÖRNEK:

                          

import Foundation 

let(a,b)=(3,8);

var (x,y)=(12,-4);

print("a=",a)

print("b=",b)

print("x=",x)

print("y=",y)

KODUN ÇIKTISI 

                          

a= 3

b= 8

x= 12

y= -4


MODÜLER ARİTMETİK 

“%” sembolü ile modüler aritmetik uygulamaları yapabilirsiniz. Bilindiği gibi x % y ifadesi x tam sayısının y tamsayısı ile bölümünden kalanı hesaplar. Örneğin 10%3 ifadesinin sonucu 1’dir.

ÖRNEK:

                          

import Foundation

let(a,b)=(3,8);

var (x,y)=(12,-4);

var z=b%a+x%y;

print("a=",a)

print("b=",b)

print("x=",x)

print("y=",y)

print("z=",z)

KODUN ÇIKTISI:

                          

a= 3

b= 8

x= 12

y= -4

z= 2

Yapılan işlemleri incelersek;

                          

8%3+12%(-4)

2+0

sonucu bulunacaktır.

BİLEŞİK(COMPOUND) ARİTMETİKSEL ATAMA OPERATÖRLERİ

Operatörler Sembolü Kullanılışı İşlem Sonucu
Atama = x=y y'nin değerini x'e ata
Topla-ata += x+=y x+y 'nin değerini x'e ata
Çıkar-ata -= x-=y x-y'nin değerini x'e ata
Çarp-ata *= x*=y x*y'nin değerini x'e ata
Böl-ata /= x/=y x/y'nin değerini x'e ata
Kalanını ata %= x%=y x%y'nin değerini x'e ata

ÖRNEK:

                          

import Foundation

var(a,b)=(3,8);

var (x,y)=(12,-4);

x+=y;

b%=a;

print("a=",a)

print("b=",b)

print("x=",x)

print("y=",y)

KODUN ÇIKTISI

                          

a= 3

b= 2

x= 8

y= -4

Yapılan işlemi incelersek;

                          

x=x+y

x=12+(-4)

x=8

ve

b=b%a

b=8%3

b=2

olarak bulunur.

KARŞILAŞTIRMA OPERATÖRLERİ

 Bu operatörler iki veriyi karşılaştırarak büyüklük, küçüklük ya da eşitlik bakımından bir sonuca varan operatörlerdir. Aşağıdaki tabloda bu operatörlerin bir listesi sunulmaktadır:

Tablo K.Karşılaştırma Operatörleri
Karşılaştırma Operatörü Anlamı
< Küçüktür
> Büyüktür
<= Küçük veya eşittir
>= Büyük veya eşittir
== Eşittir
!= Eşit değildir

Aşağıdaki tabloda bu konu örneklenmektedir:

İFADE DEĞER
-13<0 True
10>23 False
21==21 True
13!=27 True
11>=-22 True
2>10 False

ÖRNEK:

                          

import Foundation

var(a,b)=(3,8);

var (x,y)=(12,-4);

var z=3;

print("a<b=",a<b)

print("b>a=",b>a)

print("x=y =",x==7)

print("a==z =",a==z)

KODUN ÇIKTISI:

                          

a<b= true

b>a= true

x=y = false

a==z = true

Karşılaştırma işleminin sonucu doğru ise  mantıksal (logical, Boolean) bir değer olarak  “true”, yanlış ise “false” değeri bulunacaktır.

BOOLEAN TÜRÜ

Bir karşılaştırma işleminin sonucu olarak elde edilen değerdir. Doğru (true) ve yanlış (false) olmak üzere iki değer söz konusudur.

ÖRNEK:

                          

import Foundation

var x:Int=2;

var y:Int=12;

var z:Int=2;

var a=x>y;

var b=x==y;

var c=x<y;

print("a=",a);

print("b=",b);

print("c=",c);

KODUN ÇIKTISI:

                          

a= false

b= false

c= true

MANTIKSAL (LOGICAL) OPERATÖRLER

Bu operatörler 3 tanedir:

  • Mantıksal NOT (DEĞİL)   (!a)
  • Mantıksal AND (VE)    (a && b)
  • Mantıksal OR (VEYA)   (a || b) 

Aşağıdaki tablolarda bu operatörler açıklanmaktadır:

MANTIKSAL NOT

a !a
True False
False True

Yukarıdaki tabloda görüldüğü gibi ! operatörü mantıksal ifadenin doğruluk değerini değiştirir; true ise false, false ise true  yapar.

ÖRNEK:

                          

import Foundation

var x:Int=2;

var y:Int=12;

var z:Int=2;

var a=x>y;

var b=(y>=z);

print("a=",a);

print("b=",b);

print("!a=",!a);

print("!b=",!b);

KODUN ÇIKTISI:

                          

a= false

b= true

!a= true

!b= false

MANTIKSAL AND (VE)

Mantıksal VE işlemi aşağıdaki tabloda gösterilmiştir.

MANTIKSAL VE

İfade 1 İfade 2 İfade 1 && İfade 2
True True True
True False False
False True False
False False False

ÖRNEK:

                          

5>3   &&   8==8

true  &&   true

SONUÇ:

                          

TRUE

ÖRNEK:

                          

import Foundation 

var x:Int=2;

var y:Int=12;

var z:Int=2;

var a=x>y;

var b=(y>=z);

print("a=",a);

print("b=",b);

print("a && b=",a&&b);

KODUN ÇIKTISI:

                          

a= false

b= true

a && b= false

MANTIKSAL  OR (VEYA)

Aşağıdaki tabloda mantıksal OR işleminin nasıl çalıştığı açıklanmaktadır:

İfade 1 İfade 2 İfade 1 || İfade 2
True True True
True False False
False True False
False False False

4>5    ||  6>0 

false     ||  true

SONUÇ:

                             

true

ÖRNEK:

                          

import Foundation

var x:Int=2;

var y:Int=12;

var z:Int=2;

var a=x>y;

var b=(y>=z);

print("a=",a);

print("b=",b);

print("a || b=",a||b);

KODUN ÇIKTISI:

                          

a= false

b= true

a || b= true

ARALIK OPERATÖRLERİ

Swift dilinde ayrıca 2 farklı operatör de  uygulamada büyük kolaylık sağlamaktadır. Bunlar;

          Kapalı Aralık (closed Range) Operatörü: a…b

          Yarı-açık  Aralık (half-open Range))Operatörü : a..<b

Kapalı aralık operatöründe a ve b limitleri de aralığa dahildir. Yarı-açık aralık operatöründe ise a aralığa dahildir, ancak b dahil değildir.

ÖRNEK: KAPALI ARALIK 

                          

import Foundation

var i:Int;

for i in 1...5 {

    print("i=",i); 

}

KODUN ÇIKTISI  

                          

i= 1

i= 2

i= 3

i= 4

i= 5

ÖRNEK: YARI AÇIK ARALIK

                          

import Foundation

var i:Int;

for i in 1..<7 {

    print("i=",i);

}

KODUN ÇIKTISI

                          

i= 1

i= 2

i= 3

i= 4

i= 5

i= 6

Kontrol Komutları

Kontrol ya da Denetim Komutları

Bir bilgisayar programında tüm komutlar normal olarak yazılış sırasına göre çalıştırılır. Örneğin, herhangi bir programlama dilinde yazılmış olan:

K1

K2

K3

........

Kn-1

Kn

şeklindeki bir programda önce K1, sonra K2, daha sonra K3 ,..,Kn-1 ve en son da Kn çalışacaktır. Yani komutlar yazılış sırasına göre çalışırlar.

Kontrol ya da Denetim komutları yukarıda bahsedilen doğrusal akış sırasını değiştirebilen komutlardır. Örneğin K2 bir kontrol komutu olsaydı, bu komut bir koşulu kontrol ederek koşulun sonucuna göre, K3 ,K4 ve K5’i atlayarak, programın akışını doğrudan K6’ya gönderebilirdi. Bir bilgisayar programında, programın kontrolünün aradaki komutların atlanarak bir komuttan diğerine sıçramasına dallanma(jumping ya da branching)adı verilir. Bu anlamda kontrol komutları dallanmayı gerçekleştiren komutlardır. Diğer bilgisayar programlama dillerinde olduğu gibi Swift dilinde de esas olarak iki farklı tipte kontrol yapısı ya da komutu mevcuttur:

    1) Seçme(selection) işlemini gerçekleştiren kontrol komutları: Bu tip kontrol komutlarında bir ifade kontrol edilerek ifadenin değerine göre çeşitli seçeneklerden bir tanesine dallanma işlemi gerçekleştirilir. if, if else, switch case  gibi yapılar bu tür komutları oluşturur.

    2) Tekrarlama(loop).Bu tip kontrol yapılarında işlemler grubu bir koşula bağlı olarak belirli sayıda (15 kez, 35 kez vb) tekrar edilir.

SEÇME (SELECTION) TİPİNDEKİ KONTROL DEYİMLERİ

İf DEYİMİ

if deyimi Swift dilinde koşula bağlı dallanma(conditional branching) adı verilen işlemi gerçekleştir. Koşula bağlı dallanma herhangi bir programlama dili için temel kontrol yapısıdır. Bu sayede program kararlar alma imkanına kavuşur, yani bir ifadenin sonucuna göre başka bir komutlar dizisinin çalışıp çalışmayacağına karar verebilir. İfadenin değeri her çalıştırmada değişebileceği için, bu özellik bir programa farklı verilere karşı farklı şekillerde davranma imkanı sağlar. Swift  dilinde koşula bağlı dallanma if  ve else anahtar sözcükleri ile gerçekleştirilir. if deyiminin en basit şekli için yazılış biçimi aşağıdaki gibidir:

if koşul {

Deyimler

}

Örneğin,

                          

if ifade {

deyim1

}

deyim2

şeklinde kullanılmışsa; burada ifadenin değeri doğru (true) ise deyim1 çalıştırılır, sonra kod deyim2’ye geçer. İfadenin değeri yanlış (false) ise bu durumda da doğrudan deyim2’ye geçilir. İfadenin değeri yanlış ise deyim1 çalışmayacaktır. Aşağıda if yapısını açıklayan bir akış diyagramı verilmiştir.

 
K1

if deyimi için akış diyagramı(flow chart)

if komutu için ikinci biçim if/else  yapısıdır. Yazılış biçimi aşağıdaki gibidir:

                          

if (ifade)  deyim1 ;

else   deyim2;

deyim3;

...

Bu durumda ifadenin değeri doğru ise deyim1 çalıştırılır ve sonra deyim3’e geçilir. İfadenin değeri yanlış ise, bu durumda da deyim1 atlanarak doğrudan else ’i izleyen deyim2’ye geçilecek ve çalıştırıldıktan sonra da deyim3 ile devam edilecektir. Aşağıda bu yapı ile ilişkili bir akış diyagramı verilmiştir.

K2

if else deyimi için akış diyagramı (flow chart)

if deyiminde ifadenin değeri doğru olduğu zaman sadece deyim1 gibi tek bir deyim değil de bir deyimler grubunun çalıştırılması isteniyorsa bu durumda bu deyimler grubu { } sembolleri ile blok içine alınmalıdır:

                          

if(ifade)

{ deyim1;

deyim2;

..

deyim_n; }

deyim_x;

..

Bu durumda ifade doğru ise deyim1,deyim2,..deyim_n ile belirtilen grubunun tümü çalıştırılarak deyim_x ’e geçilecektir; ifade yanlış ise if ’e ait deyimler bloğu atlanarak doğrudan deyim_x ’e geçilecektir.

Aynı durum if else yapısı için de söz konusudur:

                          

if(ifade) {

Deyim1;

Deyim2;

..

deyim_n;}

else {

deyim_n+1;

deyim_n+2;

..

deyim_m;

}

deyim_k;

...

Yukarıdaki yapıda ifade doğru ise, eyim1,deyim2,..,deyim_n çalışarak deyim_k’ya geçilir. Eğer ifade yanlış ise bu durumda if içindeki deyimler atlanarak sadece deyim_n+1,deyim_n+2,..,deyim_m çalışarak program deyim_k ’ya erişecektir.

IF ELSE IF ELSE YAPISI

Bu yapının yazılış biçimi aşağıdaki gibidir:

                          

if ifade_1 {

   /* ifade_1 doğru ise çalışacak kod */

} else if ifade_2 {

   /* ifade_2 doğru ise çalışacak kod */

} else if ifade_3 {

   /* ifade_3 doğru iken çalışacak kod */

} else {

   /* Yukarıdaki ifadelerden hiçbiri doğru değilse çalışacak kod */

}

ÖRNEK:

Verilen bir sayı 1-10 aralığında ise “doğru”  değilse “yanlış” mesajını yazdıran bir Swift programı aşağıda görülmektedir.

                          

import Foundation

var sayi=5  ;

if ( sayi<=10 && sayi>=1) {

    print("doğru") ;} else {print("yanlış");}

KODUN ÇIKTISI:

                          

doğru

ÖRNEK:

X < 0   ise   ifade = x2 + x + 1
x > = 0   ise   ifade = x3 - x + 6

Bu durumlara göre x ‘in değerini hesaplayan kod aşağıda görülmektedir;

                          

import Foundation

 

var  x:Int = -5  ;

var i:Int;

if ( x<0) {  i=x*x+x+1;} else { i=x*x*x-x+6;}

print("ifade=",i);

KODUN ÇIKTISI:

                          

ifade= 21

ÖRNEK:

Bir üniversitede sayısal notlarla harf notları arasındaki ilişki aşağıdaki biçimde belirlenmektedir:

Sayısal Not Harf Notu
<50 F
>=50 ve <70 C
>=70 ve <85 B
>=85 A

Buna göre sayısal not verildiğinde harf notunu hesaplayacak Swift kodları aşağıdaki gibidir:

                          

import Foundation

var  saynot:Int = 50  ;

if  saynot<50 {  print("F");}

else if  saynot<70  {print("C");}

else if  saynot<85  {print("B");}

else {print("A");}

saynot=80;

if  saynot<50 {  print("F");}

else if  saynot<70  {print("C");}

else if  saynot<85  {print("B");}

else {print("A");} 

KODUN ÇIKTISI:

                          

C

B

SWITCH-CASE  YAPISI

Bu yapının genel yazılış biçimi,

Switch(ifade)

                          

{   case değer1: deyim1;

     case  değer2:deyim 2;

    ……

     case   değer n:deyim n;

default:  deyim n+1;

}

şeklindedir. İfadenin değeri değer1’e eşitse kontrol deyim1’e, Değer2’ye eşitse kontrol deyim2’ye geçecektir. Değer n’ye eşitse kontrol deyim n’ye geçecektir. İfadenin değeri bunlardan hiçbirine eşit olmazsa bu durumda kontrol default ’u izleyen deyim n+1’e geçecektir. Switch-case yapısı aslında birden çok if komutuna karşı gelir.

ÖRNEK:

                          

import Foundation

let KAR: Character = "x"

switch KAR

{

case "a":

    print("a  harfidir")

case "x":

    print("x harfidir")

default:

    print("başka bir harftir")

KODUN ÇIKTISI:

                          

x harfidir 

FOR-IN ÇEVRİM (LOOP) YAPISI 

Swift’te bir işlemler grubunu istenilen sayıda tekrarlamayı sağlayan komutlar mevcuttur ve bunlara çevrim (loop) komutları denir. Bunlardan en çok kullanılanı for-in loop yapısıdır. Aşağıda 1’den 7’ye kadar sayan bir program for-in loop yapısı kullanılarak yazılmıştır. 

ÖRNEK:

                          

import Foundation

for i in 1...7

{print("i=",i)

}

KODUN ÇIKTISI:

                          

i= 1

i= 2

i= 3

i= 4

i= 5

i= 6

i= 7

ÖRNEK:

                          

import Foundation

for i in 1...7 {

print("\(i) KERE 5  \(i * 5) TİR")

}

KODUN ÇIKTISI:

                          

1 KERE 5  5 TİR

2 KERE 5  10 TİR

3 KERE 5  15 TİR

4 KERE 5  20 TİR

5 KERE 5  25 TİR

6 KERE 5  30 TİR

7 KERE 5  35 TİR

ÖRNEK: TAMSAYILARIN TOPLAMININ BULUNMASI

Toplam işlemlerinde daima toplama değerine sahip olacak bir değişkene ilk değer olarak 0 atanır ve daha sonra toplanacak değerler buna eklenir. Bunu aşağıdaki gibi anlatabiliriz:

Toplam = Toplam + Eklenecek Terim

Aşağıdaki program 1’den 7’ye kadar tam sayılar toplamını (1+2+3+4+5+6+7)  bulmaktadır:

                          

import Foundation

var TOPLAM=0

for i in 1...7 {

TOPLAM=TOPLAM+i

}

print("(1+2+3+4+5+6+7)=",TOPLAM)

KODUN ÇIKTISI:

                          

(1+2+3+4+5+6+7)= 28

ÖRNEK: FAKTÖRYEL HESABI

Birden n’ye  kadar tamsayıların çarpımı, yani 1*2*3*..n   ifadesi n!  şeklinde gösterilir  ve n faktöriyel şeklinde okunur. Aşağıdaki Swift kodu bunu hesaplamaktadır. 

                          

import Foundation

var FAKT=1

for i in 1...7 {

FAKT=FAKT*i

}

print("1*2*3*4*5*6*7=",FAKT)

KODUN ÇIKTISI:

1*2*3*4*5*6*7= 5040

ÖRNEK: BN İFADESİNİ HESAPLAMAK 

Aşağıdaki örnekte 23  ifadesi hesaplatılmaktadır:

                          

import Foundation

let B = 2

let N = 3

var C = 1

for _ in 1...N {

C *= B}

print("\(B) ÜZERİ  \(N) = \(C)")

KODUN ÇIKTISI: 

                          

2 ÜZERİ  3 = 8

ÖRNEK: DİZİ ELEMANLARINA FOR ÇEVRİMİ İLE ERİŞMEK

For-in çevrim yapısı, diziler üzerinde işlem yapmak için çok uygundur. Aşağıdaki örnekte diziler üzerinde for kullanımı gösterilmiştir.

                          

import Foundation

let LISTE = ["ALİ CAN", "VELİ OKAN", "AYŞE BERTAN", "JALE ERSAN"]

for I in LISTE {

print("SAYIN, \(I)!")

}

KODUN ÇIKTISI:

                          

SAYIN, ALİ CAN!

SAYIN, VELİ OKAN!

SAYIN, AYŞE BERTAN!

SAYIN, JALE ERSAN!

ÖRNEK: BİR SÖZLÜK (DICTIONARY) YAPISINDA (ANAHTAR, DEĞER) İKİLİLERİNE ERİŞİM

For-in çevrim yapısı ile anahtar-değer ikililerini içeren sözlük yapıları üzerinde işlem yapılabilir. Aşağıda bununla ilgili bir örnek verilmiştir;

                          

import Foundation

let PERSONEL = ["ALİ CAN": 55, "AYŞE MERT": 17, "CAN OKAN": 32]

for (AD, SICIL) in PERSONEL {

print("\(AD)  ADLI PERSONELİN SİCİLİ \(SICIL) DİR")

}

KODUN ÇIKTISI:

                          

AYŞE MERT  ADLI PERSONELİN SİCİLİ 17 DİR

CAN OKAN  ADLI PERSONELİN SİCİLİ 32 DİR

ALİ CAN  ADLI PERSONELİN SİCİLİ 55 DİR

WHILE ÇEVRİMLERİ

For çevrimlerinde çevrimin kaç kere tekrar edeceği önceden bellidir.  Ancak bazı durumlarda çevirimin kaç kez tekrar edileceği önceden bilinmeyebilir. Bu gibi durumlarda while çevrimi kullanılır. While çevrimleri iki türlüdür:

  1. While çevrim(döngü-loop) yapısında koşul çevrimin her geçişinin başında kontrol edilir ve koşul doğru ise çevrim devam eder.
  2. While-repeat çevrim yapısında ise koşul her çevrim geçişi ya da tekrarının sonunda kontrol edilir; koşul doğru ise çevrim sürer, değilse çevrim sona erer.

Her iki while yapısında da koşul doğru (true) olduğu sürece çevrim bir sonsuz çevrim (infinite loop) oluşturur. Ancak koşul yanlış (false) ise çevrim dışına çıkılır.

While çevrim yapısının genel yazılış biçimi aşağıdaki gibidir:

while koşul {    deyimler}Koşul doğru olduğu sürece deyimler çalışacaktır. 

ÖRNEK:Aşağıdaki while örneğinde 1’den 5’e kadar sayılar toplanmaktadır: 

                          

import Foundation

var i=1

var top=0

while i<=5 {

    top=top+i

    i=i+1;

}

print("1+2+3+4+5=",top)

KODUN ÇIKTISI:

                          

1+2+3+4+5= 15

ÖRNEK:

For-in  yapısı ile yapılabilen her şey while yapısı ile de gerçekleştirilebilir. n!  hesabı da bunlar arasındadır:

                          

import Foundation

var i=1

var F=1

while i<=5 {

    F*=i

    i=i+1;

}

print("1*2*3*4*5=5!=",F)

KODUN ÇIKTISI:

                          

1*2*3*4*5=5!= 120

REPEAT –WHILE YAPISI 

Repeat-while kontrol yapısının genel yazılış biçimi aşağıdaki gibidir:

repeat {deyimler} while koşul

İlk başta deyimler hiç bir kontrol olmadan çalışırlar. Daha sonra koşul kontrol edilir. Koşul doğru olduğu sürece işlem sürecektir.

ÖRNEK:

Aşağıdaki repeat-while yapısı ile 1+2+3+..+10   toplamı hesaplanmaktadır:

                          

import Foundation

var S=0

var i=1

repeat {

    S+=i

    i=i+1

} while i<=10

print("1+2+3+..10=",S)

KODUN ÇIKTISI:

                          

1+2+3+..10= 55

 

Fonksiyonlar

Fonksiyonlar (Functions)

Fonksiyon  yapısı her bilgisayar programlama dilinde var olan bir yapıdır. Fonksiyon ayrı bir adı ve işlevi olan bir program parçasıdır. Swift dilinde bir fonksiyonun genel yapısı,

                          

Func    Fonk_ad(ParametreListesi)->Tür {

Swift deyimleri

Return GÖNDERİLEN_DEĞER }

şeklindedir. Bir fonksiyon kendi adı ile çağrılır. Çağıran program ya da program parçası eğer tanımlıysa bir parametre listesini veri olarak gönderir. Bu listede değişken listesi ile birlikte bu değişkenlerin tipleri de belirtilir. TÜR tanımı ile fonksiyonun hesaplama sonucu göndereceği değerin türü  belirtilir. Gönderilecek değer ise return deyiminden hemen sonra gösterilir.

Bazı fonksiyonlar için parametre listesi boş bir listedir. Bazı fonksiyonlar ise  değer göndermezler; bunlara void tipi fonksiyon denir.

ÖRNEK: KENDİSİNE GÖNDERİLEN BİR SAYININ KARESİNİ GERİ GÖNDEREN SWIFT FONKSİYONU

                          
import Foundation  
func KARE(x:Int)->Int {
       return   x * x  } 
for i in 2...5 { print("SAYI=",i  , "KARESİ=",KARE(x:i)) }

KODUN ÇIKTISI 

                          

SAYI= 2 KARESİ= 4

SAYI= 3 KARESİ= 9

SAYI= 4 KARESİ= 16

SAYI= 5 KARESİ= 25

Bu örnekte KARE adlı fonksiyon kendisine gönderilen Int türündeki x parametresinin karesini  hesaplayarak return ile x2 değerini çağıran noktaya geri göndermektedir.

ÖRNEK: VERİLEN BİR DİZİNİN EN KÜÇÜK ELEMANINI BULAN BİR FONKSİYON

                          

import Foundation

func EN_KUCUK(DIZI: [Int]) -> Int {

        var K = DIZI[0]

    for i in DIZI[1..<DIZI.count] {

        if i < K {

            K = i

        }    }

    return K

}

let N = EN_KUCUK(DIZI:[566,132,-65,74,95,6,12])

print("EN KÜÇÜK SAYI= \(N)")

KODUN ÇIKTISI

                          

EN KÜÇÜK SAYI= -65

ÖRNEK: VERİLEN BİR DİZİNİN EN BÜYÜK ELEMANINI BULAN BİR FONKSİYON

                          

import Foundation

func EN_BUYUK(DIZI: [Int]) -> Int {

        var B = DIZI[0]

    for i in DIZI[1..<DIZI.count] {

        if i > B { B = i }

    }

    return B

}

let N = EN_BUYUK(DIZI:[566,132,-65,74,95,6,12])

print("EN BUYUK SAYI= \(N)")

PROGRAMIN ÇIKTISI 

                          

EN BUYUK SAYI= 566

ÖRNEK: İKİ VEKTÖRÜN SKALER ÇARPIMI

X ve Y iki vektör ise X.Y  ifadesi X ile Y’nin skaler çarpımı olarak tanımlanır ve karşılıklı elemanların çarpımları toplamına eşittir.

Örneğin,

X=(x1,x2,x3)  ve Y=(y1,y2,y3) ise 

X.Y=x1*y1+x2*y2+x3*y3   olacaktır.

Aşağıdaki fonksiyon iki vektörün skaler çarpımını buluyor:

                          

import Foundation

func SKALER(X: [Int],Y:[Int]) -> Int {

    var s=0

           for i in 0...X.count-1 {

        s = s + X[i] * Y[i]    }

    return s

}

print("SKALER ÇARPIM=",SKALER(X:[7,4,2],Y:[3,1,5])) 

PROGRAMIN ÇIKTISI:

                          

SKALER ÇARPIM= 35

Burada iki vektörün skaler çarpımının matematiksel bir işlem olduğu ve günlük hayatta bununla hiç karşılaşılmayacağı düşünülebilir. Oysa gerçek bunun tam tersidir. Aşağıdaki örnekte bir marketten alınan ürünlerin adetleri ve fiyatları gösterilmektedir. Buradan toplam fatura bedelini hesaplarsak:

Ürün Miktar (X) 5 3 6
Fiyat (Y) 10 4 5
Tutar 50 12 30

TOPLAM=50+12+30=92 TL

Fatura bedelinin hesabı sürpriz bir biçimde SKALER ÇARPIM ile AYNIDIR. Ürün miktarları dizisine X, Fiyat dizisine de Y dersek , X.Y skaler çarpımı bize toplam fatura bedelini verecektir. Görüldüğü gibi matematik günlük hayatın her yerinde karşımıza çıkar. 

ÖRNEK: FAKTÖRYEL HESABI

1’ den n’e kadar sayıların çarpımı n! şeklinde gösterilir ve n faktöriyel olarak isimlendirilir. n değeri verildiğine göre n! değerini hesaplayacak fonksiyon aşağıdadır:

                          

import Foundation

func FAKT(n: Int)->Double {

    var f=1.0

    var ii = 1.0

    for i in 1...n

    { f = f * ii

        ii += 1.0

    }

    return f

}

for j in 3...6

{print(FAKT(n:j))

}

PROGRAMININ ÇIKTISI

                          

6.0

24.0

120.0

720.0

DEĞER GÖNDERMEYEN FONKSİYONLAR

Bazı fonksiyonlar tek bir değer hesaplamak yerine konsola bir değer yazmak, ekranda görsel işlemler yapmak için tasarlanabilir. Bu durumda bu tür fonksiyonlarda return deyiminin bulunması gerekmez. 

ÖRNEK:

                          

import Foundation

func CARP(x: Double, y: Double) {

    let z = x * y

    print("x=",x,"y=",y,"z=",z)

}

var x=4.0

var y=7.0;

for i in 1...5

{

    print(CARP(x:x,y:y))

x=x+1.0

y=y+3.0

}

KODUN ÇIKTISI

                          

= 4.0 y= 7.0 z= 28.0

()

x= 5.0 y= 10.0 z= 50.0

()

x= 6.0 y= 13.0 z= 78.0

()

x= 7.0 y= 16.0 z= 112.0

()

x= 8.0 y= 19.0 z= 152.0

()

Nesneye Yönelik Programlama

Nesneye Yönelik Programlama

Nesneye Yönelik Programlama bilgisayar yazılım teknolojisi içinde çok önemli bir adımdır ve 1980’li yıllarda ortaya çıkmış bir teknolojidir. Bugün kullanılan yazılımların büyük çoğunluğu bu teknolojiyi kullanmaktadır.

Bu teknolojiyi oluşturanlar aslında basit bir kavramı programlama ortamına sokmuşlar: NESNE. Bu mantığa göre programlama ortamında her şey nesnelerle temsil edilmiştir. NESNE (OBJECT) günlük hayatta her yerde karşımıza çıkan bir kavramdır; masa, buzdolabı, otomobil birer nesne olarak düşünülür ve bu nesnelerin bazı özellikleri vardır. Mesela masanın eni, boyu ve yüksekliği birer özelliktir (property). Gerçek dünyada bir masayı hareket ettirebiliriz. Böylece nesnelerin etkilendiği olaylar (event) ve nesne üzerine uygulanabilecek metotlar (method) karşımıza çıkar. Kuvvet uygulama bir olay (event) örneği olabilir ve hareket etme ise bir metoda örnektir.

Nesneye yönelik programlama dillerinin yazılımlara getirdiği başlıca faydaları sıralarsak;

1) Yazılımın bakım (maintenance) kolaylığı: Nesneye yönelik programlama dillerinde nesneler sınıflar içinde temsil edilirler ve ilişkili sınıflar bir araya getirilerek paketler oluşturulur. Bu sayede yazılımın bakımı, ya sınıfta bir değişiklik yapma ya da sınıf ekleme veya çıkarma şeklinde olacaktır. Bu da programın tümünü etkilemeyecektir.

2) Genişleyebilme (extensibility): Nesneye yönelik programlamada mevcut nesnelerin özelliklerinin değiştirilmesi ve nesnelere yeni özellikler eklenmesi sınıf yapısı içinde gerçekleştirilebilen oldukça kolay bir işlemdir.

3) Üretilen kodun yeniden kullanılabilirliği (reusability) : Nesneye yönelik programlamada geliştirilen sınıfları birden fazla kişi kullanabilir. Ortak kütüphaneler oluşturularak bu sınıflar tüm kullanıcıların hizmetine sunulur ve geliştirilen kodun yeniden kullanılabilirliği sağlandığı için maliyet oldukça düşecektir.

NESNEYE YÖNELİK PROGRAMLAMA TEORİSİNİN 4 TEMEL ÖZELLİĞİ

Bir dilin NESNEYE YÖNELİK PROGRAMLAMA DİLİ olabilmesi için dört temel özelliği sağlaması şarttır.

  1. I. Soyutlama (Abstraction)
  2. II. Paketleme (Encapsulation)
  3. III. Çok Biçimlilik (Polymorphism)
  4. IV. Miras Alma (Inheritance)

SWIFT bu özelliklerin hepsini sağlamaktadır ve bu nedenle saf bir Nesneye Yönelik Programlama dilidir.

Sınıflar

SINIFLAR (CLASS) VE YAPILAR (STRUCT)

Sınıf ve yapılar Swift kodları içerisinde esnek yapı bloklarıdır. Her ikisine de işlevselliği arttırmak amacı ile özellikler (properties)  ve metotlar (methods) eklenebilir. Özellikler değişkenlerle, metotlar ise fonksiyonlarla aynı anlamdadır.  Swift dili bir çok diğer dilin aksine sınıflar ve yapılar için ayrı ara yüz (interface) ya da gerçekleştirim (implementation) dosyalarının oluşturulmasına gerek duymaz. Bu yapılar aynı dosya içinde tanımlanabilir.

SINIF VE YAPININ ORTAK ÖZELLİKLERİ 

  1. Verileri saklamak için her ikisinde de özellikler(properties) tanımlanabilir.
  2. İşlevsellik amacıyla her ikisinde de metotlar (methods) tanımlanabilir.
  3. Her ikisi için de indis (subscript) tanımlanabilir.
  4. Her ikisi için de başlangıç durumunu belirlemek için başlangıç durumu atama (initialization) yapılabilir.
  5. Her ikisinin de işlevsellikleri genişletilebilir.
  6. Gerekirse özel işlevi olan protokoller (protocols) atanabilir.

SINIF VE YAPILAR ARASINDAKİ FARKLAR

Sınıf’ın sahip olduğu ama yapı içinde bulunmayan özellikler ise şunlardır:

- Miras alma (inheritance) özelliği: Bir sınıfın diğer bir sınıfın özellik ve metotlarını miras alabilmesidir.

- Çalışma sırasında bir sınıf örneğinin tipini kontrol etme imkanı sağlayan type casting özelliği

- Başlangıç durumunu iptal (Deinitialize) özelliği: Bir sınıfın ilk atama yapılmış bir örneğini gerek duyulmadığında eski bellek kaynağına iade etmesidir.

- Bir sınıf örneğine birden fazla referans ile erişebilme özelliği

SINIF TANIMI

Bir sınıf tanımının genel biçimi aşağıdaki gibidir:

                          

class   SınıfAdı{

 

//Sınıfa ait özellikler

// Metotlar

 

}

YAPI TANIMI

Aslında yapı tanımı da sınıf tanımından pek farklı değildir:

                          

struct  YapıAdı{

 

// Yapıya ait özellikler

// Metotlar

 

}

 

ÖRNEK:

Aşağıda çeşitli özellik ve metotlara sahip bir sınıf oluşturacağız ve bu sınıftan bir nesne üreteceğiz.

                          

import Foundation

class DAIRE{

var R = 3.0

func ALAN() -> Double {

return(3.14 * R * R)

}

func CEVRE() -> Double {

return(2 * 3.14 * R )

}}

var OR = DAIRE()

print("DAİRE ALANI=",OR.ALAN())

print("DAİRE ÇEVRESİ=",OR.CEVRE())

KODUN ÇIKTISI:

                          

DAİRE ALANI= 28.26

DAİRE ÇEVRESİ= 18.84

Bu örnekte DAIRE adlı bir sınıf oluşturulmuştur. Bu sınıfın R (yarıçap) adlı bir özelliği (property), ALAN() ve CEVRE() adlı iki tane metodu vardır.

DAIRE adlı sınıftan, OR adlı bir nesne oluşturulmakta ve sınıfın uygun metotları çağrılarak alanı ve çevresi hesaplanmaktadır.

DEPOLANMIŞ (STORED) VE HESAPLANMIŞ(COMPUTED) ÖZELLİKLER                

Swift’te bir sınıf içinde iki tür özellik tanımlamak mümkündür:

  1. Depolanmış özellik: var ya da let tanımlayıcısı ile tanımlanır ve ilk değer atanır.
  2. Hesaplanmış özellik: Var tanımlayıcısı ile atanır fakat ilk değer yerine bir fonksiyon tanımı atanır.

ÖRNEK:

                          

import Foundation

class DAIRE{

var YCAP = 3.0

var ALAN:Double {

return(3.14 * YCAP * YCAP)

    }

    }

 

var OR = DAIRE()

OR.YCAP=1.0

print("DAİRE ALANI=",OR.ALAN)

KODUN ÇIKTISI: 

                          

DAİRE ALANI= 3.14

Dikkat edilirse bu örnekte ALAN adlı özellik bir fonksiyon biçiminde tanımlanmıştır.

SET VE GET ÖZELLİKLERİ

Hesaplanmış özellik değeri get özelliği ile sadece okunabilir (read only) yapılabileceği gibi, set özelliği yardımı ile değer atanabilir özellik haline gelebilir.

ÖRNEK:

                          

import Foundation

class DAIRE{

    var YCAP = 2.5

    var ALAN:Double {

        get {

    return(3.14 * YCAP * YCAP)

                }

        set(Y_A) {

            YCAP = (Y_A / 3.14)

                    }

            }

    }

 

var OR = DAIRE()

print("DAİRE ALANI=",OR.ALAN)

OR.ALAN=6.28;

print("DAİRE ALANI=",OR.ALAN)

KODUN ÇIKTISI:

                          

DAİRE ALANI= 19.625

DAİRE ALANI= 12.56

Kodda önce r=2.5 yarıçap değeri için hesaplanmaktadır. Daha sonra OR.ALAN=6.28 ataması ile yarıçap 2 olarak alınır ve alan 12.56 olarak bulunmaktadır.

SINIF ELEMANLARINA İNDİS (SUBSCRIPT) İLE ERİŞME 

Sınıf yapısı içinde sınıfa ait özellikler basit, sabit ya da değişken olabileceği gibi, dizi türü veya benzeri veriler de olabilir. Bu durumda sınıf içindeki bu dizi elemanlarına indis (subscript) değeri ile erişmek mümkündür.

ÖRNEK:

                          

import Foundation

class BOLGE{

    var SEHIRLER = ["EDIRNE", "TEKIRDAĞ", "KIRKLARELI", "ISTANBUL"]

     subscript(I: Int) -> String{

                return SEHIRLER[I]

           }

    }

var S = BOLGE()

 print(S[3] )

print(S[1])

KODUN ÇIKTISI: 

                          

ISTANBUL

TEKIRDAĞ

EDİRNE TEKIRDAG KIRKLARELI ISTANBUL
0 1 2 3

SEHIRLER dizisi yukarıdaki biçimde yerleştiğine göre 0 indisli değer “EDIRNE”, 3 indisli değer ise “ISTANBUL” olur.

SET ÖZELLİĞİ KULLANILARAK GÜNCELLEME YAPMAK

Yukarıdaki örneğe benzer şekilde, dizi veri elemanı için set ve get elemanları oluşturulabilir.

ÖRNEK: 

Aşağıdaki örnekte 3 indisli şehir “ÇANAKKALE” olarak güncellenmektedir:

                          

import Foundation

class BOLGE{

    var SEHIRLER = ["EDIRNE", "TEKIRDAĞ", "KIRKLARELI", "ISTANBUL"]

     subscript(I: Int) -> String{

        get{

        return SEHIRLER[I]

        }

        set(Y_SEHIR){

        SEHIRLER[I] = Y_SEHIR

            }

        }

    }

var S = BOLGE()

print(S[2])

S[3]="ÇANAKKALE"

for j in 0...3

{print(S[j])

}

KODUN ÇIKTISI:

                          

EDIRNE

TEKIRDAĞ

KIRKLARELI

ÇANAKKALE

İLK DEĞER ATAMA: init   METODU

 Init metodu ile sınıfa ait özelliklere ilk değer ataması yapılabilir. Aşağıdaki kod ile Y_CAP adlı DAIRE sınıfı özelliğine ilk değer olarak 3 değeri atanmaktadır:

                          

import Foundation

class DAIRE{

var Y_CAP:Float

 

init(ILK_Y_CAP:Float){

Y_CAP = ILK_Y_CAP

    }

var ALAN:Float {

return(3.14 * Y_CAP * Y_CAP)

        }

    }

var OG = DAIRE(ILK_Y_CAP: 3)

print("YARIÇAP=",OG.Y_CAP)

print("ALAN=",OG.ALAN)

KODUN ÇIKTISI:

                          

YARIÇAP= 3.0

ALAN= 28.26

Deinit metodu ile bir nesneyi yok ederek kullandığı bellek alanını boş bellek alanları içine geri gönderebiliriz. Deinit  metodu aşağıdaki biçimde kullanılabilir:

                          

deinit{       

print("MESAJ")  

}

MİRAS ALMA (INHERITANCE)

Nesneye yönelik programlama dillerinde bir sınıftan yeni bir sınıf türetilebilir. Bu durumda ilk sınıfa baz ya da temel sınıf, ikinci sınıfa ise türetilmiş sınıf denir:

S1

Jenerik

Generics (Jenerik)

Jenerik kodun (Generic Code) özelliği; esnek ve yeniden kullanılabilir fonksiyonlar yazılmasını sağlamaktır. Böylece tanımladığınız gereksinimlerle uyumlu ve herhangi bir tip ile birlikte çalışabilen esnek yazılımlar üretebilirsiniz. Bu tür kodlar; tekrarlardan kaçınan ve hedefini açıkça ifade eden kodlardır. Jenerikler Swift’in en güçlü özelliklerinden biridir. Standart Swift kütüphanesinin önemli bir kısmı jenerik kod ile inşa edilmiştir.

Örneğin; Swift’in Dizi (Array) ve Sözlük (Dictionary) tipleri jenerik koleksiyonlardır. Bunların her birinin elemanlarını istediğiniz tipte oluşturabilirsiniz, oldukça esnektirler.

BİR JENERIK FONKSİYON ÖRNEĞİ

Aşağıdaki örnekte bir jenerik fonksiyon oluşturulacak ve kullanılacaktır. Geliştirilen fonksiyon iki değişkenin değerlerine yer değiştirme fonksiyonudur. Eğer A=12, B=5  ise, yer değiştirme işlemi sonunda A=5, B=12 olacaktır. Bu bilgisayar biliminde swap olarak bilinen işlemdir.

Aşağıdaki jenerik fonksiyonun en önemli özelliği, ”TİPTEN BAĞIMSIZ”  olmasıdır; yani iki argüman, Int de olsa Double da olsa String de olsa YER_DEG adlı fonksiyon her durum için de başarı ile çalışacaktır.

ÖRNEK JENERİK FONKSİYON: SWIFT KODU

                          

import Foundation

func YER_DEG<T>(_ X: inout T, _ Y: inout T) {

let GECICI = X

X = Y

Y = GECICI

}

var a=5;

var b=8;

print(a,"   ",b)

YER_DEG(&a, &b);

print(a,"   ",b)

var x=8.9;

var y=4.5;

print(x,"   ",y)

YER_DEG(&x, &y);

print(x,"   ",y)

JENERİK FONKSİYON KODUNUN ÇIKTISI:

5 8
8 5
8.9 4.5
4.5 8.9

TİP PARAMETRELERİ

                          

func YER_DEG<T>(_ X: inout T, _ Y: inout T) {

ifadesinde T tutucu (placeholder) tipi tip parametresine bir örnektir. Tip parametreleri, bir tutucu tipini belirler ve fonksiyon isminden hemen sonra gelir. Ayrıca < ve > sembolleri arasında yazılır. Tip parametresi bir kez belirlenince bu parametre, fonksiyon parametreleri ile fonksiyonun göndereceği değerde, hatta fonksiyon gövdesi içinde herhangi bir değişken için de kullanılabilir. Fonksiyon çağrıldıkça tip parametresi güncel tip ile yer değiştirir. Gerekirse birden fazla tip parametresi de tanımlanabilir.

TİP PARAMETRELERİNİ İSİMLENDİRME

Genellikle T,U,V gibi harflerle isimlendirilirler. Ayrıca aynı kod içinde birden fazla tip parametresi de bulunabilir. Aşağıdaki örnek kod içinde tip parametresi olarak T ve U harfleri kullanılmıştır. İki ayrı jenerik; YER_DEG  ve DEG_YER fonksiyonlardır:

                          

import Foundation

func YER_DEG<T>(_ X: inout T, _ Y: inout T) {

    let GECICI = X

    X = Y

    Y = GECICI

}

func DEG_YER<U>(_ A: inout U, _ B: inout U) {

    let GECICI = A

    A = B

    B = GECICI

}

var a=5;

var b=8;

print(a,"   ",b)

YER_DEG(&a, &b);

print(a,"   ",b)

var x=8.9;

var y=4.5;

print(x,"   ",y)

 

YER_DEG(&x, &y);

print(x,"   ",y)

var aa=5;

var bb=8;

print(aa,"   ",bb)

DEG_YER(&aa, &bb);

print(aa,"   ",bb)

var ax=8.9;

var ay=4.5;

print(ax,"   ",ay)

 

DEG_YER(&ax, &ay);

print(ax,"   ",ay)

 

KODUN ÇIKTISI:

5 8
8 5
8.9 4.5
4.5 8.9
5 8
8 5
8.9 4.5
4.5 8.9

Protokol

Swift’te protokoller diğer dillerdeki ara yüzlere (interface) benzerler. Protokoller bir grup davranışı onların gerçekleşmesine bağlı olmadan tanımlar. Bu davranışların gerçekleşmeleri ise önceki bölümlerde anlatılan sınıf, yapı ya da sayma (Enum) yapıları ile olur.

Protokoller protocol sözcüğü ile tanımlanır. Tanımlanan protokollerin gerçekleştirilmesine protokolün onaylanması denir. Tanımlanan özelliklerin  “set”, “get” ya da her iki türde gerçekleştirimi mümkündür.

ÖRNEK:

Aşağıdaki Swift kodu protokolün gerçekleştirilmesi ve kullanımı konusunda fikir verecektir:

                          

import Foundation

protocol MOTOR_TASIT{

var HIZ:Int { get set }

       var KAPASITE:Int { get }

       func MESAJ() -> String

    }

 

 class UCAK: MOTOR_TASIT{

        var HIZ = 750

        var KAPASITE = 180

   

         func MESAJ() -> String {

                return "AIRBUS 320"

           }

     }

 

let jet1 = UCAK() // 750-180

print(jet1.HIZ)

print(jet1.KAPASITE)

print(jet1.MESAJ())

KODUN ÇIKTISI

                          

750

180

AIRBUS 320

Koleksiyonlar

Koleksiyonlar (Collections)

Koleksiyonlar grup halinde veri içeren, elemanlarına bir indis yardımı ile erişilebilen, dinamik içerikli yapılardır.

Koleksiyonlar 3 ayrı gruba ayrılabilir:

  1. Diziler (arrays)
  2. Kümeler (sets)
  3. Sözlükler (dictionaries)

DİZİLER

Ortak bir isim altında bir grup veriyi bir araya toplayan yapılardır. Dizinin farklı elemanlarına erişmek için bir indis (subscript)  kullanmak gerekir. Aşağıda 5 elemanlı SEHIRLER adlı bir dizi vardır ve bu dizinin eleman indisleri, 0,1,2,3 ve 4 değerlerini alır:

SEHIRLER
ANKARA İSTANBUL BURSA İZMİR EDİRNE
0 1 2 3 4

Aşağıdaki Swift kodu bu diziyi oluşturur ve listeler:

                          

import Foundation

let SEHIRLER: [String] = ["ANKARA", "İSTANBUL", "BURSA", "İZMİR","EDİRNE"]

for i in 0...4

{print(SEHIRLER[i])

}

PROGRAMIN ÇIKTISI

                          

ANKARA

İSTANBUL

BURSA

İZMİR

EDİRNE

print(SEHIRLER.first!)

DİZİNİN ELEMAN SAYISI

Dizinin eleman sayısını kod çalışırken bulmak için ,count metodu kullanılır:

                          

print(SEHIRLER.count)

Bu komut sonucunda eleman sayısı 5 olarak listelenecektir.

SÖZLÜK (DICTIONARY)

Sözlükler, erişimin bir anahtar (key) ile gerçekleştirildiği koleksiyonlardır. Genel olarak anahtarlar String türünde olur, fakat farklı Swift tiplerinden olmaları da mümkündür.

Aşağıdaki örnekte String türü anahtar ve Int türü bir değerden  oluşturulan bir sözlük görülmektedir:

                          

import Foundation

let PERS = ["ALI": 14, "HAKAN": 15, "AYŞE": 11, "BERNA": 16,"MERT":17]

print(PERS["AYŞE"]!)

print(PERS["HAKAN"]!)

Programın çıktısı ise aşağıdadır:

                          

11

15

Diziler sözlükler içinde ya da sözlükler diziler içinde saklanabilir:

SET (KÜME) YAPILARI

Bu yapılar matematikteki küme yapıları ile benzerlik gösterir. Her elemandan sadece bir tane olmalıdır; birden fazla olduğu takdirde küme bir tanesini yazacaktır. Küme elemanları sıralı değildir.

Aşağıdaki örnekte SEHIR adlı bir küme oluşturulmakta ve yazdırılmaktadır. Swift’te küme yapısı teknik olarak dizi yapısı gibidir:

                          

import Foundation

let SEHIR: Set<String> = ["VIYANA", "ROMA", "PARIS", "LONDRA","PARIS"]

print(SEHIR)

ÖRNEK KODUN ÇIKTISI İSE AŞAĞIDADIR:

                          

["ROMA", "VIYANA", "LONDRA", "PARIS"]

Küme elemanlarına dizilerde olduğu gibi indis aracılığı ile erişemeyiz. Swift’in yapısında bulunan insert metodu ile diziye eleman eklenebilir. remove metodu ile kümeden eleman silinir. contains metodu ile de bir elemanın kümede mevcut olup olmadığını anlayabiliriz.

ÖRNEK:

                          

import Foundation

var SEHIR: Set<String> = ["VIYANA", "ROMA", "PARIS", "LONDRA","PARIS"]

print(SEHIR)

SEHIR.insert("STOCKHOLM")

SEHIR.insert("KOPENHAG")

SEHIR.remove("ROMA")

print(SEHIR)

print(SEHIR.contains("VIYANA"))

print(SEHIR.contains("MADRID"))

ÖRNEK KODUN ÇIKTISI:

                          

["ROMA", "VIYANA", "LONDRA", "PARIS"]

["STOCKHOLM", "VIYANA", "KOPENHAG", "LONDRA", "PARIS"]

true

false

Bir  katalog düzenlemek için küme (SET) veri yapısı idealdir; çünkü kataloglarda tekrar eden elemanlar istenmez.

TUPLE (SATIR)

Literatürde tuple ilişkisel bir veri tabanı tablosunun bir satırı anlamındadır; biz de tuple karşılığı olarak satır terimini kullanacağız.

Swift’te tuple veya satır kavramı ile temsil edilen veri yapısı kendisine bir isim verilmiş ve parantez içinde çok sayıda eleman içeren bir veri grubudur. Satır elemanlarına “.”  operatörü ve indisler yardımı ile erişilebilir:

ÖRNEK SWIFT KODU:

                          

import Foundation

var EKIP=("ALI OKAN", "MERT CANER","AYSE MERTOL")

print(EKIP.2)

print(EKIP.0)

print(EKIP.1) 

ÖRNEK KODUN ÇIKTISI

                          

AYSE MERTOL

ALI OKAN

MERT CANER

Bir satır birden çok değişkene atanabilir:

                          

import Foundation

var EKIP=("ALI OKAN", "MERT CANER","AYSE MERTOL")

var (ILK,ORTA,SON)=("ALI OKAN", "MERT CANER","AYSE MERTOL")

print(ILK)

print(ORTA)

print(SON) 

KODUN ÇIKTISI:

ALI OKAN

MERT CANER

AYSE MERTOL

Sayma (Enum) Veri Tipi


Bir çok programlama dilinde mevcut olan enum (sayma) veri tipi Swift’te de mevcuttur. Enum veri tipi; bir grup veriye bir isim vererek onlara sistematik olarak erişim sağlar. Diğer bazı dillerden farklı olarak Swift’te enum veri tipine sayısal değerler atanmaz.
Enum Veri Tipi: Örnek Swift Kodu

                          

import Foundation

enum ISLEM {

    case TOPLA

    case CIKAR

    case CARP

    case BOL }

var IS = ISLEM.CARP

print(IS)

KODUN ÇIKTISI

                          

CARP

ÖRNEK SWIFT KODU:

                          

import Foundation

enum KITALAR {

    case AVRUPA

    case ASYA

    case AMERIKA

    case AVUSTRALYA

    case AFRIKA

    case ANTARKTIKA

}

var K = KITALAR.AVRUPA

switch K {

case .AVRUPA:

    print("AVRUPA'YA HOŞ GELDİNİZ")

case .ASYA:

    print("ASYA'YA HOŞ GELDİNİZ")

case .AFRIKA:

    print("AFRIKA'YA HOŞ GELDİNİZ")

case .ANTARKTIKA:

    print("ANTARKTIKA'YA HOŞ GELDİNİZ")

case .AVUSTRALYA:

    print("AVUSTRALYA'YA HOŞ GELDİNİZ")

case .AMERIKA:

    print("AMERIKA'YA HOŞ GELDİNİZ")

default:

    print("YANLIS KITADASINIZ")

}

ÖRNEK KODUN ÇIKTISI:

                                 

AVRUPA'YA HOŞ GELDİNİZ

Extension (Uzatma)

Extension (Uzatma)

İsimlerinden de anlayacağımız gibi uzatmalar (extensions) mevcut sınıf, yapı, sayma yapısı ve protokol tiplerine yeni işlevsellikler ekler. Uzatmalar Objective C ‘deki kategorilere benzer ancak Swift’teki uzatmaların isimleri yoktur.

Uzatmalar ile Swift içinde:

  1. Hesaplanmış örnek (instance) özellikleri ve tip özellikleri eklenebilir
  2. Örnek metotları ve tip metotları tanımlanabilir
  3. Yeni ilk değer atayıcıları oluşturabilir.
  4. İndisler tanımlanabilir.
  5. Yeni iç içe yapılar (nested) tanımlanabilir ve kullanılabilir.

UZANTI TANIMLAMA

                          

extension  BirTip {

Eklenecek Yeni işlevsellik komutları

}

Uzantı içine protokol isimleri de açıkça yazılarak tanımlaman uzantının söz konusu protokoller için de geçerli olması sağlanabilir:

                          

   Extension BirTip:BirProtokol,İkinciProtokol{

Protokol gereksinimlerinin gerçekleştirimi

}

HESAPLANMIŞ ÖZELLİKLER: ÖRNEK SWIFT KODU

                          

import Foundation

extension Double {

  var DOLAR: Double { return self * 3.54 }

        var EURO:Double{return self * 3.72}

       var TL: Double { return self }

        }

let PARA = 1000.EURO

let PARA1=1400.DOLAR

print("1000 EURO \(PARA) TL")

print("1400 DOLAR \(PARA1) TL")

KODUN ÇIKTISI:

                          

1000 EURO 3720.0 TL

1400 DOLAR 4956.0 TL

Closure (Kapatma)

Closure (Kapatma) 

Kapatma denilen Swift program kod grupları aslında isimsiz fonksiyonlara benzer yapıdadırlar. Diğer bir deyişle fonksiyonlar, kapatmaların özel bir halidir.

Bir kapatmanın genel yapısı aşağıdaki gibidir:

                          

{ (PARAMETRELER) -> return TİP in
DEYİMLER
}

Kapatma herhangi bir değer göndermiyorsa ->   sembolleri ihmal edilebilir; ayrıca return de bulunmaz.

                          

{ (PARAMETRELER) in
DEYİMLER
}

Aşağıda bir örnek görülmektedir:

                          

var M: () -> (String) = {

    return "Closure örneği"

}

Burada parametre almayan fakat string türü bir değer gönderen bir kapatma görülmektedir. M()  değişkeni kullanılarak çağrılabilir. Aşağıda iki farklı kapatmanın oluşturulduğu ve kullanıldığı bir Swift uygulaması görülmektedir:

                          

import Foundation

// PARAMETRE ALMIYOR VE BİR STRING GÖNDERİYOR

var M: () -> (String) = {

    return "M Closure String döner"

}

print(M())

// BİR Int PARAMETRE ALIYOR VE BİR Int GÖNDERİYOR

var D: (Int) -> (Int) = { x in

    return 5 * x

}

print(D(3))

Swift kodunun çıktısı ise aşağıdadır:

                          

M Closure String döner

15

Genel olarak fonksiyonlar ve kapatmalar konusunda aşağıdakileri söyleyebiliriz;

  1. I.GLOBAL FONKSİYONLAR - Bunların isimleri mevcuttur ve değer göndermezler.
  2. II.İÇ İÇE FONKSİYONLAR - Bunların isimleri vardır ve değer gönderirler.
  3. III. KAPATMA İFADELERİ - İsimleri yoktur ve değer gönderebilirler.

KAPATMA İÇİNDE DEĞERLERİN İZLENMESİ 

Bir kapatma bazı değişken değerlerini uygulama boyunca saklayabilir ve gerektiğinde kullanabilir. Aşağıdaki örnekte bu görülmektedir;

                          

import Foundation

var SAYI = 0

var IKI_EKLE = {

    SAYI += 2

}

var YAZ_SAY = {

    print(SAYI)

}

IKI_EKLE();

IKI_EKLE();

YAZ_SAY();

KODUN ÇIKTISI:

                          

4

SIRALAMA UYGULAMASI 

Sort ( by : ) metodu sıralama işlemini gerçekleştiren bir metottur. Bu metodu bir kapatma ile birlikte kullanabiliriz:

                          

import Foundation

var SAY = [13,25,-7,19,-1,99,104,22,5]

SAY.sort(by: <) // DİZİ ARTAN SIRADA SIRALANACAK

print(SAY)

print("\n\n")

SAY.sort(by: >) // DİZİ AZALAN SIRADA SIRALANIYOR

print(SAY)

KODUN ÇIKTISI

                          

[-7, -1, 5, 13, 19, 22, 25, 99, 104]

[104, 99, 25, 22, 19, 13, 5, -1, -7]

Bu örnekte görüldüğü gibi < ve > operatörleri birer kapatma olarak referans alınabilir.

ÖRNEK:

                          

import Foundation

var SAY = [65,90,9,-65,43,-2,123,-6,-5,555,76]

SAY.sort(by: { a, b in

    return a < b

})

print(SAY)

print("\n\n")

SAY.sort(by: { a, b in

    return a > b

})

print(SAY)

KODUN ÇIKTISI

                          

[-65, -6, -5, -2, 9, 43, 65, 76, 90, 123, 555]

 

[555, 123, 90, 76, 65, 43, 9, -2, -5, -6, -65]

 

Stringler (Karakterler)

STRINGLER VE KARAKTERLER

Swift dilinde özellikle metin işleme uygulamalarında string ve karakter türü verilere ihtiyaç olur. String aslında bir karakter dizisidir ve String sözcüğü ile tanımlanır. Bir string’e çeşitli yollarla erişilebilir; örneğin String bir karakterler koleksiyonu şeklinde görüntülenebilir.

ÖRNEK: STRING TANIMI VE KULLANIMI

                          

import Foundation

let ad:String="ahmet okan";

print("AD=",ad)

KODUN ÇIKTISI

                          

AD= ahmet okan

Önceki bölümlerde belirtildiği gibi String ’e var bildirisi ile tanımlama yapılmışsa program içinde değeri değiştirilebilir, ancak let  bildirisi ile atama yapılmışsa değeri değiştirilemez. Bu durumda hata mesajı alınacaktır:

ÖRNEK: VAR İLE BİLDİRİ

                          

import Foundation

var ad:String="ahmet okan";

ad+=" mertoğlu";

print("AD=",ad)

KODUN ÇIKTISI

                          

AD= ahmet okan mertoğlu

ÖRNEK: LET İLE BİLDİRİ

                          

import Foundation

let ad:String="ahmet okan";

ad+=" mertoğlu";

print("AD=",ad)

KODUN ÇIKTISI

                          

Hata Mesajı: left side of mutating operator is not mutable,’ad’ is a ‘let’ constant.

Boş bir string oluşturmak için aşağıdaki yöntemlerden  herhangi biri kullanılabilir:

                          

var bos1=””; 

var bos2=String();

Sonuçta hem bos1 hem de bos2  aynı içerikte olacaktır; yani ikisi de hiçbir karakter içermeyecektir.

ÖRNEK:

                          

import Foundation

var bos1="";

var bos2=String();

print("bos1=",bos1)

print("bos2=",bos2)

KODUN ÇIKTISI:

                          

bos1=

bos2=

ÖRNEK: isEmpty FONKSİYONU

Bir string ’in içeriğinin boş olup olmadığı isEmpty fonksiyonu ile kontrol edilebilir. Eğer string boşsa “isEmpty” fonksiyonu “true” döner. Aksi halde ise “false” değerini verecektir.

                          

import Foundation

var bos1="ankara";

var bos2=String();

if bos1.isEmpty {print("bos1  boştur");}else {print("bos1=",bos1)}

if bos2.isEmpty {print("bos2  boştur");}else {print("bos2=",bos2)}

KODUN ÇIKTISI

                          

bos1= ankara

bos2  boştur

ÖRNEK: BİR STRING’İ KARAKTERLERİNE AYIRMA

String türü bir veri tekrarlanan bir yol ile karakterlerine ayrılabilir. Aşağıdaki örnek Swift kodunu inceleyiniz:

                          

import Foundation

var st="ankara";

for i  in st.characters {

print("\n",i)

 

}

KODUN ÇIKTISI 

                          

 a

 n

 k

 a

 r

 a

TEK KARAKTER TANIMLAMA

Character sözcüğünü kullanarak sadece tek karakter içeren değişken ya da sabit tanımlayabiliriz:

                          

Let  a:Character=”A”

ÖRNEK:

 

import Foundation

var a:Character="a";

var b:Character="b";

print("a=",a)

print("b=",b)

KODUN ÇIKTISI:

                          

a= a

b= b

KARAKTER DİZİSİ TANIMLAMAK

                          

Let  ank: [Character]=[“a”,”n”,”k”,”a”,”r”,”a”]

Let  an=String(ank)

Burada ank adlı her elemanı bir harften oluşan karakter dizisi tanımlanmış daha sonra da an adlı string ’e dönüştürülmüştür.

ÖRNEK:

                          

import Foundation

let  ank:[Character]=["a","n","k","a","r","a"]

let  an=String(ank)

 

 

print("a=",ank)

print("b=",an)

for i in ank {

print(i)

}

KODUN ÇIKTISI

                          

a= ["a", "n", "k", "a", "r", "a"]

b= ankara

a

n

k

a

r

a

STRING ‘LERİN VE KARAKTERLERİN BİRBİRİNE EKLENMESİ

String türü veriler ve karakter türündeki veriler birbirine eklenebilir. String ’leri eklemek için 4 sembolü ya da += sembolü kullanılır. Bir string ’e bir karakter eklemek için de append metodu kullanılır. Bununla ilgili örnekler aşağıda verilmiştir:

ÖRNEK:

                          

import Foundation

let  ank:[Character]=["a","n","k","a","r","a"]

let  an=String(ank)

let b=an+" başkenttir"

 

print("an=",an)

print("b=",b)

KODUN ÇIKTISI

                          

an= ankara

b= ankara başkenttir

ÖRNEK: 

                          

import Foundation

var  ank:[Character]=["a","n","k","a","r","a"]

var  an=String(ank)

 an+=" başkenttir"

 

print("an=",an)

KODUN ÇIKTISI

                          

an= ankara başkenttir

ÖRNEK:

                          

import Foundation

var  ank:[Character]=["a","n","k","a","r","a"]

var  an=String(ank)

print("an=",an)

 

let x:Character="m";

an.append(x);

print("an=",an)

KODUN ÇIKTISI

                          

an= ankara

an= ankaram

STRING ENTERPOLASYONU

String ‘ler sayısal veri ve \ sembolü yardımı ile karmaşık biçimde kullanılarak dinamik string ‘ler oluşturmak için kullanılabilir. Aşağıdaki örneği inceleyiniz:

ÖRNEK:

                          

import Foundation

let say = 5

let mm = "\(say) kere 3  \(Int(say) * 3 ) tir "

print("mm=",mm)

KODUN ÇIKTISI

                          

mm= 5 kere 3  15 tir

UNICODE  SAYILAR

Swift dilinde string türü bilgiler Unicode sayılar denilen veri yapıları tarafından oluşturulur ve saklanır. Unicode sayısal değerleri (scaler) bir karakter için 21-bit uzunluğunda bir sayıdır. Örneğin ”b” harfi için U+0062  sayısı kullanılır. Burada 62 onaltılık (hexadecimal) sistemde ifade edilir. Kısaca herhangi bir  sayı Unicode sisteminde “\u{n}” şeklinde ifade edilir. Burada n, 1-8 dijit arasında 16’lı sistemde sayıdır.

ÖRNEK:

                          

import Foundation

let kar:Character="\u{62}";

print(kar);

KODUN ÇIKTISI

                          

b

ASCII KODLARI VE KARŞI GELEN KARAKTERLER

Aşağıdaki örnek Swift kodu sayısal ASCII kodlarını ve onlara karşı gelen karakterleri yazdırmaktadır:

                          

import Foundation

for i in 60...70 {

    let ii=UnicodeScalar(i) ;

    print(ii,i);

};

KODUN ÇIKTISI

                          

Optional("<") 60

Optional("=") 61

Optional(">") 62

Optional("?") 63

Optional("@") 64

Optional("A") 65

Optional("B") 66

Optional("C") 67

Optional("D") 68

Optional("E") 69

Optional("F") 70

STRING ‘LER İÇİNDE ÖZEL KARAKTERLER

String türü veriler aşağıda listelenen özel karakterleri içerebilirler:

ÖZEL KARAKTER ANLAMI
\0 Null Karakteri
\\ Ters Slash (Back slash)
\t Yatay Tab
\n Yeni Satıra Geçme
\r Yazıcı Şaryoyu Geriye Alma (Carriage return)
\" Çift Tırnak
\' Tek Tırnak

GENİŞLETİLMİŞ GRAFİKSEL KÜMELER

Bazı özel karakterler, mesela é, tek bir Unicode ile temsil edilebileceği gibi iki ayrı Unicode’un yan yana getirilmesi ile de oluşturulabilir:

ÖRNEK:

                          

import Foundation

var M: Character = "\u{E9}"

var BILESIK: Character = "\u{65}\u{301}"

print(M)

print(BILESIK)

KODUN ÇIKTISI

                          

é

é

Bu yöntem ile değişik grafik karakterler üretebilirsiniz.

ÖRNEK: KARMAŞIK BİR KARAKTER SEMBOLÜ

                          

import Foundation

var BILESIK:Character = "\u{61}\u{300}"

print(BILESIK)

KODUN ÇIKTISI

                          

à

ÖRNEK:

                          

import Foundation

var BILESIK:Character = "\u{67}\u{301}"

print(BILESIK)

KODUN ÇIKTISI:

                          
g

ÖRNEK: BİR STRINGTEKİ KARAKTERLERİ SAYMA

Bir string ’teki karakter sayısını count metodu ile bulabiliriz. Aşağıdaki örneği inceleyiniz:

                          

import Foundation

let sehirler = "ankara,istanbul,izmir"

print("sehirler  \(sehirler.characters.count) karakter içeriyor")

KODUN ÇIKTISI:

                          

sehirler  21 karakter içeriyor 

Sehirler  stringinde ,”,” sembolleri dahil, 21 karakter bulunmaktadır.

BİR STRING’E ERİŞME VE STRING’TE DEĞİŞİKLİK YAPMA

ÖRNEK:

                          

import Foundation

let ST = "YKB CODE"

print(ST[ST.startIndex])

print(ST[ST.index(before: ST.endIndex)])

print(ST[ST.index(after:ST.startIndex)])

 

let i = ST.index(ST.startIndex, offsetBy: 6)

print(ST[i])

KODUN ÇIKTISI

                          

Y

E

K

D

Y K B C O D E
0 1 2 3 4 5 6 7

Burada  startIndex=0,endIndex=7  ve ST.startIndex,offsetBy:6   ifadesi ise başlangıç indis değerine(0) ,6 eklenerek (0+6)  bulunacaktır o da 6’dır ve ilgili karakter “D” dir.

Başlangıç karakteri Y, son karakter ise “D”’dir.

ÖRNEK:

String içerisine, indices  özelliğini kullanarak karakterlerin indislerine erişebilirsiniz. Aşağıdaki kodu çalıştırınız:

                          

import Foundation

let ST = "YKB CODE"

for i in ST.characters.indices {

    print("\(ST[i]) ")

}

KODUN ÇIKTISI:

                          

Y

K

B

 

C

O

D

E 

STRINGIN YAPISINDA DEĞİŞİKLİK: KARAKTER EKLEME VE ÇIKARMA

Insert(:at: )  Metodu

String içine belirtilen bir pozisyona tek bir karakter eklemek için kullanılır.

ÖRNEK: 

                          

import Foundation

var ST = "ANKARA"

print(ST)

ST.insert("M", at: ST.endIndex)

print(ST)

KODUN ÇIKTISI

                          

ANKARA

ANKARAM

Insert(contentsOf:at:)  Metodu

String ‘in belirtilen pozisyonundan itibaren başka bir string ‘in eklenmesini sağlar. Aşağıdaki örnek kodu inceleyiniz:

ÖRNEK:

                          

import Foundation

var ST = "abcde"

print(ST)

ST.insert(contentsOf:"fg".characters, at: ST.index(before: ST.endIndex))

print(ST)

KODUN ÇIKTISI

                          

abcde

abcdfge

Remove(AT:)  Metodu

Bir string ‘te belli bir indis pozisyonundaki karakteri silmek için remove metodu kullanılır.

ÖRNEK:

                          

import Foundation

var ST = "abcde"

print(ST)

ST.remove(at: ST.index(before: ST.endIndex))

print(ST)

KODUN ÇIKTISI

                          

abcde

abcd

Böylece son karakter silinir.

Remove(at:)  Metodu

Belirtilen string ‘in belirtilen aralıktaki bir alt bölümünü siler.

ÖRNEK:

                          

import Foundation

var ST = [1.12, 1.55, 1.9, 1.7, 2.4,2.24]

print(ST)

ST.removeSubrange(2..<4)

print(ST)

KODUN ÇIKTISI

                          

[1.1200000000000001, 1.55, 1.8999999999999999, 1.7, 2.3999999999999999, 2.2400000000000002]

[1.1200000000000001, 1.55, 2.3999999999999999, 2.2400000000000002]

Böylece 2 indisli ve 3 indisli 1.9 ve 1.7  elemanları silinecektir.

STRINGLERİN KARŞILAŞTIRILMASI

Swift metin türü (text) verileri mukayese etmek için 3 farklı yol sağlar:

  1. String ve karakter eşitliği
  2. Ön ek (prefix) eşitliği
  3. Son ek (suffix) eşitliği

String ve Karakter Eşitliği

String ve karakter eşitliği, eşittir(==) ve eşit değildir (!=) şeklinde isimlendirilen karşılaştırma operatörleri ile gerçekleştirilir:

EŞİTLİK(==)

ÖRNEK:

        

import Foundation

let A="ISTANBUL VE BOĞAZ..DÜNYANIN EN GÜZEL YERİ"

let B="ISTANBUL VE BOĞAZ..DÜNYANIN EN GÜZEL YERİ"

f A==B {

print("BU STRINGLER BİRBİRİNE EŞİTTİR")

}

KODUN ÇIKTISI:

BU STRINGLER BİRBİRİNE EŞİTTİR

Daha önce é ve benzeri özel karakterlerin birden fazla temsil şeklinin olduğunu söylemiştik. Eşitlik kontrollerinde bu farklı temsil şekilleri birbirine denk kabul edilir. Aşağıdaki örnek kodu inceleyiniz:

ÖRNEK:

                          

import Foundation

let A = "PARİS\u{E9}"

let B = "PARİS\u{65}\u{301}"

if A == B {

    print(A)

    print(B)

    print("BU STRINGLER BİRBİRİNE EŞİTTİR")

}

KODUN ÇIKTISI:

                          

PARİSé

PARİSé

BU STRINGLER BİRBİRİNE EŞİTTİR

Ön Ek (PREFIX) ve Son Ek (SUFFIX) Eşitliği

Aşağıdaki KRIMINAL_RAPOR adlı dizi elemanları : sembolü ile iki kısma ayrılıyor; iki nokta : sembolünden öncesi ön ek ve sonrası ise son ektir. Buna göre KRIMINAL_RAPOR adlı dizide kaç tane uyuşturucu vakası bulunduğunu aşağıdaki gibi bir programla kontrol edebiliriz:

ÖRNEK: 

                          

import Foundation

let KRIMINAL_RAPOR = [

    "UYUŞTURUCU: ANKARA",

    "UYUŞTURUCU: ISTANBUL",

    "UYUŞTURUCU: İZMİR",

    "CINAYET: ISTANBUL",

    "CINAYET: İZMİR",

    "SOYGUN:ANKARA"

]

 

var UYUS_SAYAC = 0

for i in KRIMINAL_RAPOR {

    if i.hasPrefix("UYUŞTURUCU") {

        UYUS_SAYAC += 1

    }

}

print((UYUS_SAYAC), "tane uyuşturucu vakası vardır")

KODUN ÇIKTISI:

                          

3 tane uyuşturucu vakası vardır

ÖRNEK:

ISTANBUL’da kaç kriminal vaka vardır? sorusu ise sonek kontrolü ile aşağıdaki gibi cevaplanabilir:

                          

import Foundation

let KRIMINAL_RAPOR = [

    "UYUŞTURUCU: ANKARA",

    "UYUŞTURUCU: ISTANBUL",

    "UYUŞTURUCU: İZMİR",

    "CINAYET: ISTANBUL",

    "CINAYET: İZMİR",

    "SOYGUN:ANKARA"

]

var UYUS_SAYAC = 0

for i in KRIMINAL_RAPOR {

    if i.hasSuffix("ISTANBUL") {

        UYUS_SAYAC += 1

    }

}

print((UYUS_SAYAC), "tane ISTANBUL vakası vardır")

KODUN ÇIKTISI:

                          

2 tane ISTANBUL vakası vardır

UTF-8, UTF-16, UTF-32

Swift’te bir string ya UTF-8, UTF-16,UTF-32 kod birimleri koleksiyonundan ya da 21 bitlik Unicode değerlerinden oluşur. Her biri için ayrı erişim metotları mevcuttur.

UTF-8 kodlama sistemi ise ASCII karakterleri ile denktir. Aşağıdaki tablo bu konuda bilgi veriyor:

AD UTF-8 UTF-16 UTF-32
En Küçük Kod Noktası 0000 0000 0000
En Büyük Kod Noktası 10FFF 10FFF 10FFF
Kod Birim Boyutu 8 Bits 16 Bits 32 Bits
Karakter Başına En Az Byte Sayısı 1 2 4
Karakter Başına En Fazla Byte Sayısı 4 4 4

ÖRNEK:

                          

import Foundation

var UNICOD_STRING  = "ankara~æ¬∆" 

print("UTF-8 KODLARI: ")

for KOD in UNICOD_STRING.utf8 {

    print("\(KOD) ")

}

print("\n\n")

print("UTF-16 KODLARI: ")

for KOD in UNICOD_STRING.utf16 {

    print("\(KOD) ")

}

KODUN ÇIKTISI:

 UTF-8 KODLARI:

                          

97

110

107

97

114

97

126

195

166

194

172

226

136

134

UTF-16 KODLARI:

                          

97

110

107

97

114

97

126

230

172

8710

ÖRNEK: KARAKTERLERİ İNTEGER KODLARLA GÖRÜNTÜLEMEK

                          

import Foundation

let SEHIR = "istanbul"

print("16 lık kodlar")

for KAR in SEHIR.utf16 {

   

    print(KAR)

}

 

print("\n\n")

print("8 lık kodlar")

for KAR in SEHIR.utf8 {

        print(KAR)

}

KODUN ÇIKTISI: 

16 lık kodlar

                          

105

115

116

97

110

98

117

108

8 lık kodlar

                          

105

115

116

97

110

98

117

108

ÖRNEK: BİR STRINGİ KÜÇÜK HARFTEN BÜYÜK HARFE DÖNÜŞTÜRME YA DA TERSİ

                          

import Foundation

let A = "Ykb code"

print(A.uppercased())

print(A.lowercased())

print(A.capitalized )

PROGRAMIN ÇIKTISI

                          

YKB CODE

ykb code

Ykb Code

İlk metot bütün string ‘i büyük harfe, ikinci metot bütün string ’i küçük harfe, üçüncü metot ise kelimelerin ilk harflerini büyük harfe dönüştürmektedir.

top-btn