Swift - Hızlı Kılavuz

Swift 4, Apple Inc tarafından iOS ve OS X geliştirme için geliştirilmiş yeni bir programlama dilidir. Swift 4, C uyumluluğunun kısıtlamaları olmadan en iyi C ve Objective-C'yi benimser.

Swift 4, güvenli programlama modellerini kullanır.
Swift 4, modern programlama özellikleri sağlar.
Swift 4, Objective-C benzeri sözdizimi sağlar.
Swift 4, iOS ve OS X uygulamaları yazmanın harika bir yoludur.
Swift 4, mevcut Cocoa çerçevelerine sorunsuz erişim sağlar.
Swift 4, dilin yordamsal ve nesneye yönelik bölümlerini birleştirir.
Swift 4, girdi / çıktı veya dizi işleme gibi işlevleri desteklemek için ayrı bir kitaplık içe aktarmaya ihtiyaç duymaz.

Swift 4, Mac OS ve iOS'taki mevcut Obj-C sistemiyle aynı çalışma zamanını kullanır ve bu, Swift 4 programlarının birçok mevcut iOS 6 ve OS X 10.8 platformunda çalışmasını sağlar.

Swift 4, Swift 4 programcılarının kodlarını yazıp çalıştırarak sonuçları hemen görebilecekleri oyun alanı özelliğiyle birlikte gelir.

Swift'in ilk halka açık sürümü 2010'da yayınlandı. Chris Lattnerİlk resmi sürümün ortaya çıkması için neredeyse 14 yıl geçti ve daha sonra, diğer birçok katılımcı tarafından desteklendi. Swift 4, Xcode 6 beta sürümüne dahil edildi.

Swift tasarımcıları, Objective-C, Rust, Haskell, Ruby, Python, C # ve CLU gibi diğer çeşitli popüler dillerden fikir aldı.

Yerel Ortam Kurulumu

Swift 4, öğrenme amaçlı bir Oyun Alanı platformu sağlıyor ve biz de aynısını kuracağız. Playground'da Swift 4 kodlamanızı başlatmak için xCode yazılımına ihtiyacınız var. Swift 4'ün kavramlarına alıştığınızda, iOS / OS x uygulama geliştirme için xCode IDE'yi kullanabilirsiniz.

Başlangıç olarak, Apple Developer web sitesinde zaten bir hesabınız olduğunu düşünüyoruz. Giriş yaptıktan sonra şu bağlantıya gidin - Apple Geliştiricileri için İndirin

Bu, aşağıdaki gibi mevcut bir dizi yazılımı listeleyecektir -

Şimdi xCode'u seçin ve disk görüntüsünün yanındaki verilen bağlantıya tıklayarak indirin. Dmg dosyasını indirdikten sonra, dosyayı çift tıklayarak ve verilen talimatları izleyerek kurabilirsiniz. Son olarak, verilen talimatları izleyin ve xCode simgesini Uygulama klasörüne bırakın.

Artık makinenizde xCode kurulu. Ardından, Uygulama klasöründen Xcode'u açın ve hüküm ve koşulları kabul ettikten sonra devam edin. Her şey yolundaysa, aşağıdaki ekranı göreceksiniz -

Seçiniz Get started with a playgroundseçeneğini seçin ve oyun alanı için bir ad girin ve platform olarak iOS'u seçin. Son olarak, Playground penceresini aşağıdaki gibi alacaksınız -

Varsayılan Swift 4 Oyun Alanı Penceresinden alınan kod aşağıdadır.

import UIKit
var str = "Hello, playground"

OS X programı için aynı programı oluşturursanız, o zaman Cocoa ithalini içerecek ve program aşağıdaki gibi görünecektir -

import Cocoa
var str = "Hello, playground"

Yukarıdaki program yüklendiğinde, Playground sonuç alanında (Sağ Taraf) aşağıdaki sonucu göstermelidir.

Hello, playground

Tebrikler, Swift 4 programlama ortamınız hazır ve öğrenim aracınız "Öğretici Nokta" ile devam edebilirsiniz.

Ortamı kurarken Swift 4 programından bir parça görmüştük. Aşağıdakilerle bir kez daha başlayalımHello, World! OS X oyun alanı için oluşturulan program, şunları içerir: import Cocoa aşağıda gösterildiği gibi -

/* My first program in Swift 4 */
var myString = "Hello, World!"

print(myString)

İOS oyun alanı için aynı programı oluşturursanız, import UIKit ve program aşağıdaki gibi görünecektir -

import UIKit
var myString = "Hello, World!"
print(myString)

Yukarıdaki programı uygun bir oyun alanı kullanarak çalıştırdığımızda, aşağıdaki sonucu alacağız -

Hello, World!

Şimdi bir Swift 4 programının temel yapısını görelim, böylece Swift 4 programlama dilinin temel yapı taşlarını anlamanız kolay olacaktır.

Swift 4'te içe aktar

Kullanabilirsiniz importHerhangi bir Objective-C çerçevesini (veya C kitaplığını) doğrudan Swift 4 programınıza aktarmak için açıklama. Örneğin, yukarıdakilerimport cocoa ifadesi, tüm OS X için geliştirme katmanını oluşturan tüm Cocoa kitaplıklarını, API'leri ve çalışma zamanlarını Swift 4'te kullanılabilir hale getirir.

Kakao, C'nin bir üst kümesi olan Objective-C'de uygulanır, bu nedenle Swift 4 uygulamalarınızda C ve hatta C ++ 'ı karıştırmak kolaydır.

Swift 4'te Jetonlar

Bir Swift 4 programı, çeşitli simgelerden oluşur ve bir simge, bir anahtar sözcük, bir tanımlayıcı, bir sabit, bir dize değişmezi veya bir semboldür. Örneğin, aşağıdaki Swift 4 ifadesi üç simgeden oluşur -

print("test!")
The individual tokens are:
print("test!")

Yorumlar

Yorumlar, Swift 4 programınızdaki yardımcı metinler gibidir. Derleyici tarafından yok sayılırlar. Çok satırlı yorumlar / * ile başlar ve aşağıda gösterildiği gibi * / karakterleriyle biter -

/* My first program in Swift 4 */

Çok satırlı yorumlar Swift 4'te yuvalanabilir. Aşağıdaki, Swift 4'te geçerli bir yorumdur -

/* My first program in Swift 4 is Hello, World!
/* Where as second program is Hello, Swift 4! */ */

Tek satırlı yorumlar, yorumun başında // kullanılarak yazılır.

// My first program in Swift 4

Noktalı virgül

Swift 4, isteğe bağlı olmasına rağmen, kodunuzdaki her ifadeden sonra noktalı virgül (;) yazmanızı gerektirmez; ve eğer noktalı virgül kullanırsanız, derleyici bundan şikayet etmez.

Bununla birlikte, aynı satırda birden çok ifade kullanıyorsanız, sınırlayıcı olarak noktalı virgül kullanmanız gerekir, aksi takdirde derleyici bir sözdizimi hatası verir. Yukarıdaki Merhaba Dünya! aşağıdaki gibi program -

/* My first program in Swift 4 */
var myString = "Hello, World!"; print(myString)

Tanımlayıcılar

Swift 4 tanımlayıcısı, bir değişkeni, işlevi veya kullanıcı tarafından tanımlanan diğer herhangi bir öğeyi tanımlamak için kullanılan bir addır. Tanımlayıcı, A'dan Z'ye veya a'dan z'ye veya alt çizgi _ ile başlar ve ardından sıfır veya daha fazla harf, alt çizgi ve rakam (0-9) gelir.

Swift 4, tanımlayıcılar içinde @, $ ve% gibi özel karakterlere izin vermez. Swift 4 bircase sensitiveProgramlama dili. Dolayısıyla, Manpower ve insan gücü, Swift 4'teki iki farklı tanımlayıcıdır. İşte kabul edilebilir tanımlayıcıların bazı örnekleri -

Azad        zara   abc   move_name   a_123
myname50    _temp  j     a23b9       retVal

Ayrılmış bir kelimeyi tanımlayıcı olarak kullanmak için, ondan önce ve sonra bir ters işaret (`) koymanız gerekir. Örneğin,class geçerli bir tanımlayıcı değil, ancak 'class`geçerlidir.

Anahtar kelimeler

Aşağıdaki anahtar sözcükler Swift 4'te ayrılmıştır. Bu ayrılmış sözcükler, ters işaretlerle öncelenmedikçe sabitler veya değişkenler ya da diğer tanımlayıcı adları olarak kullanılamaz -

Bildirimlerde kullanılan anahtar sözcükler

Sınıf	tanım	Sıralama	uzantı
Func	ithalat	İçinde	iç
İzin Vermek	Şebeke	özel	protokol
halka açık	statik	yapı	alt simge
tip takma ad	var

İfadelerde kullanılan anahtar kelimeler

kırmak	durum	devam et	varsayılan
yapmak	Başka	suya düşmek	için
Eğer	içinde	dönüş	değiştirmek
nerede	süre

İfadelerde ve türlerde kullanılan anahtar sözcükler

gibi	dynamicType	yanlış	dır-dir
sıfır	kendini	Öz	Süper
doğru	_COLUMN_	_DOSYA_	_FUNCTION_
_HAT_

Belirli bağlamlarda kullanılan anahtar kelimeler

birliktelik	Kolaylık	dinamik	didSet
final	almak	infix	giriş
tembel	ayrıldı	mutasyon	Yok
değişmeyen	isteğe bağlı	geçersiz kılmak	postfix
öncelik	önek	Protokol	gereklidir
sağ	Ayarlamak	Tür	sahipsiz
güçsüz	willSet

Beyaz boşluklar

Yalnızca beyaz boşluk içeren, muhtemelen bir açıklama içeren bir satır boş satır olarak bilinir ve bir Swift 4 derleyicisi bunu tamamen yok sayar.

Boşluk, Swift 4'te boşlukları, sekmeleri, yeni satır karakterlerini ve yorumları tanımlamak için kullanılan terimdir. Beyaz boşluklar, bir ifadenin bir bölümünü diğerinden ayırır ve derleyicinin, bir ifadedeki int gibi bir öğenin nerede bittiğini ve sonraki öğenin nerede başladığını belirlemesini sağlar. Bu nedenle, aşağıdaki ifadede -

var age

Arasında en az bir boşluk karakteri (genellikle boşluk) olmalıdır var ve agederleyicinin bunları ayırt edebilmesi için. Öte yandan, aşağıdaki açıklamada -

int fruit = apples + oranges   //get the total fruits

Meyve ve = arasında veya = ile elma arasında boşluk karakteri gerekmez, ancak daha iyi okunabilirlik için bazılarını dahil etmekte özgürsünüz.

Bir operatörün her iki tarafındaki boşluk eşit olmalıdır, örneğin.

int fruit = apples +oranges    //is a wrong statement
int fruit = apples + oranges   //is a Correct statement

Değişmezler

Değişmez bilgi, bir tamsayı, kayan noktalı sayı veya dize türünün bir değerinin kaynak kodu temsilidir. Aşağıdakiler değişmez değer örnekleridir -

92               // Integer literal
4.24159          // Floating-point literal
"Hello, World!"  // String literal

Swift ile Baskı

Herhangi bir şeyi hızlı bir şekilde yazdırmak için 'yazdır' anahtar kelimesine sahibiz.

Yazdırmanın üç farklı özelliği vardır.

Items - Basılacak öğeler

Separator - öğeler arasında ayırıcı

Terminator - satırın bitmesi gereken değer, bir örnek ve sözdizimi görelim.

print("Items to print", separator: "Value " , terminator: "Value")
// E.g. of print statement.

print("Value one")
// prints "Value one \n" Adds, \n as terminator and " " as separator by
default.

print("Value one","Value two", separator: " Next Value" , terminator: " End")
//prints "Value one Next Value Value two End"

Yukarıdaki kodda ilk yazdırma ifadesi, sonlandırıcı olarak \ n, sonlandırıcı olarak \ n, satırsonu Besleme ekler; ikinci yazdırma ifadesinde olduğu gibi, sonlandırıcı olarak "End" verdik, dolayısıyla bu, \ n yerine "Son" yazdıracaktır.

Özel ayırıcı ve sonlandırıcılarımızı ihtiyacımıza göre verebiliriz.

Herhangi bir programlama dilinde programlama yaparken, bilgileri depolamak için farklı değişken türleri kullanmanız gerekir. Değişkenler, değerleri saklamak için ayrılmış bellek konumlarından başka bir şey değildir. Bu, bir değişken oluşturduğunuzda bellekte biraz yer ayırdığınız anlamına gelir.

Dize, karakter, geniş karakter, tam sayı, kayan nokta, Boole, vb. Gibi çeşitli veri türlerinin bilgilerini depolamak isteyebilirsiniz. Bir değişkenin veri türüne bağlı olarak, işletim sistemi belleği ayırır ve ayrılmışta nelerin saklanabileceğine karar verir. hafıza.

Yerleşik Veri Türleri

Swift 4, programcıya zengin çeşitlilikte yerleşik ve kullanıcı tanımlı veri türleri sunar. Aşağıdaki temel veri türleri en sık değişkenleri bildirirken görülür -

Int or UInt- Bu, tam sayılar için kullanılır. Daha spesifik olarak, 32 veya 64 bit işaretli tamsayı tanımlamak için Int32, Int64, 32 veya 64 bit işaretsiz tamsayı değişkenlerini tanımlamak için UInt32 veya UInt64 kullanabilirsiniz. Örneğin, 42 ve -23.
Float- Bu, 32 bitlik kayan nokta sayısını ve daha küçük ondalık noktalı sayıları temsil etmek için kullanılır. Örneğin, 3.14159, 0.1 ve -273.158.
Double- Bu, 64 bitlik bir kayan nokta sayısını temsil etmek için kullanılır ve kayan nokta değerlerinin çok büyük olması gerektiğinde kullanılır. Örneğin, 3.14159, 0.1 ve -273.158.
Bool - Bu, doğru veya yanlış olan bir Boole değerini temsil eder.
String- Bu sıralı bir karakter koleksiyonudur. Örneğin, "Merhaba Dünya!"
Character- Bu, tek karakterli bir dizedir. Örneğin, "C"
Optional - Bu, bir değeri tutabilen veya hiç içermeyen bir değişkeni temsil eder.
Tuples - Bu, birden çok değeri tek Bileşik Değer içinde gruplamak için kullanılır.

Tamsayı türleriyle ilgili birkaç önemli noktayı burada listeledik -

32 bit platformda Int, Int32 ile aynı boyuttadır.
64 bitlik bir platformda Int, Int64 ile aynı boyuttadır.
32 bitlik bir platformda, UInt, UInt32 ile aynı boyuttadır.
64 bitlik bir platformda UInt, UInt64 ile aynı boyuttadır.
Int8, Int16, Int32, Int64, 8 Bit, 16 Bit, 32 Bit ve 64 Bit işaretli tamsayı biçimlerini temsil etmek için kullanılabilir.
UInt8, UInt16, UInt32 ve UInt64, işaretsiz tamsayının 8 Bit, 16 Bit, 32 Bit ve 64 Bit formlarını temsil etmek için kullanılabilir.

Bağlı Değerler

Aşağıdaki tablo değişken türünü, değeri bellekte depolamak için ne kadar bellek gerektiğini ve bu tür değişkenlerde saklanabilecek maksimum ve minimum değerin ne olduğunu gösterir.

Tür	Tipik Bit Genişliği	Tipik Aralık
Int8	1 bayt	-127 ila 127
UInt8	1 bayt	0 ile 255
Int32	4 bayt	-2147483648 ile 2147483647
UInt32	4 bayt	0 ila 4294967295
Int64	8 bayt	-9223372036854775808 ile 9223372036854775807
UInt64	8 bayt	0 ile 18446744073709551615
Yüzer	4 bayt	1.2E-38 - 3.4E + 38 (~ 6 basamaklı)
Çift	8 bayt	2.3E-308 - 1.7E + 308 (~ 15 basamak)

Tür Takma Adları

Kullanarak mevcut bir tür için yeni bir ad oluşturabilirsiniz. typealias. Tipalias kullanarak yeni bir tür tanımlamak için basit sözdizimi:

typealias newname = type

Örneğin, aşağıdaki satır derleyiciye şunu söyler: Feet başka bir isim Int -

typealias Feet = Int

Şimdi, aşağıdaki bildirim tamamen yasaldır ve mesafe adı verilen bir tamsayı değişkeni oluşturur -

typealias Feet = Int
var distance: Feet = 100
print(distance)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda aşağıdaki sonucu alıyoruz.

Tip Güvenlik

Swift 4, tür açısından güvenli bir dildir, yani kodunuzun bir parçası bir String beklerse, yanlışlıkla bir Int geçiremezsiniz.

Swift 4 tür açısından güvenli olduğundan, kodunuzu derlerken tür kontrolleri yapar ve uyumsuz türleri hata olarak işaretler.

var varA = 42
varA = "This is hello"
print(varA)

Yukarıdaki programı derlediğimizde, aşağıdaki derleme zamanı hatasını üretir.

main.swift:2:8: error: cannot assign value of type 'String' to type 'Int'
varA = "This is hello"

Tür Çıkarımı

Tür çıkarımı, bir derleyicinin kodunuzu derlediğinde, yalnızca sağladığınız değerleri inceleyerek belirli bir ifadenin türünü otomatik olarak çıkarmasını sağlar. Swift 4, aşağıdaki gibi uygun türü bulmak için tür çıkarımını kullanır.

// varA is inferred to be of type Int
var varA = 42
print(varA)

// varB is inferred to be of type Double
var varB = 3.14159
print(varB)

// varC is also inferred to be of type Double
var varC = 3 + 0.14159
print(varC)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

42
3.14159
3.14159

Bir değişken, programlarımızın değiştirebileceği adlandırılmış depolama alanı sağlar. Swift 4'teki her değişkenin, değişkenin belleğinin boyutunu ve düzenini belirleyen belirli bir türü vardır; o hafızada saklanabilecek değerlerin aralığı; ve değişkene uygulanabilecek işlemler kümesi.

Swift 4, aşağıdaki temel değişken türlerini destekler -

Int or UInt- Bu, tam sayılar için kullanılır. Daha spesifik olarak, 32 veya 64 bit işaretli tamsayı tanımlamak için Int32, Int64, 32 veya 64 bit işaretsiz tamsayı değişkenlerini tanımlamak için UInt32 veya UInt64 kullanabilirsiniz. Örneğin, 42 ve -23.
Float- Bu, 32 bitlik bir kayan nokta sayısını temsil etmek için kullanılır. Daha küçük ondalık noktalı sayıları tutmak için kullanılır. Örneğin, 3.14159, 0.1 ve -273.158.
Double- Bu, 64 bitlik bir kayan nokta sayısını temsil etmek için kullanılır ve kayan nokta değerlerinin çok büyük olması gerektiğinde kullanılır. Örneğin 3.14159, 0.1 ve -273.158.
Bool - Bu, doğru veya yanlış olan bir Boole değerini temsil eder.
String- Bu sıralı bir karakter koleksiyonudur. Örneğin, "Merhaba Dünya!"
Character- Bu, tek karakterli bir dizedir. Örneğin, "C"

Swift 4 ayrıca, sonraki bölümlerde ele alacağımız çeşitli diğer değişken türlerini tanımlamaya da izin verir. Optional, Array, Dictionaries, Structures, ve Classes.

Aşağıdaki bölüm, Swift 4 programlamasında çeşitli değişken türlerinin nasıl açıklanacağını ve kullanılacağını kapsayacaktır.

Değişken Beyanı

Değişken bildirimi, derleyiciye değişken için depolamanın nerede ve ne kadar oluşturulacağını söyler. Değişkenleri kullanmadan önce, bunları kullanarak bildirmelisiniz.var aşağıdaki gibi anahtar kelime -

var variableName = <initial value>

Aşağıdaki örnek, Swift 4'te bir değişkenin nasıl tanımlanacağını gösterir -

var varA = 42
print(varA)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Tür Açıklamaları

Sağlayabilirsiniz type annotationBir değişkeni bildirdiğinizde, değişkenin depolayabileceği değerlerin türü hakkında net olmak için. İşte sözdizimi -

var variableName:<data type> = <optional initial value>

Aşağıdaki örnek, Annotation kullanılarak Swift 4'te bir değişkenin nasıl ilan edileceğini gösterir. Burada, tür ek açıklamasını kullanmıyorsak, değişken için bir başlangıç değeri sağlamanın zorunlu hale geldiğini, aksi takdirde değişkenimizi tür ek açıklamasını kullanarak bildirebileceğimizi not etmek önemlidir.

var varA = 42
print(varA)

var varB:Float

varB = 3.14159
print(varB)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

42
3.1415901184082

Değişkenleri Adlandırma

Bir değişkenin adı harflerden, rakamlardan ve alt çizgi karakterinden oluşabilir. Bir harf veya alt çizgiyle başlamalıdır. Swift 4 büyük / küçük harfe duyarlı bir programlama dili olduğundan büyük ve küçük harfler farklıdır.

Değişkenlerinizi adlandırmak için basit veya Unicode karakterler kullanabilirsiniz. Aşağıdaki örnekler, değişkenleri nasıl adlandırabileceğinizi gösterir -

var _var = "Hello, Swift 4!"
print(_var)

var 你好 = "你好世界"
print(你好)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda aşağıdaki sonucu alıyoruz.

Hello, Swift 4!
你好世界

Değişkenleri Yazdırma

Bir sabitin veya değişkenin geçerli değerini yazdırma işlevi ile yazdırabilirsiniz. Adı parantez içine alarak bir değişken değerini enterpolasyon yapabilir ve açılış parantezinden önce bir ters eğik çizgi ile ondan kaçabilirsiniz: Aşağıdakiler geçerli örneklerdir -

var varA = "Godzilla"
var varB = 1000.00

print("Value of \(varA) is more than \(varB) millions")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda aşağıdaki sonucu alıyoruz.

Value of Godzilla is more than 1000.0 millions

Swift 4 ayrıca Optionalsbir değerin yokluğunu yöneten tür. Opsiyonlar ya "bir değer vardır ve x'e eşittir" ya da "hiç değer yoktur" derler.

Opsiyonel, başlı başına bir türdür, aslında Swift 4'ün yeni süper güçlü numaralandırmalarından biridir. İki olası değeri vardır,None ve Some(T), nerede T Swift 4'te bulunan doğru veri türünün ilişkili bir değeridir.

İşte isteğe bağlı bir Tamsayı bildirimi -

var perhapsInt: Int?

İşte isteğe bağlı bir String bildirimi -

var perhapsStr: String?

Yukarıdaki bildirim, onu açıkça başlatmakla eşdeğerdir nil which means no value −

var perhapsStr: String? = nil

Let's take the following example to understand how optionals work in Swift 4 −

var myString:String? = nil

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

When we run the above program using playground, we get the following result −

myString has nil value

Optionals are similar to using nil with pointers in Objective-C, but they work for any type, not just classes.

Forced Unwrapping

If you defined a variable as optional, then to get the value from this variable, you will have to unwrap it. This just means putting an exclamation mark at the end of the variable.

Let's take a simple example −

var myString:String?

myString = "Hello, Swift 4!"

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

When we run the above program using playground, we get the following result −

Optional("Hello, Swift 4!")

Now let's apply unwrapping to get the correct value of the variable −

var myString:String?

myString = "Hello, Swift 4!"

if myString != nil {
   print( myString! )
} else {
   print("myString has nil value")
}

When we run the above program using playground, we get the following result.

Hello, Swift 4!

Automatic Unwrapping

You can declare optional variables using exclamation mark instead of a question mark. Such optional variables will unwrap automatically and you do not need to use any further exclamation mark at the end of the variable to get the assigned value. Let's take a simple example −

var myString:String!
myString = "Hello, Swift 4!"

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

When we run the above program using playground, we get the following result −

Hello, Swift 4!

Optional Binding

Use optional binding to find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable.

An optional binding for the if statement is as follows −

if let constantName = someOptional {
   statements
}

Let's take a simple example to understand the usage of optional binding −

var myString:String?
myString = "Hello, Swift 4!"

if let yourString = myString {
   print("Your string has - \(yourString)")
} else {
   print("Your string does not have a value")
}

When we run the above program using playground, we get the following result −

Your string has - Hello, Swift 4!

Swift 4 also introduces Tuples type, which are used to group multiple values in a single compound Value.

The values in a tuple can be of any type, and do not need to be of same type.

For example, ("Tutorials Point", 123) is a tuple with two values, one of string Type, and other is integer type. It is a legal command.

let ImplementationError = (501, "Not implemented") is an error when something on the server is not implemented, It returns two values. Error Code, and Description.

You can create tuples from as many values as you want and from any number of different data types.

Here’s the syntax of Tuple declaration −

var TupleName = (Value1, value2,… any number of values)

Here’s a Tuple declaration −

var error501 = (501, “Not implemented”)

You can access the values of tuple using the index numbers that start from 0.

Here’s an example of accessing tuple Values −

print(“The code is\(error501.0)”)
print(“The definition of error is\(error501.1)”)

You can name the variables of a tuple while declaring , and you can call them using their names

var error501 = (errorCode: 501, description: “Not Implemented”)
print(error501.errorCode)   // prints 501.

Tuples are helpful in returning multiple values from a function. Like, a web application might return a tuple of type ("String", Int) to show whether the loading was successful or failed.

By returning different values in a tuple we can make decisions depending on different tuple types.

Note − Tuples are useful for temporary values and are not suited for complex data.

Constants refer to fixed values that a program may not alter during its execution. Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are enumeration constants as well.

Constants are treated just like regular variables except the fact that their values cannot be modified after their definition.

Constants Declaration

Before you use constants, you must declare them using let keyword as follows −

let constantName = <initial value>

Following is a simple example to show how to declare a constant in Swift 4 −

let constA = 42
print(constA)

When we run the above program using playground, we get the following result −

Type Annotations

You can provide a type annotation when you declare a constant, to be clear about the kind of values the constant can store. Following is the syntax −

var constantName:<data type> = <optional initial value>

The following example shows how to declare a constant in Swift 4 using Annotation. Here it is important to note that it is mandatory to provide an initial value while creating a constant −

let constA = 42
print(constA)

let constB:Float = 3.14159
print(constB)

When we run the above program using playground, we get the following result.

42
3.1415901184082

Naming Constants

The name of a constant can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Swift 4 is a case-sensitive programming language.

You can use simple or Unicode characters to name your variables. Following are valid examples −

let _const = "Hello, Swift 4!"
print(_const)

let 你好 = "你好世界"
print(你好)

When we run the above program using playground, we get the following result −

Hello, Swift 4!
你好世界

Printing Constants

You can print the current value of a constant or variable using print function. You can interpolate a variable value by wrapping the name in parentheses and escape it with a backslash before the opening parenthesis: Following are valid examples −

let constA = "Godzilla"
let constB = 1000.00

print("Value of \(constA) is more than \(constB) millions")

When we run the above program using playground, we get the following result −

Value of Godzilla is more than 1000.0 millions

A literal is the source code representation of a value of an integer, floating-point number, or string type. The following are examples of literals −

42                // Integer literal
3.14159           // Floating-point literal
"Hello, world!"   // String literal

Integer Literals

An integer literal can be a decimal, binary, octal, or hexadecimal constant. Binary literals begin with 0b, octal literals begin with 0o, and hexadecimal literals begin with 0x and nothing for decimal.

Here are some examples of integer literals −

let decimalInteger = 17         // 17 in decimal notation
let binaryInteger = 0b10001     // 17 in binary notation
let octalInteger = 0o21         // 17 in octal notation
let hexadecimalInteger = 0x11   // 17 in hexadecimal notation

Floating-point Literals

A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or hexadecimal form.

Decimal floating-point literals consist of a sequence of decimal digits followed by either a decimal fraction, a decimal exponent, or both.

Hexadecimal floating-point literals consist of a 0x prefix, followed by an optional hexadecimal fraction, followed by a hexadecimal exponent.

Here are some examples of floating-point literals −

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

String Literals

A string literal is a sequence of characters surrounded by double quotes, with the following form −

"characters"

String literals cannot contain an unescaped double quote ("), an unescaped backslash (\), a carriage return, or a line feed. Special characters can be included in string literals using the following escape sequences −

Escape sequence	Meaning
\0	Null Character
\\	\character
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\'	Single Quote
\"	Double Quote
\000	Octal number of one to three digits
\xhh...	Hexadecimal number of one or more digits

The following example shows how to use a few string literals −

let stringL = "Hello\tWorld\n\nHello\'Swift 4\'"
print(stringL)

When we run the above program using playground, we get the following result −

Hello World

Hello'Swift 4'

Boolean Literals

There are three Boolean literals and they are part of standard Swift 4 keywords −

A value of true representing true.
A value of false representing false.
A value of nil representing no value.

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Objective-C is rich in built-in operators and provides the following types of operators −

Arithmetic Operators
Comparison Operators
Logical Operators
Bitwise Operators
Assignment Operators
Range Operators
Misc Operators

This tutorial will explain the arithmetic, relational, logical, bitwise, assignment and other operators one by one.

Arithmetic Operators

The following table shows all the arithmetic operators supported by Swift 4 language. Assume variable A holds 10 and variable B holds 20, then −

Operator	Description	Example
+	Adds two operands	A + B will give 30
−	Subtracts second operand from the first	A − B will give -10
*	Multiplies both operands	A * B will give 200
/	Divides numerator by denominator	B / A will give 2
%	Modulus Operator and remainder of after an integer/float division	B % A will give 0

Comparison Operators

The following table shows all the relational operators supported by Swift 4 language. Assume variable A holds 10 and variable B holds 20, then −

Operator	Description	Example
==	Checks if the values of two operands are equal or not; if yes, then the condition becomes true.	(A == B) is not true.
!=	Checks if the values of two operands are equal or not; if values are not equal, then the condition becomes true.	(A != B) is true.
>	Checks if the value of left operand is greater than the value of right operand; if yes, then the condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand; if yes, then the condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand; if yes, then the condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand; if yes, then the condition becomes true.	(A <= B) is true.

Logical Operators

The following table shows all the logical operators supported by Swift 4 language. Assume variable A holds 1 and variable B holds 0, then −

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non-zero, then the condition becomes true.	(A && B) is false.
\|\|	Called Logical OR Operator. If any of the two operands is non-zero, then the condition becomes true.	(A \|\| B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then the Logical NOT operator will make it false.	!(A && B) is true.

Bitwise Operators

Bitwise operators work on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows −

p	q	p&q	p\|q	p^q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume A = 60; and B = 13;

In binary format, they will be as follows:

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

Bitwise operators supported by Swift 4 language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then 7−

Operator	Description	Example
&	Binary AND Operator copies a bit to the result, if it exists in both operands.	(A & B) will give 12, which is 0000 1100
\|	Binary OR Operator copies a bit, if it exists in either operand.	(A \| B) will give 61, which is 0011 1101
^	Binary XOR Operator copies the bit, if it is set in one operand but not both.	(A ^ B) will give 49, which is 0011 0001
~	Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.	(~A ) will give -61, which is 1100 0011 in 2's complement form.
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	(A << 2 will give 240, which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15, which is 0000 1111

Assignment Operators

SSwift 4 supports the following assignment operators −

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assign value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assigns the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assigns the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assigns the result to left operand	C = A is equivalent to C = C A
/=	Divide AND assignment operator, It divides left operand with the right operand and assigns the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assigns the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
\|=	bitwise inclusive OR and assignment operator	C \|= 2 is same as C = C \| 2

Range Operators

Swift 4 includes two range operators, which are shortcuts for expressing a range of values. The following table explains these two operators.

Operator	Description	Example
Closed Range	(a...b) defines a range that runs from a to b, and includes the values a and b.	1...5 gives 1, 2, 3, 4 and 5
Half-Open Range	(a..< b) defines a range that runs from a to b, but does not include b.	1..< 5 gives 1, 2, 3, and 4
One- sided Range	a… , defines a range that runs from a to end of elements …a , defines a range starting from start to a	1… gives 1 , 2,3… end of elements …2 gives beginning… to 1,2

Misc Operators

Swift 4 supports a few other important operators including range and ? : which are explained in the following table.

Operator	Description	Example
Unary Minus	The sign of a numeric value can be toggled using a prefixed -	-3 or -4
Unary Plus	Returns the value it operates on, without any change.	+6 gives 6
Ternary Conditional	Condition ? X : Y	If Condition is true ? Then value X : Otherwise value Y

Operators Precedence

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Operator	Description	Example
Primary Expression Operators	() [] . expr++ expr--	left-to-right
Unary Operators	* & + - ! ~ ++expr --expr * / % + - >> << < > <= >= == !=	right-to-left
Binary Operators	& ^ \| && \|\|	left-to-right
Ternary Operator	?:	right-to-left
Assignment Operators	= += -= *= /= %= >>= <<= &=^= \|=	right-to-left
Comma	,	left-to-right

Decision making structures require that the programmer specifies one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general from of a typical decision making structure found in most of the programming languages −

Swift 4 provides the following types of decision making statements. Click the following links to check their detail.

Sr.No	Statement & Description
1	if statement An if statement consists of a Boolean expression followed by one or more statements.
2	if...else statement An if statement can be followed by an optional else statement, which executes when the Boolean expression is false.
3	if...else if...else Statement An if statement can be followed by an optional else if...else statement, which is very useful to test various conditions using single if...else if statement.
4	nested if statements You can use one if or else if statement inside another if or else if statement(s).
5	switch statement A switch statement allows a variable to be tested for equality against a list of values.

The ? : Operator

We have covered conditional operator ? : in the previous chapter which can be used to replace if...else statements. It has the following general form −

Exp1 ? Exp2 : Exp3;

Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon.

The value of a ? expression is determined like this: Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire ? expression. If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression.

There may be a situation when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times. Following is the general from of a loop statement in most of the programming languages −

Swift 4 programming language provides the following kinds of loop to handle looping requirements. Click the following links to check their detail.

Sr.No	Loop Type & Description
1	for-in This loop performs a set of statements for each item in a range, sequence, collection, or progression.
2	while loop Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.
3	repeat...while loop Like a while statement, except that it tests the condition at the end of the loop body.

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Swift 4 supports the following control statements. Click the following links to check their detail.

Sr.No	Control Statement & Description
1	continue statement This statement tells a loop to stop what it is doing and start again at the beginning of the next iteration through the loop.
2	break statement Terminates the loop statement and transfers execution to the statement immediately following the loop.
3	fallthrough statement The fallthrough statement simulates the behavior of Swift 4 switch to C-style switch.

Strings in Swift 4 are an ordered collection of characters, such as "Hello, World!" and they are represented by the Swift 4 data type String, which in turn represents a collection of values of Character type.

Create a String

You can create a String either by using a string literal or creating an instance of a String class as follows −

// String creation using String literal
var stringA = "Hello, Swift 4!"
print( stringA )

// String creation using String instance
var stringB = String("Hello, Swift 4!")
print( stringB )

//Multiple line string

let stringC = """
Hey this is a
example of multiple Line
string by tutorialsPoint 

"""
print(stringC)

When the above code is compiled and executed, it produces the following result

Hello, Swift 4!
Hello, Swift 4!
Hey this is a
example of multiple Line
string by tutorialsPoint

Empty String

You can create an empty String either by using an empty string literal or creating an instance of String class as shown below. You can also check whether a string is empty or not using the Boolean property isEmpty.

// Empty string creation using String literal
var stringA = ""

if stringA.isEmpty {
   print( "stringA is empty" )
} else {
   print( "stringA is not empty" )
}

// Empty string creation using String instance
let stringB = String()

if stringB.isEmpty {
   print( "stringB is empty" )
} else {
   print( "stringB is not empty" )
}

When the above code is compiled and executed, it produces the following result −

stringA is empty
stringB is empty

String Constants

You can specify whether your String can be modified (or mutated) by assigning it to a variable, or it will be constant by assigning it to a constant using let keyword as shown below −

// stringA can be modified
var stringA = "Hello, Swift 4!"
stringA + = "--Readers--"
print( stringA )

// stringB can not be modified
let stringB = String("Hello, Swift 4!")
stringB + = "--Readers--"
print( stringB )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Playground execution failed: error: <EXPR>:10:1: error: 'String' is not
convertible to '@lvalue UInt8'
stringB + = "--Readers--"

Dize Enterpolasyonu

Dize enterpolasyonu, değerlerini bir dize değişmezinin içine dahil ederek sabitlerin, değişkenlerin, değişmez değerlerin ve ifadelerin bir karışımından yeni bir String değeri oluşturmanın bir yoludur.

Dize değişmezine eklediğiniz her öğe (değişken veya sabit), bir ters eğik çizgi ile önek olarak bir çift parantez içine alınır. İşte basit bir örnek -

var varA = 20
let constA = 100
var varC:Float = 20.0

var stringA = "\(varA) times \(constA) is equal to \(varC * 100)"
print( stringA )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

20 times 100 is equal to 2000.0

Dize Birleştirme

İki dizeyi veya bir dizeyi ve bir karakteri veya iki karakteri birleştirmek için + operatörünü kullanabilirsiniz. İşte basit bir örnek -

let constA = "Hello,"
let constB = "World!"

var stringA = constA + constB
print( stringA )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Hello,World!

IP uzunluğu

Swift 4 dizgilerinde bir lengthözelliği, ancak bir dizedeki karakter sayısını saymak için global count () işlevini kullanabilirsiniz. İşte basit bir örnek -

var varA = "Hello, Swift 4!"

print( "\(varA), length is \((varA.count))" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Hello, Swift 4!, length is 15

Dize Karşılaştırması

İki dize değişkenini veya sabiti karşılaştırmak için == operatörünü kullanabilirsiniz. İşte basit bir örnek -

var varA = "Hello, Swift 4!"
var varB = "Hello, World!"

if varA == varB {
   print( "\(varA) and \(varB) are equal" )
} else {
   print( "\(varA) and \(varB) are not equal" )
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Hello, Swift 4! and Hello, World! are not equal

Dize Yineleme

Dizeler yine swift 4'teki değerler koleksiyonudur, böylece döngüleri kullanarak dizge üzerinde yineleme yapabiliriz. -

for chars in "ThisString" {
   print(chars, terminator: " ")
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

T h i s S t r i n g

Unicode Dizeleri

Aşağıdaki örnekte gösterildiği gibi, utf8 ve utf16 özelliklerini yineleyerek bir String'in UTF-8 ve UTF-16 temsiline erişebilirsiniz -

var unicodeString = "Dog???"

print("UTF-8 Codes: ")
for code in unicodeString.utf8 {
   print("\(code) ")
}

print("\n")

print("UTF-16 Codes: ")
for code in unicodeString.utf16 {
   print("\(code) ")
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

UTF-8 Codes: 
68 
111 
103 
63 
63 
63 


UTF-16 Codes: 
68 
111 
103 
63 
63 
63

Dize İşlevleri ve Operatörleri

Swift 4, Dizelerle ilgili çok çeşitli yöntemleri ve operatörleri destekler -

Sr.No	Fonksiyonlar / Operatörler ve Amaç
1	isEmpty Bir dizenin boş olup olmadığını belirleyen bir Boolean değeri.
2	hasPrefix(prefix: String) Belirli bir parametre dizesinin dizenin öneki olup olmadığını kontrol eden işlev.
3	hasSuffix(suffix: String) Belirli bir parametre dizesinin dizenin bir soneki olup olmadığını kontrol etme işlevi.
4	toInt() Sayısal String değerini Tamsayıya dönüştürme işlevi.
5	count() Bir dizedeki Karakterlerin sayısını saymak için Global işlev.
6	utf8 Bir dizenin UTF-8 temsilini döndüren özellik.
7	utf16 Bir dizenin UTF-16 gösterimini döndüren özellik.
8	unicodeScalars Bir dizenin Unicode Skalar gösterimini döndüren özellik.
9	+ İki dizeyi veya bir dizeyi ve bir karakteri veya iki karakteri birleştirmek için işleç.
10	+= Mevcut bir dizeye bir dize veya karakter eklemek için işleç.
11	== Operatör iki dizenin eşitliğini belirler.
12	< Operatör, bir dizenin diğerinden daha az değerlendirip değerlendirmediğini belirlemek için bir sözlükbilimsel karşılaştırma gerçekleştirir.
13	startIndex Stringin başlangıç indeksindeki değeri almak için.
14	endIndex Stringin bitiş indeksindeki değeri almak için.
15	Indices İç mekanlara tek tek ulaşmak için. yani dizenin tüm karakterleri tek tek.
16	insert("Value", at: position) Bir konuma değer eklemek için.
17	remove(at: position) removeSubrange(range) bir konumdaki bir değeri kaldırmak veya dizeden bir dizi değeri kaldırmak için.
18	reversed() bir dizenin tersini döndürür

Bir character Swift, veri türü tarafından adreslenen tek karakterli bir String hazır bilgisidir Character. Aşağıdaki örneğe bir göz atın. İki karakter sabiti kullanır -

let char1: Character = "A"
let char2: Character = "B"

print("Value of char1 \(char1)")
print("Value of char2 \(char2)")

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of char1 A
Value of char2 B

Bir Character türü değişkeni veya sabitinde birden fazla karakter saklamaya çalışırsanız, Swift 4 buna izin vermeyecektir. Swift 4 Playground'da aşağıdaki örneği yazmayı deneyin ve derlemeden önce bile bir hata alırsınız.

// Following is wrong in Swift 4
let char: Character = "AB"

print("Value of char \(char)")

Boş Karakter Değişkenleri

Boş bir değere sahip boş bir Character değişkeni veya sabiti oluşturmak mümkün değildir. Aşağıdaki sözdizimi mümkün değildir -

// Following is wrong in Swift 4
let char1: Character = ""
var char2: Character = ""

print("Value of char1 \(char1)")
print("Value of char2 \(char2)")

Karakterlere Dizelerden Erişme

Swift 4'ün Dizeleri tartışılırken açıklandığı gibi, String, belirli bir sıradaki Karakter değerleri koleksiyonunu temsil eder. Böylece, verilen String'deki tek tek karakterlere, o dizeyi birfor-in döngü -

for ch in "Hello" {
   print(ch)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

H
e
l
l
o

Dizeleri Karakterlerle Birleştirme

Aşağıdaki örnek, Swift 4'ün Karakterinin Swift 4'ün String ile nasıl birleştirilebileceğini gösterir.

var varA:String = "Hello "
let varB:Character = "G"

varA.append( varB )

print("Value of varC = \(varA)")

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of varC = Hello G

Swift 4 dizileri, aynı türden sıralı değer listelerini depolamak için kullanılır. Swift 4, yanlışlıkla bile olsa bir diziye yanlış tür girmenize izin vermeyen katı bir kontrol koyar.

Oluşturulan bir diziyi bir değişkene atarsanız, her zaman değiştirilebilir, yani öğelerini ekleyerek, kaldırarak veya değiştirerek onu değiştirebilirsiniz; ancak bir sabite bir dizi atarsanız, bu dizi değişmezdir ve boyutu ve içeriği değiştirilemez.

Diziler Oluşturma

Aşağıdaki başlatıcı sözdizimini kullanarak belirli bir türde boş bir dizi oluşturabilirsiniz -

var someArray = [SomeType]()

Verilen boyutta a * bir dizi oluşturmak ve onu bir değerle başlatmak için kullanılan sözdizimi:

var someArray = [SomeType](count: NumbeOfElements, repeatedValue: InitialValue)

Boş bir dizi oluşturmak için aşağıdaki ifadeyi kullanabilirsiniz. Int 3 öğeli ve başlangıç değeri sıfır olan tür -

var someInts = [Int](count: 3, repeatedValue: 0)

Aşağıda, üç öğeden oluşan bir dizi oluşturmak ve bu diziye üç değer atamak için bir örnek daha verilmiştir -

var someInts:[Int] = [10, 20, 30]

Dizilere Erişim

Kullanarak bir diziden bir değer alabilirsiniz. subscript sözdizimi, almak istediğiniz değerin dizinini köşeli parantez içinde dizinin adından hemen sonra aşağıdaki gibi iletin -

var someVar = someArray[index]

Burada index0'dan başlar, bu da ilk elemana indeks kullanılarak 0 olarak erişilebileceği, ikinci elemana 1 olarak indeks kullanılarak erişilebileceği anlamına gelir. Aşağıdaki örnek, dizilerin nasıl oluşturulacağını, başlatılacağını ve bunlara nasıl erişileceğini gösterir -

var someInts = [Int](count: 3, repeatedValue: 10)

var someVar = someInts[0]
print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of first element is 10
Value of second element is 10
Value of third element is 10

Dizileri Değiştirme

Kullanabilirsiniz append()bir dizinin sonuna yeni bir öğe eklemek için yöntem veya toplama atama operatörü (+ =). Aşağıdaki örneğe bir göz atın. Burada, başlangıçta boş bir dizi oluşturuyoruz ve ardından aynı diziye yeni öğeler ekliyoruz -

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

var someVar = someInts[0]

print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of first element is 20
Value of second element is 30
Value of third element is 40

Aşağıdaki örnekte gösterildiği gibi, belirli bir dizine yeni bir değer atayarak bir Dizinin mevcut bir öğesini değiştirebilirsiniz -

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

// Modify last element
someInts[2] = 50

var someVar = someInts[0]

print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of first element is 20
Value of second element is 30
Value of third element is 50

Bir Dizi Üzerinde Yineleme

Kullanabilirsiniz for-in aşağıdaki örnekte gösterildiği gibi bir dizideki tüm değer kümesini yinelemek için döngü -

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]
for item in someStrs {
   print(item)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Apple
Amazon
Google

Kullanabilirsiniz enumerate() Aşağıdaki örnekte aşağıda gösterildiği gibi değeriyle birlikte bir öğenin dizinini döndüren işlev -

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]

for (index, item) in someStrs.enumerated() {
   print("Value at index = \(index) is \(item)")
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value at index = 0 is Apple
Value at index = 1 is Amazon
Value at index = 2 is Google

İki Dizi Ekleme

Aynı türden iki dizi eklemek için toplama işlecini (+) kullanabilirsiniz; bu, iki diziden aşağıdaki gibi değerlerin kombinasyonuyla yeni bir dizi verir -

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB
for item in intsC {
   print(item)
}

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Count özelliği

Salt okunur kullanabilirsiniz count aşağıda gösterilen bir dizideki öğe sayısını bulmak için bir dizinin özelliği -

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB

print("Total items in intsA = \(intsA.count)")
print("Total items in intsB = \(intsB.count)")
print("Total items in intsC = \(intsC.count)")

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Total items in intsA = 2
Total items in intsB = 3
Total items in intsC = 5

Boş Mülkiyet

Salt okunur kullanabilirsiniz empty aşağıda gösterildiği gibi bir dizinin boş olup olmadığını bulmak için bir dizinin özelliği -

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = [Int]()

print("intsA.isEmpty = \(intsA.isEmpty)")
print("intsB.isEmpty = \(intsB.isEmpty)")
print("intsC.isEmpty = \(intsC.isEmpty)")

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true

Swift 4 sets aynı türden farklı değerleri saklamak için kullanılır, ancak dizilerde olduğu gibi kesin bir sıralaması yoktur.

Elemanların sıralanması sorun değilse veya yinelenen değerler olmadığından emin olmak istiyorsanız, diziler yerine kümeler kullanabilirsiniz. (setler yalnızca farklı değerlere izin verir.)

Bir tür, bir sette saklanabilmesi için hashable olmalıdır. Bir hash değeri, eşit nesneler için eşit olan bir Int değeridir. Örneğin, x == y ise, o zamanx.hashvalue == y.hashvalue.

Tüm temel swift değerleri varsayılan olarak hashable tipindedir ve set değerleri olarak kullanılabilir.

Setler Oluşturma

Aşağıdaki başlatıcı sözdizimini kullanarak belirli bir türde boş bir küme oluşturabilirsiniz -

var someSet = Set<Character>()     //Character can be replaced by data type of set.

Setlere Erişme ve Değiştirme

Yöntemlerini ve özelliklerini kullanarak bir kümeye erişebilir veya bunları değiştirebilirsiniz -

Setteki elemanların sayısını göstermek için "count" yöntemi kullanılabilir.

someSet.count        // prints the number of elements

Sete değer eklemek için "insert" yöntemi kullanılabilir.

someSet.insert("c")   // adds the element to Set.

Benzer şekilde isEmpty, setin boş olup olmadığını kontrol etmek için kullanılabilir.

someSet.isEmpty       // returns true or false depending on the set Elements.

Setteki değeri kaldırmak için "kaldır" yöntemi kullanılabilir.

someSet.remove("c")     // removes a element , removeAll() can be used to remove all elements

Bir kümede değerin varlığını kontrol etmek için "içerir" yöntemi kullanılabilir.

someSet.contains("c")     // to check if set contains this value.

Bir Set Üzerinde Yineleme

For-in döngüsünü kullanarak bir set üzerinde yineleme yapabilirsiniz -

for items in someSet {
   print(someSet)
}

//Swift sets are not in an ordered way, to iterate over a set in ordered way use

for items in someSet.sorted() {
   print(someSet)
}

Set İşlemlerinin Gerçekleştirilmesi

Hızlı Setler üzerinde temel set işlemlerini gerçekleştirebilirsiniz.

Aşağıda, set işlemlerini gerçekleştirme yöntemleri verilmiştir -

Intersection
Union
subtracting

let evens: Set = [10,12,14,16,18]
let odds: Set = [5,7,9,11,13]
let primes = [2,3,5,7]
odds.union(evens).sorted()
// [5,7,9,10,11,12,13,14,16,18]
odds.intersection(evens).sorted()
//[]
odds.subtracting(primes).sorted()
//[9, 11, 13]

Swift 4 dictionariesaynı tipteki sırasız değer listelerini saklamak için kullanılır. Swift 4, bir sözlüğe yanlışlıkla bile yanlış bir tür girmenize izin vermeyen katı bir kontrol koyar.

Swift 4 sözlükleri, keydaha sonra başvurulabilecek ve aynı anahtarla aranabilecek bir değeri saklamak için. Bir dizideki öğelerin aksine, bir dizideki öğelerdictionarybelirli bir sipariş yok. Kullanabilirsindictionary tanımlayıcılarına göre değerleri aramanız gerektiğinde.

Bir sözlük anahtarı bir tamsayı veya sınırlaması olmayan bir dize olabilir, ancak bir sözlük içinde benzersiz olmalıdır.

Oluşturulan bir sözlüğü bir değişkene atarsanız, o zaman her zaman değiştirilebilir, yani öğeleri ekleyerek, kaldırarak veya değiştirerek onu değiştirebilirsiniz. Ancak bir sözlüğü bir sabite atarsanız, bu sözlük değişmezdir ve boyutu ve içeriği değiştirilemez.

Sözlük Oluşturma

Aşağıdaki başlatıcı sözdizimini kullanarak belirli bir türde boş bir sözlük oluşturabilirsiniz -

var someDict = [KeyType: ValueType]()

Anahtarı Int türünde olacak ve ilişkili değerler dizeler olacak boş bir sözlük oluşturmak için aşağıdaki basit sözdizimini kullanabilirsiniz -

var someDict = [Int: String]()

Verilen bir değer kümesinden bir sözlük oluşturmak için bir örnek:

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

Sıraya Dayalı Başlatma

Swift 4, dizilerden Sözlük oluşturmanıza izin verir (Anahtar-Değer Çiftleri.)

var cities = [“Delhi”,”Bangalore”,”Hyderabad”]

Anahtarı Int türünde olacak ve ilişkili değerler dizeler olacak boş bir sözlük oluşturmak için aşağıdaki basit sözdizimini kullanabilirsiniz -

var Distance = [2000,10, 620]

Verilen bir değer kümesinden bir sözlük oluşturmak için bir örnek:

let cityDistanceDict = Dictionary(uniqueKeysWithValues: zip(cities, Distance))

Yukarıdaki kod satırları, anahtar olarak Şehirler ve Değer olarak Uzaklık olan bir sözlük oluşturacaktır -

Filtreleme

Swift 4, bir sözlükten değerleri filtrelemenize izin verir.

var closeCities = cityDistanceDict.filter { $0.value < 1000 }

Yukarıdaki kodu çalıştırırsak closeCities Sözlüğümüz olacaktır.

["Bangalore" : 10 , "Hyderabad" : 620]

Sözlük Gruplaması

Swift 4, Sözlük değerlerinin gruplandırılmasını sağlar.

var cities = ["Delhi","Bangalore","Hyderabad","Dehradun","Bihar"]

Sözlüğün değerlerini birinci alfabeye göre gruplamak için aşağıdaki basit sözdizimini kullanabilirsiniz.

var GroupedCities = Dictionary(grouping: cities ) { $0.first! }

Yukarıdaki kodun sonucu olacaktır

["D" :["Delhi","Dehradun"], "B" : ["Bengaluru","Bihar"], "H" : ["Hyderabad"]]

Sözlüklere Erişim

Alt simge sözdizimini kullanarak, sözlükten bir değer elde edebilir, almak istediğiniz değerin anahtarını köşeli parantez içinde sözlüğün adının hemen arkasına aşağıdaki gibi iletebilirsiniz -

var someVar = someDict[key]

Bir sözlükten değerler oluşturmak, başlatmak ve bunlara erişmek için aşağıdaki örneği kontrol edelim -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someVar = someDict[1]

print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of key = 1 is Optional("One")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

Sözlükleri Değiştirme

Kullanabilirsiniz updateValue(forKey:)sözlüğün belirli bir anahtarına mevcut bir değeri eklemek için yöntem. Bu yöntem, sözlüğün değer türünün isteğe bağlı bir değerini döndürür. İşte basit bir örnek -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict.updateValue("New value of one", forKey: 1)
var someVar = someDict[1]

print( "Old value of key = 1 is \(oldVal)" )
print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Old value of key = 1 is Optional("One")
Value of key = 1 is Optional("New value of one")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

Aşağıdaki örnekte gösterildiği gibi, belirli bir tuşa yeni değer atayarak sözlüğün mevcut bir öğesini değiştirebilirsiniz -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict[1]
someDict[1] = "New value of one"
var someVar = someDict[1]

print( "Old value of key = 1 is \(oldVal)" )
print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Old value of key = 1 is Optional("One")
Value of key = 1 is Optional("New value of one")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

Anahtar / Değer Çiftlerini Kaldır

Kullanabilirsiniz removeValueForKey()sözlükten anahtar / değer çiftini kaldırma yöntemi. Bu yöntem, varsa anahtar / değer çiftini kaldırır ve kaldırılan değeri döndürür veya değer yoksa nil değerini döndürür. İşte basit bir örnek -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var removedValue = someDict.removeValue(forKey: 2)

print( "Value of key = 1 is \(someDict[1])" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

Bir anahtar / değer çiftini sözlükten bir değer atayarak kaldırmak için alt simge sözdizimini de kullanabilirsiniz. nilbu anahtar için. İşte basit bir örnek -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

someDict[2] = nil

print( "Value of key = 1 is \(someDict[1])" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

Sözlük Üzerinde Yineleme

Kullanabilirsin for-in Aşağıdaki örnekte gösterildiği gibi, bir Sözlük'teki tüm anahtar-değer çiftleri kümesi üzerinde yineleme yapmak için döngü yapın -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

for (index, keyValue) in someDict.enumerated() {
   print("Dictionary key \(index) - Dictionary value \(keyValue)")
}

When the above code is compiled and executed, it produces the following result −

Dictionary key 2 - Dictionary value Two
Dictionary key 3 - Dictionary value Three
Dictionary key 1 - Dictionary value One

You can use enumerate() function which returns the index of the item along with its (key, value) pair as shown below in the example −

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerated() {
   print("Dictionary key \(key) - Dictionary value \(value)")
}

When the above code is compiled and executed, it produces the following result −

Dictionary key 0 - Dictionary value (key: 2, value: "Two")
Dictionary key 1 - Dictionary value (key: 3, value: "Three")
Dictionary key 2 - Dictionary value (key: 1, value: "One")

Convert to Arrays

You can extract a list of key-value pairs from a given dictionary to build separate arrays for both keys and values. Here is an example −

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)

print("Print Dictionary Keys")

for (key) in dictKeys {
   print("\(key)")
}
print("Print Dictionary Values")

for (value) in dictValues {
   print("\(value)")
}

When the above code is compiled and executed, it produces the following result −

Print Dictionary Keys
2
3
1
Print Dictionary Values
Two
Three
One

The count Property

You can use the read-only count property of a dictionary to find out the number of items in a dictionary as shown below −

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]

print("Total items in someDict1 = \(someDict1.count)")
print("Total items in someDict2 = \(someDict2.count)")

When the above code is compiled and executed, it produces the following result −

Total items in someDict1 = 3
Total items in someDict2 = 2

The empty Property

You can use read-only empty property of a dictionary to find out whether a dictionary is empty or not, as shown below −

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
var someDict3:[Int:String] = [Int:String]()

print("someDict1 = \(someDict1.isEmpty)")
print("someDict2 = \(someDict2.isEmpty)")
print("someDict3 = \(someDict3.isEmpty)")

When the above code is compiled and executed, it produces the following result −

someDict1 = false
someDict2 = false
someDict3 = true

A function is a set of statements organized together to perform a specific task. A Swift 4 function can be as simple as a simple C function to as complex as an Objective C language function. It allows us to pass local and global parameter values inside the function calls.

Function Declaration − tells the compiler about a function's name, return type, and parameters.
Function Definition − It provides the actual body of the function.

Swift 4 functions contain parameter type and its return types.

Function Definition

In Swift 4, a function is defined by the "func" keyword. When a function is newly defined, it may take one or several values as input 'parameters' to the function and it will process the functions in the main body and pass back the values to the functions as output 'return types'.

Every function has a function name, which describes the task that the function performs. To use a function, you "call" that function with its name and pass input values (known as arguments) that match the types of the function's parameters. Function parameters are also called as 'tuples'.

A function's arguments must always be provided in the same order as the function's parameter list and the return values are followed by →.

Syntax

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

Take a look at the following code. The student’s name is declared as string datatype declared inside the function 'student' and when the function is called, it will return student’s name.

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

When we run the above program using playground, we get the following result −

First Program
About Functions

Calling a Function

Let us suppose we defined a function called 'display' to Consider for example to display the numbers a function with function name 'display' is initialized first with argument 'no1' which holds integer data type. Then the argument 'no1' is assigned to argument 'a' which hereafter will point to the same data type integer. Now the argument 'a' is returned to the function. Here display() function will hold the integer value and return the integer values when each and every time the function is invoked.

func display(no1: Int) -> Int {
   let a = no1
   return a
}

print(display(no1: 100))
print(display(no1: 200))

When we run above program using playground, we get the following result −

100
200

Parameters and Return Values

Swift 4 provides flexible function parameters and its return values from simple to complex values. Similar to that of C and Objective C, functions in Swift 4 may also take several forms.

Functions with Parameters

A function is accessed by passing its parameter values to the body of the function. We can pass single to multiple parameter values as tuples inside the function.

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}

print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

When we run above program using playground, we get the following result −

40
45
120

Functions without Parameters

We may also have functions without any parameters.

Syntax

func funcname() -> datatype {
   return datatype
}

Following is an example having a function without a parameter −

func votersname() -> String {
   return "Alice"
}
print(votersname())

When we run the above program using playground, we get the following result −

Alice

Functions with Return Values

Functions are also used to return string, integer, and float data type values as return types. To find out the largest and smallest number in a given array function 'ls' is declared with large and small integer datatypes.

An array is initialized to hold integer values. Then the array is processed and each and every value in the array is read and compared for its previous value. When the value is lesser than the previous one it is stored in 'small' argument, otherwise it is stored in 'large' argument and the values are returned by calling the function.

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]

   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   return (lar, sma)
}

let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

When we run the above program using playground, we get the following result −

Largest number is: 98 and smallest number is: -5

Functions without Return Values

Some functions may have arguments declared inside the function without any return values. The following program declares a and b as arguments to the sum() function. inside the function itself the values for arguments a and b are passed by invoking the function call sum() and its values are printed thereby eliminating return values.

func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

When we run the above program using playground, we get the following result −

30 20
50 40
30 24

Functions with Optional Return Types

Swift 4 introduces 'optional' feature to get rid of problems by introducing a safety measure. Consider for example we are declaring function values return type as integer but what will happen when the function returns a string value or either a nil value. In that case compiler will return an error value. 'optional' are introduced to get rid of these problems.

Optional functions will take two forms 'value' and a 'nil'. We will mention 'Optionals' with the key reserved character '?' to check whether the tuple is returning a value or a nil value.

func minMax(array: [Int]) -> (min: Int, max: Int)? {
   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
   
   for value in array[1..<array.count] {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

When we run above program using playground, we get following result −

min is -6 and max is 109

''Optionals' are used to check 'nil' or garbage values thereby consuming lot of time in debugging and make the code efficient and readable for the user.

Functions Local Vs External Parameter Names

Local Parameter Names

Local parameter names are accessed inside the function alone.

func sample(number: Int) {
   print(number)
}

Here, the func sample argument number is declared as internal variable since it is accessed internally by the function sample(). Here the 'number' is declared as local variable but the reference to the variable is made outside the function with the following statement −

func sample(number: Int) {
   print(number)
}

sample(number: 1)
sample(number: 2)
sample(number: 3)

When we run the above program using playground, we get the following result −

1
2
3

External Parameter Names

External parameter names allow us to name a function parameters to make their purpose more clear. For example below you can name two function parameters and then call that function as follows −

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}

pow(firstArg:5, secondArg:3)

When we run the above program using playground, we get the following result −

Variadic Parameters

When we want to define function with multiple number of arguments, then we can declare the members as 'variadic' parameters. Parameters can be specified as variadic by (···) after the parameter name.

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

When we run the above program using playground, we get the following result −

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

Constant, Variable and I/O Parameters

Functions by default consider the parameters as 'constant', whereas the user can declare the arguments to the functions as variables also. We already discussed that 'let' keyword is used to declare constant parameters and variable parameters is defined with 'var' keyword.

I/O parameters in Swift 4 provide functionality to retain the parameter values even though its values are modified after the function call. At the beginning of the function parameter definition, 'inout' keyword is declared to retain the member values.

It derives the keyword 'inout' since its values are passed 'in' to the function and its values are accessed and modified by its function body and it is returned back 'out' of the function to modify the original argument.

Variables are only passed as an argument for in-out parameter since its values alone are modified inside and outside the function. Hence no need to declare strings and literals as in-out parameters. '&' before a variable name refers that we are passing the argument to the in-out parameter.

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}

var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

When we run the above program using playground, we get the following result −

Swapped values are 10, 2

Function Types & its Usage

Each and every function follows the specific function by considering the input parameters and outputs the desired result.

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

Following is an example −

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

When we run the above program using playground, we get the following result −

2
6

Here the function is initialized with two arguments no1 and no2 as integer data types and its return type is also declared as 'int'

Func inputstr(name: String) -> String {
   return name
}

Here the function is declared as string datatype.

Functions may also have void data types and such functions won't return anything.

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

When we run the above program using playground, we get the following result −

Swift 4 Functions
Types and its Usage

The above function is declared as a void function with no arguments and no return values.

Using Function Types

Functions are first passed with integer, float or string type arguments and then it is passed as constants or variables to the function as mentioned below.

var addition: (Int, Int) -> Int = sum

Here sum is a function name having 'a' and 'b' integer variables which is now declared as a variable to the function name addition. Hereafter both addition and sum function both have same number of arguments declared as integer datatype and also return integer values as references.

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

When we run the above program using playground, we get the following result −

Result: 129

Function Types as Parameter Types & Return Types

We can also pass the function itself as parameter types to another function.

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

When we run the above program using playground, we get the following result −

Result: 129
Result: 30

Nested Functions

A nested function provides the facility to call the outer function by invoking the inside function.

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 30)
print(decrem())

When we run the above program using playground, we get the following result −

-30

Closures in Swift 4 are similar to that of self-contained functions organized as blocks and called anywhere like C and Objective C languages. Constants and variable references defined inside the functions are captured and stored in closures. Functions are considered as special cases of closures and it takes the following three forms −

Global Functions	Nested Functions	Closure Expressions
Have a name. Do not capture any values	Have a name. Capture values from enclosing function	Unnamed Closures capture values from the adjacent blocks

Closure expressions in Swift 4 language follow crisp, optimization, and lightweight syntax styles which includes.

Inferring parameter and return value types from context.
Implicit returns from single-expression closures.
Shorthand argument names and
Trailing closure syntax

Syntax

Following is a generic syntax to define closure which accepts parameters and returns a data type −

{
   (parameters) −> return type in
   statements
}

Following is a simple example −

let studname = { print("Welcome to Swift Closures") }
studname()

When we run the above program using playground, we get the following result −

Welcome to Swift Closures

The following closure accepts two parameters and returns a Bool value −

{     
   (Int, Int) −> Bool in
   Statement1
   Statement 2
   ---
   Statement n
}

Following is a simple example −

let divide = {
   (val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}

let result = divide(200, 20)
print (result)

When we run the above program using playground, we get the following result −

Expressions in Closures

Nested functions provide a convenient way of naming and defining blocks of code. Instead of representing the whole function declaration and name constructs are used to denote shorter functions. Representing the function in a clear brief statement with focused syntax is achieved through closure expressions.

Ascending Order Program

Sorting a string is achieved by the Swift 4s key reserved function "sorted" which is already available in the standard library. The function will sort the given strings in the ascending order and returns the elements in a new array with same size and data type mentioned in the old array. The old array remains the same.

Two arguments are represented inside the sorted function −

Values of Known type represented as arrays.
Array contents (Int, Int) and returns a Boolean value (Bool) if the array is sorted properly it will return true value otherwise it will return false.

A normal function with input string is written and passed to the sorted function to get the strings sorted to new array which is shown below −

func ascend(s1: String, s2: String) -> Bool {
   return s1 > s2
}

let stringcmp = ascend(s1: "Swift 4", s2: "great")
print (stringcmp)

When we run above program using playground, we get following result −

true

The initial array to be sorted for icecream is given as "Swift 4" and "great". Function to sort the array is declared as string datatype and its return type is mentioned as Boolean. Both the strings are compared and sorted in ascending order and stored in a new array. If the sorting is performed successful the function will return a true value else it will return false.

Closure expression syntax uses −

constant parameters,
variable parameters, and
inout parameters.

Closure expression did not support default values. Variadic parameters and Tuples can also be used as parameter types and return types.

let sum = {
   (no1: Int, no2: Int) -> Int in 
   return no1 + no2 
}

let digits = sum(10, 20)
print(digits)

When we run the above program using playground, we get the following result −

The parameters and return type declarations mentioned in the function statement can also be represented by the inline closure expression function with 'in' keyword. Once declaring parameter and return types 'in' keyword is used to denote that the body of the closure.

Single Expression Implicit Returns

Here, the function type of the sorted function's second argument makes it clear that a Bool value must be returned by the closure. Because the closure's body contains a single expression (s1 > s2) that returns a Bool value, there is no ambiguity, and the return keyword can be omitted.

To return a Single expression statement in expression closures 'return' keyword is omitted in its declaration part.

var count:[Int] = [5, 10, -6, 75, 20]
let descending = count.sorted(by: { n1, n2 in n1 > n2 })
let ascending = count.sorted(by: { n1, n2 in n1 < n2 })

print(descending)
print(ascending)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[75, 20, 10, 5, -6]
[-6, 5, 10, 20, 75]

İfadenin kendisi, string1'in string 2'den büyük olduğu zaman true değerini döndürdüğünü, aksi halde false değerini döndürdüğünü, dolayısıyla return ifadesinin burada atlandığını açıkça tanımlar.

Bilinen Tip Kapamalar

İki sayının eklenmesini düşünün. Eklemenin tamsayı veri türünü döndüreceğini biliyoruz. Bu nedenle, bilinen tür kapanışları şu şekilde bildirilir -

let sub = {
   (no1: Int, no2: Int) -> Int in 
   return no1 - no2 
}

let digits = sub(10, 20)
print(digits)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

-10

Steno Bağımsız Değişken Adlarını Kapanış Olarak Bildirme

Swift 4, kapanış argümanlarının değerlerine $ 0 isimleriyle başvurmak için kullanılabilen satır içi kapanışlara otomatik olarak kısa argüman adları sağlar, $1, $2 vb.

var shorthand: (String, String) -> String
shorthand = { $1 }
print(shorthand("100", "200"))

Burada $ 0 ve $ 1, kapanışın birinci ve ikinci String argümanlarına atıfta bulunur.

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Swift 4, kullanıcının Satır içi kapanışları 0 $ 'ı temsil ederek kısa argüman adları olarak göstermesini kolaylaştırır, $1, $2 - $ n.

Kapanış ifadeleri içinde steno argüman adlarını temsil ettiğimizde, tanım bölümünde kapanış argüman listesi atlanır. İşlev türüne bağlı olarak, steno argüman adları türetilecektir. Steno argüman ifade gövdesinde tanımlandığından 'in' anahtar kelimesi atlanır.

Operatör İşlevleri Olarak Kapanışlar

Swift 4, yalnızca operatör işlevlerini kapatma işlevi sağlayarak üyelere erişmenin kolay bir yolunu sağlar. Önceki örneklerde 'Bool' anahtar kelimesi, dizeler eşit olduğunda 'true' veya 'false' döndürmek için kullanılır.

İfade, kapanışta operatör işlevi tarafından daha da basitleştirilmiştir -

let numb = [98, -20, -30, 42, 18, 35]
var sortedNumbers = numb.sorted ({
   (left: Int, right: Int) -> Bool in
   return left < right
})

let asc = numb.sorted(<)
print(asc)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[-30, -20, 18, 35, 42, 98]

Fragman Olarak Kapanışlar

Fonksiyonun son argümanının bir kapanış ifadesine geçirilmesi, 'İzleyen Kapamalar' yardımıyla bildirilir. {} İle fonksiyonun () dışında yazılır. Fonksiyonu satır içi olarak tek bir satıra yazmak mümkün olmadığında kullanılması gerekir.

reversed = sorted(names) { $0 > $1}

burada {$ 0> $ 1}, dışında (adlar) bildirilen sondaki kapanışlar olarak temsil edilir.

import Foundation
var letters = ["North", "East", "West", "South"]

let twoletters = letters.map({ 
   (state: String) -> String in
   return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString
})

let stletters = letters.map() { 
   $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString 
}
print(stletters)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[NO, EA, WE, SO]

Değerleri ve Referans Türlerini Yakalama

Swift 4'te sabitlerin ve değişkenlerin değerlerinin yakalanması kapanışlar yardımıyla yapılır. Ayrıca, değişkenler artık mevcut olmasa bile, kapanış gövdesi içindeki bu sabitler ve değişkenler için değerleri belirtir ve değiştirir.

Sabit ve değişken değerlerin yakalanması, diğer işlevin gövdesine işlev yazarak yuvalanmış işlev kullanılarak elde edilir.

İç içe geçmiş bir işlev yakalar -

Dış fonksiyon argümanları.
Outer işlevi içinde tanımlanan sabitleri ve değişkenleri yakalayın.

Swift 4'te, bir fonksiyonun içinde bir sabit veya bir değişken bildirildiğinde, bu değişkenlere referans da kapanış tarafından otomatik olarak oluşturulur. Aynı zamanda tesise aşağıdaki gibi ikiden fazla değişkeni aynı kapanışla gönderme olanağı sağlar -

let decrem = calcDecrement(forDecrement: 18)
decrem()

Buraya oneDecrement ve Azaltma değişkenlerinin her ikisi de kapanış referansı olarak aynı bellek bloğunu gösterecektir.

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 100
   func decrementer() -> Int {
      overallDecrement -= total
      print(overallDecrement)
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 18)
decrem()
decrem()
decrem()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

82
64
46

CalcDecrement dış işlevi her çağrıldığında, decmenter () işlevini çağırır ve değeri 18 birim düşürür ve calcDecrement dış işlevi yardımıyla sonucu döndürür. Burada calcDecrement bir kapatma görevi görür.

Decrementer () işlevi herhangi bir argüman kapamasına sahip olmasa da, varsayılan olarak 'genelDecrement' ve 'toplam' değişkenlerini mevcut değerlerini yakalayarak ifade eder. Belirtilen değişkenler için değerlerin kopyası yeni düşürücü () işlevi ile saklanır. Swift 4, değişkenler kullanımda değilken bellek alanlarını ayırarak ve serbest bırakarak bellek yönetimi işlevlerini yönetir.

Numaralandırma, ilgili değerler kümesinden oluşan kullanıcı tanımlı bir veri türüdür. Anahtar kelimeenum numaralandırılmış veri türünü tanımlamak için kullanılır.

Numaralandırma İşlevi

Swift 4'teki numaralandırma, C ve Hedef C'nin yapısına da benziyor.

Bir sınıfta bildirilir ve değerlerine o sınıfın örneği aracılığıyla erişilir.
İlk üye değeri, sıralama başlatıcıları kullanılarak tanımlanır.
Standart protokol işlevselliği sağlanarak işlevselliği de genişletilmiştir.

Sözdizimi

Numaralandırmalar enum anahtar kelimesiyle tanıtılır ve tüm tanımlarını bir küme parantezi içine yerleştirir -

enum enumname {
   // enumeration values are described here
}

Örneğin, haftanın günleri için aşağıdaki gibi bir numaralandırma tanımlayabilirsiniz -

enum DaysofaWeek {
   case Sunday
   case Monday
   ---
   case Saturday
}

Misal

enum names {
   case Swift
   case Closures
}

var lang = names.Closures
lang = .Closures

switch lang {
   case .Swift:
      print("Welcome to Swift")
   case .Closures:
      print("Welcome to Closures")
   default:
      print("Introduction")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Welcome to Closures

Swift 4 numaralandırma, üyelerine C ve Amaç C gibi varsayılan değerleri atamaz. Bunun yerine üyeler, numaralandırma adlarıyla açıkça tanımlanır. Numaralandırma adı büyük harfle başlamalıdır (Örn: enum DaysofaWeek).

var weekDay = DaysofaWeek.Sunday

Burada Numaralandırma adı 'DaysofaWeek' değişken bir hafta içi güne atanır. Derleyiciye, veri türünün Pazar gününe ait olduğunu bildirir, söz konusu sınıfın sonraki enum üyelerine atanacaktır. Enum üye veri türü tanımlandıktan sonra, üyelere değerler ve diğer hesaplamalar geçirilerek erişilebilir.

Switch İfadesi ile Numaralandırma

Swift 4 'Değiştir' ifadesi, çok yönlü seçimi de takip eder. Belirtilen koşula bağlı olarak belirli bir zamanda yalnızca bir değişkene erişilir. Switch deyimindeki varsayılan durum, belirtilmemiş durumları yakalamak için kullanılır.

enum Climate {
   case India
   case America
   case Africa
   case Australia
}

var season = Climate.America
season = .America
switch season {
   case .India:
      print("Climate is Hot")
   case .America:
      print("Climate is Cold")
   case .Africa:
      print("Climate is Moderate")
   case .Australia:
      print("Climate is Rainy")
   
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Climate is Cold

Program ilk olarak Climate'ı numaralandırma adı olarak tanımlar. Daha sonra 'Hindistan', 'Amerika', 'Afrika' ve 'Avustralya' gibi üyelerinin 'İklim' sınıfına ait olduğu ilan edildi. Şimdi üye Amerika bir Sezon Değişkenine atanmıştır. Ayrıca, Switch case .America'ya karşılık gelen değerleri görecek ve o belirli ifadeye dallanacaktır. Çıktı, "İklim Soğuk" olarak görüntülenecektir. Aynı şekilde, tüm üyelere anahtar ifadeleri aracılığıyla erişilebilir. Koşul tatmin edilmediğinde, varsayılan olarak 'İklim tahmin edilemez' yazdırır.

Numaralandırma ayrıca ilişkili değerlere ve ham değerlere göre sınıflandırılabilir.

İlişkili Değerler ve Ham Değerler Arasındaki Fark

İlişkili Değerler	Ham Değerler
Farklı Veri Türleri	Aynı Veri Türleri
Ör: enum {10,0.8, "Merhaba"}	Ör: enum {10,35,50}
Değerler sabit veya değişkene göre oluşturulur	Önceden doldurulmuş Değerler
Her defasında bildirildiğinde değişir	Üye için değer aynı

İlişkili Değerlerle Enum

enum Student {
   case Name(String)
   case Mark(Int,Int,Int)
}

var studDetails = Student.Name("Swift 4")
var studMarks = Student.Mark(98,97,95)

switch studMarks {
   case .Name(let studName):
      print("Student name is: \(studName).")
   case .Mark(let Mark1, let Mark2, let Mark3):
      print("Student Marks are: \(Mark1),\(Mark2),\(Mark3).")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Student Marks are: 98,97,95.

Örneğin, öğrencilerin adı ve üç konuda güvence altına alınan işaretlere erişmeyi düşünün, numaralandırma adı öğrenci olarak bildirilir ve enum sınıfında bulunan üyeler, dize veri türüne ait adlardır, işaretler veri türü Tamsayı'nın mark1, mark2 ve mark3 olarak temsil edilir. Öğrenci adına veya puanladıkları notlara erişmek için

var studDetails = Student.Name("Swift")
var studMarks = Student.Mark(98,97,95)

Şimdi, anahtar durumu, bu vaka bloğu yürütülürse öğrenci adını yazdıracak, aksi takdirde öğrenci tarafından güvence altına alınan işaretleri yazdıracaktır. Her iki koşul da başarısız olursa, varsayılan blok yürütülür.

Ham Değerlerle Numaralandırma

Ham değerler dizeler, karakterler veya tam sayı veya kayan noktalı sayı türlerinden herhangi biri olabilir. Her ham değer, numaralandırma beyanı içinde benzersiz olmalıdır. Tam sayılar ham değerler için kullanıldığında, numaralandırma üyelerinden bazıları için değer belirtilmezse otomatik olarak artar.

enum Month: Int {
   case January = 1, February, March, April, May, June, July, August,
      September, October, November, December
}

let yearMonth = Month.May.rawValue
print("Value of the Month is: \(yearMonth).")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Value of the Month is: 5.

Swift 4, yapıları Yapılar olarak kullanmak için esnek bir yapı taşı sağlar. Bu yapılardan yararlanarak bir kez yapı yöntemlerini ve özelliklerini tanımlayabiliriz.

C ve Hedef C'nin aksine

Yapının uygulama dosyaları ve arayüz gerektirmesi gerekmez.
Yapı, tek bir dosya oluşturmamızı ve arayüzünü otomatik olarak diğer bloklara genişletmemizi sağlar.

Yapı'da, değişken değerleri kopyalanır ve eski değerlerin bir kopyası döndürülerek sonraki kodlara geçirilir, böylece değerler değiştirilemez.

Sözdizimi

Structures are defined with a 'Struct' Keyword.
struct nameStruct {
   Definition 1
   Definition 2
   ---
   Definition N
}

Bir Yapının Tanımı

Örneğin, üç konunun puanlarını içeren öğrenci kayıtlarına erişmemiz ve üç konunun toplamını bulmamız gerektiğini varsayalım. Burada markStruct, veri türü 'Int' olarak üç işaretli bir yapıyı başlatmak için kullanılır.

struct MarkStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int
}

Yapıya ve Özelliklerine Erişim

Yapının üyelerine yapı adı ile erişilir. Yapının örnekleri 'let' anahtar sözcüğü ile başlatılır.

struct studentMarks {
   var mark1 = 100
   var mark2 = 200
   var mark3 = 300
}

let marks = studentMarks()
print("Mark1 is \(marks.mark1)")
print("Mark2 is \(marks.mark2)")
print("Mark3 is \(marks.mark3)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Mark1 is 100
Mark2 is 200
Mark3 is 300

Öğrenci işaretlerine 'studentMarks' yapı adı ile erişilir. Yapı üyeleri, tamsayı tipi değerleri ile mark1, mark2, mark3 olarak başlatılır. Daha sonra studentMarks () yapısı 'let' anahtar kelimesi ile 'işaretlere' aktarılır. Bundan sonra 'işaretler' yapı üye değerlerini içerecektir. Artık değerler yapı üye değerlerine '.' İle erişilerek yazdırılır. ilklendirilmiş isimleriyle.

struct MarksStruct {
   var mark: Int

   init(mark: Int) {
      self.mark = mark
   }
}

var aStruct = MarksStruct(mark: 98)
var bStruct = aStruct     // aStruct and bStruct are two structs with the same value!
bStruct.mark = 97

print(aStruct.mark)      // 98
print(bStruct.mark)      // 97

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

98
97

Yapıların En İyi Kullanım Uygulamaları

Swift 4 dili, yapıları işlev bloklarını oluşturmak için özel veri türleri olarak tanımlama işlevselliği sağlar. Yapının örnekleri, daha fazla manipülasyon için değeri tarafından tanımlanan bloklara aktarılır.

Yapılara sahip olma ihtiyacı

Basit veri değerlerini kapsüllemek için.
Kapsüllenmiş verileri ve ilişkili özelliklerini 'referanslar' yerine 'değerler' ile kopyalamak için.
'Kopyalama' ve 'Referans' Yapısı.

Swift 4'teki yapılar, üyelerini referanslarından çok değerleriyle geçiriyor.

struct markStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int

   init(mark1: Int, mark2: Int, mark3: Int) {
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

var marks = markStruct(mark1: 98, mark2: 96, mark3:100)
print(marks.mark1)
print(marks.mark2)
print(marks.mark3)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

98
96
100

Başka bir örnek

struct markStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int
   
   init(mark1: Int, mark2: Int, mark3: Int) {
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

var fail = markStruct(mark1: 34, mark2: 42, mark3: 13)

print(fail.mark1)
print(fail.mark2)
print(fail.mark3)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

34
42
13

'MarkStruct' yapısı ilk olarak mark1, mark2 ve mark3 üyeleriyle tanımlanır. Şimdi üye sınıfların değişkenleri, tam sayı değerlerini tutacak şekilde başlatılır. Daha sonra yapı üyelerinin kopyası 'self' Anahtar Kelime ile oluşturulur. Yapı elemanlarının kopyaları oluşturulduktan sonra, parametre işaretleriyle birlikte yapı bloğu, artık öğrencilerin işaretlerini tutacak olan 'işaretler' değişkenine aktarılır. Daha sonra işaretler 98, 96, 100 olarak yazdırılır. Aynı yapı üyeleri için sonraki adım, aynı yapı üyelerini farklı işaretlerle işaret etmek için "başarısız" adlı başka bir durum kullanılır. Ardından sonuçlar 34, 42, 13 olarak yazdırılır. Bu, yapıların üye değişkenlerinin bir kopyasına sahip olacağını ve daha sonra üyeleri sonraki işlev bloklarına aktaracağını açık bir şekilde açıklar.

Swift 4'teki sınıflar, esnek yapıların yapı taşlarıdır. Sabitlere, değişkenlere ve işlevlere benzer şekilde, kullanıcı sınıf özelliklerini ve yöntemlerini tanımlayabilir. Swift 4, sınıfları bildirirken kullanıcıların arayüzler veya uygulama dosyaları oluşturmasına gerek olmayan işlevselliği sağlıyor. Swift 4, sınıfları tek bir dosya olarak oluşturmamızı sağlar ve harici arayüzler, sınıflar başlatıldığında varsayılan olarak oluşturulacaktır.

Derslere sahip olmanın faydaları

Miras, bir sınıfın özelliklerini başka bir sınıfa aktarır
Tür atama, kullanıcının çalışma zamanında sınıf türünü kontrol etmesini sağlar
Deinitializers bellek kaynaklarını serbest bırakmaya özen gösterir
Referans sayma, sınıf örneğinin birden fazla referansa sahip olmasına izin verir

Sınıfların ve yapıların Ortak Özellikleri

Özellikler, değerleri depolamak için tanımlanır
Değerlere erişim sağlamak için abonelikler tanımlanır
İşlevselliği iyileştirmek için yöntemler başlatılır
Başlangıç durumu, başlatıcılar tarafından tanımlanır
İşlevsellik, varsayılan değerlerin ötesine genişletildi
Protokol işlevsellik standartlarının doğrulanması

Sözdizimi

Class classname {
   Definition 1
   Definition 2
   --- 
   Definition N
}

Sınıf Tanımı

class student {
   var studname: String
   var mark: Int 
   var mark2: Int 
}

Örnek oluşturmak için sözdizimi

let studrecord = student()

Misal

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

class studentMarks {
   var mark = 300
}

let marks = studentMarks()
print("Mark is \(marks.mark)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Mark is 300

Sınıf Özelliklerine Referans Türleri Olarak Erişme

Sınıf özelliklerine '.' İle erişilebilir. sözdizimi. Mülk adı bir "." İle ayrılır. örnek adından sonra.

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

class studentMarks {
   var mark1 = 300
   var mark2 = 400
   var mark3 = 900
}

let marks = studentMarks()
print("Mark1 is \(marks.mark1)")
print("Mark2 is \(marks.mark2)")
print("Mark3 is \(marks.mark3)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Mark1 is 300
Mark2 is 400
Mark3 is 900

Sınıf Kimliği Operatörleri

Swift 4'teki sınıflar, tek bir örneğe işaret eden birden çok sabit ve değişkeni ifade eder. Belirli bir sınıfa işaret eden sabitler ve değişkenler hakkında bilgi sahibi olmak için örnek kimlik operatörleri kullanılır. Sınıf örnekleri her zaman referans olarak aktarılır. Sınıflarda NSString, NSArray ve NSDictionary örnekleri her zaman bir kopya yerine mevcut bir örneğe referans olarak atanır ve aktarılır.

Operatörlerle Özdeş	Operatörlerle Özdeş Değil
Kullanılan operatör (===)	Kullanılan operatör (! ==)
İki sabit veya değişken aynı örneğe işaret ettiğinde doğru döndürür	İki sabit veya değişken farklı bir örneğe işaret ettiğinde doğru döndürür

class SampleClass: Equatable {
   let myProperty: String
   init(s: String) {
      myProperty = s
   }
}

func ==(lhs: SampleClass, rhs: SampleClass) -> Bool {
   return lhs.myProperty == rhs.myProperty
}

let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")

spClass1 === spClass2 // false
print("\(spClass1)")

spClass1 !== spClass2 // true
print("\(spClass2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

main.SampleClass
main.SampleClass

Swift 4 dili, değerleri ilişkilendirmek için sınıf, numaralandırma veya yapı için özellikler sağlar. Özellikler ayrıca Saklanan özellikler ve Hesaplanmış özellikler olarak sınıflandırılabilir.

Depolanan Özellikler ve Hesaplanan Özellikler arasındaki fark

Depolanan Mülk	Hesaplanan Mülk
Sabit ve değişken değerleri örnek olarak saklayın	Değeri saklamak yerine bir değer hesaplayın
Sınıflar ve yapılar tarafından sağlanır	Sınıflar, numaralandırmalar ve yapılar tarafından sağlanır

Hem Depolanan hem de Hesaplanan özellikler, örnek türleriyle ilişkilendirilir. Özellikler tip değerleriyle ilişkilendirildiğinde 'Tip Özellikleri' olarak tanımlanır. Depolanan ve hesaplanan özellikler genellikle belirli bir türdeki örneklerle ilişkilendirilir. Bununla birlikte, özellikler aynı zamanda türün kendisiyle de ilişkilendirilebilir. Bu tür özellikler, tip özellikleri olarak bilinir. Emlak gözlemcileri de kullanılır

Depolanan mülklerin değerini gözlemlemek için
Üst sınıftan türetilen miras alınan alt sınıfın özelliğini gözlemlemek için

Depolanan Özellikler

Swift 4, sabitlerin ve değişkenlerin örneklerini depolamak için Depolanan Mülk konseptini sunar. Sabitlerin saklanan özellikleri 'let' anahtar sözcüğü ile tanımlanır ve değişkenlerin Saklanan özellikleri 'var' anahtar sözcüğü ile tanımlanır.

Tanımlama sırasında Saklanan özellik 'varsayılan değer' sağlar
Başlatma sırasında kullanıcı ilk değerleri başlatabilir ve değiştirebilir

struct Number {
   var digits: Int
   let pi = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.pi)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

67
3.1415

Yukarıdaki kodda aşağıdaki satırı düşünün -

let pi = 3.1415

Burada pi değişkeni, pi = 3.1415 örneği ile depolanmış bir özellik değeri olarak başlatılır. Dolayısıyla, örnek ne zaman yönlendirilirse, yalnızca 3,1415 değerini tutacaktır.

Depolanan mülke sahip olmanın başka bir yöntemi, sabit yapılar olarak sahip olmaktır. Dolayısıyla, yapıların tüm örneği 'Sabitlerin Depolanmış Özellikleri' olarak kabul edilecektir.

struct Number {
   var digits: Int
   let numbers = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.numbers)")
n.numbers = 8.7

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

error: cannot assign to 'numbers' in 'n'
n.numbers = 8.7

"Sayı" yı 8.7 olarak yeniden başlatmak yerine "sayı" nın sabit olarak bildirildiğini belirten bir hata mesajı döndürecektir.

Tembel Depolanan Mülk

Swift 4, değişken ilk kez başlatıldığında başlangıç değerlerini hesaplamayacağı 'Lazy Stored Property' adlı esnek bir özellik sağlar. "lazy" değiştiricisi, onu bir tembel depolanan özellik olarak almak için değişken bildiriminden önce kullanılır.

Tembel Özellikler kullanılır -

Nesne oluşturmayı geciktirmek için.
Özellik bir sınıfın henüz bilinmeyen diğer bölümlerine bağlı olduğunda

class sample {
   lazy var no = number()    // `var` declaration is required.
}

class number {
   var name = "Swift 4"
}

var firstsample = sample()
print(firstsample.no.name)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Swift 4

Örnek değişkenler

Amaç C'de, Depolanan özellikler, depolanan özellikte bildirilen değerleri depolamak için yedekleme amacıyla örnek değişkenlere de sahiptir.

Swift 4, bu iki kavramı da tek bir 'depolanan özellik' bildiriminde birleştirir. Karşılık gelen bir örnek değişkenine ve yedekleme değerine sahip olmak yerine 'depolanmış özellik', değişken adı, veri türü ve bellek yönetimi işlevleriyle değişkenler özelliği hakkında tek bir konumda tanımlanan tüm entegre bilgileri içerir.

Hesaplanan Özellikler

Değer hesaplanan özellikleri saklamak yerine, diğer özellikleri ve değerleri dolaylı olarak almak ve ayarlamak için bir alıcı ve isteğe bağlı bir ayarlayıcı sağlar.

class sample {
   var no1 = 0.0, no2 = 0.0
   var length = 300.0, breadth = 150.0

   var middle: (Double, Double) {
      get {
         return (length / 2, breadth / 2)
      }
      
      set(axis){
         no1 = axis.0 - (length / 2)
         no2 = axis.1 - (breadth / 2)
      }
   }
}

var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)

print(result.no1)
print(result.no2)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

(150.0, 75.0)
-150.0
-65.0

Hesaplanan bir özellik yeni değeri tanımsız olarak bıraktığında, bu belirli değişken için varsayılan değer ayarlanacaktır.

Salt Okunur Özellikler Olarak Hesaplanan Özellikler

Hesaplanan özellikteki salt okunur özellik, alıcıya sahip ancak ayarlayıcı bulunmayan bir özellik olarak tanımlanır. Her zaman bir değer döndürmek için kullanılır. Değişkenlere ayrıca bir '.' Aracılığıyla erişilebilir. Sözdizimi ancak başka bir değere ayarlanamaz.

class film {
   var head = ""
   var duration = 0.0
   var metaInfo: [String:String] {
      return [
         "head": self.head,
         "duration":"\(self.duration)"
      ]
   }
}

var movie = film()
movie.head = "Swift 4 Properties"
movie.duration = 3.09

print(movie.metaInfo["head"]!)
print(movie.metaInfo["duration"]!)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Swift 4 Properties
3.09

Özellik Gözlemcileri Olarak Hesaplanan Özellikler

Swift 4'te özellik değerlerini gözlemlemek ve bunlara yanıt vermek için Özellik Gözlemcileri kullanılır. Özellik değerleri ayarlandığında her seferinde özellik gözlemcileri çağrılır. Tembel depolanan özellikler haricinde, "miras alınan" özelliğe "geçersiz kılma" yöntemi ile özellik gözlemcileri ekleyebiliriz.

Mülk Gözlemcileri aşağıdakilerden biri ile tanımlanabilir:

Değeri kaydetmeden önce - willset
Yeni değeri kaydettikten sonra - didset
Bir özellik bir başlatıcıda ayarlandığında ayarlanır ve didset gözlemcileri çağrılamaz.

class Samplepgm {
   var counter: Int = 0 {
      willSet(newTotal){
         print("Total Counter is: \(newTotal)")
      }
      
      didSet {
         if counter > oldValue {
            print("Newly Added Counter \(counter - oldValue)")
         }
      }
   }
}

let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

Yerel ve Küresel Değişkenler

Özellikleri hesaplamak ve gözlemlemek için yerel ve global değişken bildirilmiştir.

Yerel Değişkenler	Global Değişkenler
Bir işlev, yöntem veya kapanış bağlamı içinde tanımlanan değişkenler.	İşlev, yöntem, kapanış veya tür bağlamı dışında tanımlanan değişkenler.
Değerleri saklamak ve almak için kullanılır.	Değerleri saklamak ve almak için kullanılır.
Depolanan özellikler, değerleri almak ve ayarlamak için kullanılır.	Depolanan özellikler, değerleri almak ve ayarlamak için kullanılır.
Hesaplanan özellikler de kullanılır.	Hesaplanan özellikler de kullanılır.

Tip Özellikleri

Özellikler, Tür tanımı bölümünde kaşlı ayraçlarla {} tanımlanır ve değişkenlerin kapsamı da önceden tanımlanır. Değer türleri için tür özelliklerini tanımlamak için 'statik' anahtar sözcüğü ve sınıf türleri için 'sınıf' anahtar sözcüğü kullanılır.

Sözdizimi

struct Structname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

enum Enumname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

class Classname {
   class var computedTypeProperty: Int {
      // return an Int value here
   }
}

Sorgulama ve Özellikleri Ayarlama

Örnek özellikleri gibi Tür özellikleri sorgulanır ve '.' İle ayarlanır. Sözdizimi, örneğe işaret etmek yerine yalnızca tür üzerinde.

struct StudMarks {
   static let markCount = 97
   static var totalCount = 0
   
   var InternalMarks: Int = 0 {
      didSet {
         if InternalMarks > StudMarks.markCount {
            InternalMarks = StudMarks.markCount
         }
         if InternalMarks > StudMarks.totalCount {
            StudMarks.totalCount = InternalMarks
         }
      }
   }
}

var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()

stud1Mark1.InternalMarks = 98
print(stud1Mark1.InternalMarks)

stud1Mark2.InternalMarks = 87
print(stud1Mark2.InternalMarks)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

97
87

Swift 4'te dil Belirli türlerle ilişkili İşlevler, Yöntemler olarak adlandırılır. Amaç C Sınıflarında yöntemleri tanımlamak için kullanılırken, Swift 4 dili kullanıcıya Sınıflar, Yapılar ve Numaralandırmalar için yöntemlere sahip olma esnekliği sağlar.

Örnek Yöntemleri

Swift 4 dilinde, Sınıflar, Yapılar ve Numaralandırma örneklerine örnek yöntemlerle erişilir.

Örnek yöntemleri işlevsellik sağlar

Örnek özelliklerine erişmek ve bunları değiştirmek için
örneğin ihtiyacıyla ilgili işlevsellik

Örnek yöntemi {} süslü parantezlerin içine yazılabilir. Tür örneğinin yöntemlerine ve özelliklerine örtük erişimi vardır. Türün belirli bir örneği çağrıldığında, o belirli örneğe erişecektir.

Sözdizimi

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

Misal

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}
let pri = calculations(a: 600, b: 300)
pri.result()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Result is: 880
Result is: 850

Sınıf Hesaplamaları iki örnek yöntemi tanımlar -

init (), a ve b olmak üzere iki sayıyı toplamak ve bunu 'res' sonucunda saklamak için tanımlanmıştır.
tot (), 'res'i' c 'değerini geçirmekten çıkarmak için kullanılır

Son olarak, hesaplama yöntemlerini a ve b değerleri ile yazdırmak için çağrılır. Örnek yöntemlerine "." İle erişilir. nokta sözdizimi

Yerel ve Harici Parametre Adları

Swift 4 İşlevleri, değişkenleri için hem yerel hem de genel bildirimleri açıklar. Benzer şekilde, Swift 4 Yöntemleri adlandırma kuralları da Hedef C'ye benzer. Ancak yerel ve genel parametre adı bildirimlerinin özellikleri, işlevler ve yöntemler için farklıdır. Swift 4'teki ilk parametre, erişimi kolay adlandırma kuralları için 'with', 'for' ve 'by' olarak edat adlarıyla anılır.

Swift 4, ilk parametre adını yerel parametre adları olarak ve kalan parametre adlarını da genel parametre adları olarak bildirerek yöntemlerde esneklik sağlar. Burada 'no1', Swift 4 yöntemleri tarafından yerel parametre adları olarak bildirilmiştir. 'no2', genel bildirimler için kullanılır ve program üzerinden erişilir.

class division {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 / no2
      print(count)
   }
}

let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

600
320
3666

# Ve _ Sembollü Harici Parametre Adı

Swift 4 yöntemleri yerel bildirimler için ilk parametre adlarını sağlasa da, kullanıcının parametre adlarını yerelden küresel bildirimlere değiştirme hükmü vardır. Bu, ilk parametre adı ile '#' sembolünün önüne konarak yapılabilir. Bunu yaparak, ilk parametreye modüller boyunca global olarak erişilebilir.

Kullanıcının harici bir adla sonraki parametre adlarına erişmesi gerektiğinde, yöntem adı '_' sembolü yardımıyla geçersiz kılınır.

class multiplication {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 * no2
      print(count)
   }
}

let counter = multiplication()

counter.incrementBy(no1: 800, no2: 3)
counter.incrementBy(no1: 100, no2: 5)
counter.incrementBy(no1: 15000, no2: 3)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

2400
500
45000

Yöntemlerde öz mülkiyet

Yöntemler, tüm tanımlanmış tür örnekleri için 'self' olarak bilinen örtük bir özelliğe sahiptir. 'Self' özelliği, tanımlanmış yöntemleri için mevcut örnekleri belirtmek için kullanılır.

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
      print("Inside Self Block: \(res)")
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450

Örnek Yöntemlerinden Değer Türlerini Değiştirme

Swift 4'te dil yapıları ve numaralandırmaları, örnek yöntemleriyle değiştirilemeyen değer türlerine aittir. Ancak Swift 4 dili, davranışları 'değiştirerek' değer türlerini değiştirme esnekliği sağlar. Mutate, örnek yöntemlerinde herhangi bir değişiklik yapacak ve yöntemin çalıştırılmasından sonra orijinal forma geri dönecektir. Ayrıca, 'self' özelliğiyle, örtük işlevi için yeni bir örnek oluşturulur ve çalıştırıldıktan sonra mevcut yöntemi değiştirir.

struct area {
   var length = 1
   var breadth = 1
   
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      length *= res
      breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Mutasyon Yöntemi için Öz Mülkiyet

'Self' özelliğiyle birleştirilen mutasyon yöntemleri, tanımlanan yönteme yeni bir örnek atar.

struct area {
   var length = 1
   var breadth = 1
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      self.length *= res
      self.breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda aşağıdaki sonucu alıyoruz. -

39
65

Tür Yöntemleri

Bir yöntemin belirli bir örneği çağrıldığında, bu bir Örnek yöntemi olarak adlandırılır; ve yöntem belirli bir yöntem türünü çağırdığında, buna 'Tür Yöntemleri' denir. 'Sınıflar' için tür yöntemleri 'func' anahtar sözcüğü ile tanımlanır ve yapılar ve numaralandırma türü yöntemleri, 'func' anahtar sözcüğünden önce 'static' anahtar sözcüğü ile tanımlanır.

Tür yöntemleri çağrılır ve erişilir '.' belirli bir örneği çağırmak yerine tüm yöntemin çağrıldığı sözdizimi.

class Math {
   class func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

struct absno {
   static func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

let no = Math.abs(number: -35)
let num = absno.abs(number: -5)

print(no)
print(num)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda aşağıdaki sonucu alıyoruz. -

35
5

Sınıflar, Yapılar ve Numaralandırmalarda bir koleksiyonun, dizinin ve bir listenin eleman üyelerine erişim, abonelerin yardımıyla gerçekleştirilir. Bu aboneler, değerleri indeks yardımıyla saklamak ve almak için kullanılır. Dizi öğelerine someArray [index] yardımıyla erişilir ve bir Dictionary örneğindeki sonraki üye öğelerine someDicitonary [anahtar] olarak erişilebilir.

Tek bir tür için, alt simgeler, tekli bildirimden çoklu bildirime kadar değişebilir. Alt simgeye aktarılan dizin değerinin türünü aşırı yüklemek için uygun alt simgeyi kullanabiliriz. Alt simgeler ayrıca, giriş veri türü bildirimleri için kullanıcı gereksinimlerine göre tek boyuttan çoklu boyuta kadar değişir.

Alt Simge Bildirimi Sözdizimi ve Kullanımı

Hesaplanan özelliklerin bir özetini alalım. Alt simgeler de hesaplanan özelliklerle aynı sözdizimini izler. Tür örneklerini sorgulamak için, alt simgeler köşeli parantez içine yazılır ve ardından örnek adı verilir. Alt simge sözdizimi, 'örnek yöntemi' ve 'hesaplanan özellik' sözdizimiyle aynı sözdizimi yapısını izler. 'alt simge' anahtar sözcüğü, alt simgelerin tanımlanması için kullanılır ve kullanıcı, dönüş türleriyle birlikte tek veya birden çok parametre belirtebilir. Abonelikler okuma-yazma veya salt okunur özelliklere sahip olabilir ve örnekler, hesaplanan özelliklerinki gibi 'alıcı' ve 'ayarlayıcı' özelliklerinin yardımıyla depolanır ve alınır.

Sözdizimi

subscript(index: Int) −> Int {
   get {
      // used for subscript value declarations
   }
   set(newValue) {
      // definitions are written here
   }
}

Örnek 1

struct subexample {
   let decrementer: Int
   subscript(index: Int) -> Int {
      return decrementer / index
   }
}
let division = subexample(decrementer: 100)

print("The number is divisible by \(division[9]) times")
print("The number is divisible by \(division[2]) times")
print("The number is divisible by \(division[3]) times")
print("The number is divisible by \(division[5]) times")
print("The number is divisible by \(division[7]) times")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

The number is divisible by 11 times
The number is divisible by 50 times
The number is divisible by 33 times
The number is divisible by 20 times
The number is divisible by 14 times

Örnek2

class daysofaweek {
   private var days = ["Sunday", "Monday", "Tuesday", "Wednesday",
      "Thursday", "Friday", "saturday"]
   subscript(index: Int) -> String {
      get {
         return days[index]
      }
      set(newValue) {
         self.days[index] = newValue
      }
   }
}
var p = daysofaweek()

print(p[0])
print(p[1])
print(p[2])
print(p[3])

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Sunday
Monday
Tuesday
Wednesday

Alt Simge Seçenekleri

Alt simgeler, birden çok girdi parametresini alır ve bu girdi parametreleri de herhangi bir veri türüne aittir. Ayrıca değişken ve değişken parametreleri de kullanabilirler. Alt simgeler varsayılan parametre değerleri sağlayamaz veya herhangi bir giriş parametresi kullanamaz.

Birden çok alt simgenin tanımlanması, bir sınıf veya yapının gerektiği gibi birden çok alt simge tanımı sağlayabildiği "alt simge aşırı yükleme" olarak adlandırılır. Bu çok sayıda alt simge, alt simge ayraçları içinde bildirilen değer türlerine göre çıkarılır.

struct Matrix {
   let rows: Int, columns: Int
   var print: [Double]
   init(rows: Int, columns: Int) {
      self.rows = rows
      self.columns = columns
      print = Array(count: rows * columns, repeatedValue: 0.0)
   }
   subscript(row: Int, column: Int) -> Double {
      get {
         return print[(row * columns) + column]
      }
      set {
         print[(row * columns) + column] = newValue
      }
   }
}
var mat = Matrix(rows: 3, columns: 3)

mat[0,0] = 1.0
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0

print("\(mat[0,0])")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

1.0

Swift 4 alt simgesi, uygun veri türleri için tek parametreyi birden çok parametre bildirimine destekler. Program, 'Çift' veri türlerini depolamak için 'Matrix' yapısını 2 * 2 boyutlu bir dizi matrisi olarak ilan eder. Matrix parametresi, satırları ve sütunları bildirmek için Tamsayı veri türleriyle girilir.

Matrix için yeni örnek, aşağıda gösterildiği gibi başlatmaya satır ve sütun sayısı iletilerek oluşturulur.

var mat = Matrix(rows: 3, columns: 3)

Matris değerleri, satır ve sütun değerleri aşağıda gösterildiği gibi virgülle ayrılmış olarak alt simgeye geçirilerek tanımlanabilir.

mat[0,0] = 1.0  
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0

Birden fazla biçim alma yeteneği, Miras olarak tanımlanır. Genellikle bir sınıf, yöntemleri, özellikleri ve işlevleri başka bir sınıftan devralabilir. Sınıflar, alt sınıf ve süper sınıfa ayrılabilir.

Sub Class - Bir sınıf başka bir sınıftan özellikleri, yöntemleri ve fonksiyonları miras aldığında, buna alt sınıf denir
Super Class - Diğer sınıfları kendisinden miras alacak özellikleri, yöntemleri ve işlevleri içeren sınıf, süper sınıf olarak adlandırılır

Swift 4 sınıfları, yöntemleri, özellikleri, işlevleri ve geçersiz kılma yöntemlerini çağıran ve bunlara erişen üst sınıf içerir. Ayrıca, özellik gözlemcileri, bir özellik eklemek ve depolanan veya hesaplanan özellik yöntemlerini değiştirmek için de kullanılır.

Temel Sınıf

Başka bir sınıftan yöntemleri, özellikleri veya işlevleri miras almayan bir Sınıf, 'Temel Sınıf' olarak adlandırılır.

class StudDetails {
   var stname: String!
   var mark1: Int!
   var mark2: Int!
   var mark3: Int!
   
   init(stname: String, mark1: Int, mark2: Int, mark3: Int) {
      self.stname = stname
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

let stname = "Swift 4"
let mark1 = 98
let mark2 = 89
let mark3 = 76

print(stname)
print(mark1)
print(mark2)
print(mark3)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Swift 4
98
89
76

StudDetails sınıf adlı sınıf, burada öğrencilerin adını içeren bir temel sınıf olarak tanımlanır ve üç konu işaret1, işaret2 ve işaret3 olarak işaretlenir. 'let' anahtar sözcüğü, temel sınıfın değerini başlatmak için kullanılır ve temel sınıf değeri, 'print' işlevi yardımıyla oyun alanında görüntülenir.

Alt sınıf

Yeni bir sınıfı mevcut bir sınıfa dayandırma eylemi 'Alt Sınıf' olarak tanımlanır. Alt sınıf, temel sınıfının özelliklerini, yöntemlerini ve işlevlerini miras alır. Bir alt sınıf tanımlamak için ':', temel sınıf adından önce kullanılır

class StudDetails {
   var mark1: Int;
   var mark2: Int;
   
   init(stm1:Int, results stm2:Int) {
      mark1 = stm1;
      mark2 = stm2;
   }
   func print() {
      print("Mark1:\(mark1), Mark2:\(mark2)")
   }
}

class display : StudDetails {
   init() {
      super.init(stm1: 93, results: 89)
   }
}

let marksobtained = display()
marksobtained.print()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Mark1:93, Mark2:89

'StudDetails' sınıfı, öğrenci notlarının beyan edildiği ve alt sınıf 'gösteriminin' markaları süper sınıfından devralmak için kullanıldığı süper sınıf olarak tanımlanır. Alt sınıf, öğrencilerin işaretlerini tanımlar ve öğrencilerin işaretini görüntülemek için print () yöntemini çağırır.

Geçersiz kılma

Süper sınıf örneğine, tür yöntemlerine, örneğe, tür özelliklerine ve alt simge alt sınıfına erişim, geçersiz kılma kavramını sağlar. "override" anahtar sözcüğü, üst sınıfta bildirilen yöntemleri geçersiz kılmak için kullanılır.

Süper Sınıf Yöntemlere, Özelliklere ve Alt Dosyalara Erişim

'super' anahtar sözcüğü, süper sınıfta belirtilen yöntemlere, özelliklere ve aboneliklere erişmek için bir önek olarak kullanılır.

Geçersiz kılma	Yöntemlere, özelliklere ve aboneliklere erişim
Yöntemler	super.somemethod ()
Özellikleri	super.someProperty ()
Abonelikler	süper [someIndex]

Geçersiz Kılma Yöntemleri

Devralınan örnek ve tür yöntemleri, alt sınıfımızda tanımlanan yöntemlerimiz için 'geçersiz kıl' anahtar sözcüğü ile geçersiz kılınabilir. Burada, print () süper sınıfında belirtilen type özelliğine erişmek için alt sınıfta print () geçersiz kılınır. Ayrıca kriket () süper sınıfının yeni bir örneği 'cricinstance' olarak oluşturulur.

class cricket {
   func print() {
      print("Welcome to Swift 4 Super Class")
   }
}

class tennis: cricket {
   override func print() {
      print("Welcome to Swift 4 Sub Class")
   }
}

let cricinstance = cricket()
cricinstance.print()

let tennisinstance = tennis()
tennisinstance.print()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Welcome to Swift Super Class
Welcome to Swift Sub Class

Mülk Geçersiz Kılma

Bu özellik için kendi özel alıcı ve ayarlayıcınızı sağlamak için veya altta yatan özellik değeri değiştiğinde geçersiz kılma özelliğinin gözlemlenmesini sağlamak için özellik gözlemcileri eklemek için miras alınan bir örneği veya sınıf özelliğini geçersiz kılabilirsiniz.

Özellik Getiricileri ve Ayarlayıcıları Geçersiz Kılma

Swift 4, kullanıcının, ister saklı ister hesaplanmış bir özellik olsun, miras alınan özelliği geçersiz kılmak için özel alıcı ve ayarlayıcı sağlamasına izin verir. Alt sınıf, miras alınan özellik adını ve türünü bilmiyor. Bu nedenle, kullanıcının alt sınıfta, süper sınıfta belirtilen geçersiz kılma özelliğinin adını ve türünü belirtmesi önemlidir.

Bu iki şekilde yapılabilir -

Özelliği geçersiz kılmak için ayarlayıcı tanımlandığında, kullanıcının alıcıyı da tanımlaması gerekir.
Miras alınan özellik alıcıyı değiştirmek istemediğimizde, miras alınan değeri 'super.someProperty' sözdizimi ile süper sınıfa geçirebiliriz.

class Circle {
   var radius = 12.5
   var area: String {
      return "of rectangle for \(radius) "
   }
}

class Rectangle: Circle {
   var print = 7
   override var area: String {
      return super.area + " is now overridden as \(print)"
   }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Radius of rectangle for 25.0  is now overridden as 3

Öncelikli Mülkiyet Gözlemcileri

Devralınan bir mülk için yeni bir özellik eklenmesi gerektiğinde, Swift 4'te 'özelliği geçersiz kılma' kavramı getirilir. Bu, miras alınan özellik değeri değiştirildiğinde kullanıcıyı bilgilendirir. Ancak, miras alınan sabit depolanan özellikler ve miras alınan salt okunur hesaplanan özellikler için geçersiz kılma geçerli değildir.

class Circle {
   var radius = 12.5
   var area: String {
     return "of rectangle for \(radius) "
   }
}

class Rectangle: Circle {
   var print = 7
   override var area: String {
      return super.area + " is now overridden as \(print)"
   }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

class Square: Rectangle {
   override var radius: Double {
      didSet {
         print = Int(radius/5.0)+1
      }
   }
}

let sq = Square()
sq.radius = 100.0
print("Radius \(sq.area)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Radius of rectangle for 25.0  is now overridden as 3
Radius of rectangle for 100.0  is now overridden as 21

Geçersiz Kılmayı Önleyecek Nihai Özellik

Kullanıcı başkalarının süper sınıf yöntemlerine, özelliklerine veya aboneliklerine erişmesini istemediğinde, Swift 4 geçersiz kılmayı önlemek için 'son' özelliği sunar. 'Final' özelliği bildirildiğinde, alt simgeler süper sınıf yöntemlerinin, özelliklerinin ve alt simgelerinin geçersiz kılınmasına izin vermez. "Süper sınıf" da "nihai" mülke sahip olmak için bir hüküm yoktur. "Nihai" özellik bildirildiğinde, kullanıcı daha fazla alt sınıf oluşturmakla sınırlandırılır.

final class Circle {
   final var radius = 12.5
   var area: String {
      return "of rectangle for \(radius) "
   }
}

class Rectangle: Circle {
   var print = 7
   override var area: String {
      return super.area + " is now overridden as \(print)"
   }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

class Square: Rectangle {
   override var radius: Double {
      didSet {
         print = Int(radius/5.0)+1
      }
   }
}

let sq = Square()
sq.radius = 100.0
print("Radius \(sq.area)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

<stdin>:14:18: error: var overrides a 'final' var
override var area: String {
^
<stdin>:7:9: note: overridden declaration is here
var area: String {
^
<stdin>:12:11: error: inheritance from a final class 'Circle'
class Rectangle: Circle {
^
<stdin>:25:14: error: var overrides a 'final' var
override var radius: Double {
^
<stdin>:6:14: note: overridden declaration is here
final var radius = 12.5

Süper sınıf "nihai" olarak ve veri türleri de "nihai" olarak bildirildiğinden, program alt sınıfların daha fazla oluşturulmasına izin vermez ve hata verir.

Swift 4'te bildirilen sınıflar, yapılar ve numaralandırmalar, bir sınıfın örneğini hazırlamak için başlatılır. İlk değer, depolanan özellik için başlatılır ve ayrıca yeni örnekler için de değerler, daha fazla ilerlemek için başlatılır. Başlatma işlevi yaratmak için anahtar sözcük, 'init ()' yöntemi ile gerçekleştirilir. Swift 4 başlatıcısı, herhangi bir değer döndürmediği için Objective-C'den farklıdır. İşlevi, işlenmeden önce yeni oluşturulan örneklerin başlatılmasını kontrol etmektir. Swift 4 ayrıca, örnekler serbest bırakıldıktan sonra bellek yönetimi işlemlerini gerçekleştirmek için "yeniden başlatma" süreci sağlar.

Depolanan Özellikler için Başlatıcı Rolü

Depolanan özellik, örnekleri işlemeden önce sınıfları ve yapıları için örnekleri başlatmalıdır. Depolanan özellikler, değerleri atamak ve başlatmak için başlatıcıyı kullanır, böylece özellik gözlemcilerini çağırma ihtiyacını ortadan kaldırır. Başlatıcı, depolanmış mülkte kullanılır

Bir başlangıç değeri oluşturmak için.
Özellik tanımı içinde varsayılan özellik değeri atamak için.
Belirli bir veri türü için bir örneği başlatmak için 'init ()' kullanılır. İnit () işlevi içinde hiçbir argüman iletilmez.

Sözdizimi

init() {
   //New Instance initialization goes here
}

Misal

struct rectangle {
   var length: Double
   var breadth: Double
   init() {
      length = 6
      breadth = 12
   }
}

var area = rectangle()
print("area of rectangle is \(area.length*area.breadth)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

area of rectangle is 72.0

Burada 'dikdörtgen' yapısı, üye uzunluğu ve genişliği ile 'Çift' veri türleri olarak başlatılır. Init () yöntemi, yeni oluşturulan üyelerin uzunluğu ve çiftinin değerlerini başlatmak için kullanılır. Dikdörtgenin alanı hesaplanır ve dikdörtgen işlevi çağrılarak döndürülür.

Özellik Değerlerini Varsayılan Olarak Ayarlama

Swift 4 dili, saklanan özellik değerlerini başlatmak için Init () işlevi sağlar. Ayrıca, kullanıcı, sınıf veya yapı üyelerini bildirirken özellik değerlerini varsayılan olarak başlatma imkanına sahiptir. Özellik, program boyunca tek başına aynı değeri aldığında, onu init () içinde başlatmak yerine tek başına bildirim bölümünde bildirebiliriz. Özellik değerlerinin varsayılan olarak ayarlanması, sınıflar veya yapılar için miras tanımlandığında kullanıcıyı etkinleştirir.

struct rectangle {
   var length = 6
   var breadth = 12
}

var area = rectangle()
print("area of rectangle is \(area.length*area.breadth)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

area of rectangle is 72

Burada init () 'de uzunluk ve genişlik bildirmek yerine, değerler bildirimin kendisinde başlatılır.

Parametreleri Başlatma

Swift 4 dilinde kullanıcı, init () kullanarak başlatıcının tanımının bir parçası olarak parametreleri başlatma imkanına sahiptir.

struct Rectangle {
   var length: Double
   var breadth: Double
   var area: Double
   
   init(fromLength length: Double, fromBreadth breadth: Double) {
      self.length = length
      self.breadth = breadth
      area = length * breadth
   }
   init(fromLeng leng: Double, fromBread bread: Double) {
      self.length = leng
      self.breadth = bread
      area = leng * bread
   }
}

let ar = Rectangle(fromLength: 6, fromBreadth: 12)
print("area is: \(ar.area)")

let are = Rectangle(fromLeng: 36, fromBread: 12)
print("area is: \(are.area)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

area is: 72.0
area is: 432.0

Yerel ve Dış Parametreler

Başlatma parametreleri, işlev ve yöntem parametrelerine benzer hem yerel hem de genel parametre adlarına sahiptir. Yerel parametre bildirimi, başlatma gövdesi içine erişmek için kullanılır ve harici parametre bildirimi, başlatıcıyı çağırmak için kullanılır. Swift 4 başlatıcıları, hangi işlevleri çağırmak için hangi başlatıcının kullanıldığını tanımlamadıkları için işlev ve yöntem başlatıcıdan farklıdır.

Bunun üstesinden gelmek için Swift 4, init () içindeki her bir parametre için otomatik bir harici ad sunar. Bu otomatik harici ad, her başlatma parametresinden önce yazılan yerel adla eşdeğerdir.

struct Days {
   let sunday, monday, tuesday: Int
   init(sunday: Int, monday: Int, tuesday: Int) {
      self.sunday = sunday
      self.monday = monday
      self.tuesday = tuesday
   }
   init(daysofaweek: Int) {
      sunday = daysofaweek
      monday = daysofaweek
      tuesday = daysofaweek
   }
}

let week = Days(sunday: 1, monday: 2, tuesday: 3)
print("Days of a Week is: \(week.sunday)")
print("Days of a Week is: \(week.monday)")
print("Days of a Week is: \(week.tuesday)")

let weekdays = Days(daysofaweek: 4)
print("Days of a Week is: \(weekdays.sunday)")
print("Days of a Week is: \(weekdays.monday)")
print("Days of a Week is: \(weekdays.tuesday)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Days of a Week is: 1
Days of a Week is: 2
Days of a Week is: 3
Days of a Week is: 4
Days of a Week is: 4
Days of a Week is: 4

Harici Adsız Parametreler

Başlatma için harici bir ad gerekmediğinde, varsayılan davranışı geçersiz kılmak için '_' kullanılır.

struct Rectangle {
   var length: Double
   
   init(frombreadth breadth: Double) {
      length = breadth * 10
   }
   init(frombre bre: Double) {
      length = bre * 30
   }
   init(_ area: Double) {
      length = area
   }
}

let rectarea = Rectangle(180.0)
print("area is: \(rectarea.length)")

let rearea = Rectangle(370.0)
print("area is: \(rearea.length)")

let recarea = Rectangle(110.0)
print("area is: \(recarea.length)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

area is: 180.0
area is: 370.0
area is: 110.0

İsteğe Bağlı Emlak Türleri

Bazı durumlarda depolanan özellik herhangi bir değer döndürmediğinde, özellik o belirli tür için "değer yok" un döndürüldüğünü belirten "isteğe bağlı" bir türle bildirilir. Depolanan özellik "isteğe bağlı" olarak bildirildiğinde, başlatma sırasında değeri otomatik olarak "sıfır" olarak başlatır.

struct Rectangle {
   var length: Double?
   
   init(frombreadth breadth: Double) {
      length = breadth * 10
   }
   init(frombre bre: Double) {
      length = bre * 30
   }
   init(_ area: Double) {
      length = area
   }
}

let rectarea = Rectangle(180.0)
print("area is: \(rectarea.length)")

let rearea = Rectangle(370.0)
print("area is: \(rearea.length)")

let recarea = Rectangle(110.0)
print("area is: \(recarea.length)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

Başlatma Sırasında Sabit Özellikleri Değiştirme

Başlatma ayrıca kullanıcının sabit özelliğin değerini değiştirmesine de izin verir. Başlatma sırasında sınıf özelliği, sınıf örneklerinin alt sınıf tarafından değil süper sınıf tarafından değiştirilmesine izin verir. Örneğin, önceki programda 'uzunluk' ana sınıfta 'değişken' olarak bildirilmiştir. Aşağıdaki program değişkeni 'uzunluk', 'sabit' değişken olarak değiştirilmiştir.

struct Rectangle {
   let length: Double?
   
   init(frombreadth breadth: Double) {
      length = breadth * 10
   }
   init(frombre bre: Double) {
      length = bre * 30
   }
   init(_ area: Double) {
      length = area
   }
}

let rectarea = Rectangle(180.0)
print("area is: \(rectarea.length)")

let rearea = Rectangle(370.0)
print("area is: \(rearea.length)")

let recarea = Rectangle(110.0)
print("area is: \(recarea.length)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

Varsayılan Başlatıcılar

Varsayılan başlatıcılar, temel sınıfın veya yapının tüm bildirilen özelliklerine varsayılan değerlerle yeni bir örnek sağlar.

class defaultexample {
   var studname: String?
   var stmark = 98
   var pass = true
}
var result = defaultexample()

print("result is: \(result.studname)")
print("result is: \(result.stmark)")
print("result is: \(result.pass)")

Oyun alanını kullanarak yukarıdaki programı çalıştırdığımızda aşağıdaki sonucu alıyoruz. -

result is: nil
result is: 98
result is: true

Yukarıdaki program, sınıf adıyla 'varsayılan örnek' olarak tanımlanmıştır. Üç üye işlev varsayılan olarak 'studname?' Olarak başlatılır. 'nil' değerlerini saklamak için, 'stmark' 98 olarak ve 'pass' Boolean değeri 'true' olarak. Aynı şekilde, sınıftaki üye değerleri, sınıf üyesi türleri işlenmeden önce varsayılan olarak başlatılabilir.

Yapı Türleri için Memberwise Başlatıcıları

Özel başlatıcılar kullanıcı tarafından sağlanmadığında, Swift 4'teki Yapı türleri otomatik olarak 'üye başlatıcıyı' alacaktır. Ana işlevi, yeni yapı örneklerini varsayılan üye olarak başlatmayla başlatmak ve ardından yeni örnek özellikleri adıyla üye olarak başlatmaya geçirilmesidir.

struct Rectangle {
   var length = 100.0, breadth = 200.0
}
let area = Rectangle(length: 24.0, breadth: 32.0)

print("Area of rectangle is: \(area.length)")
print("Area of rectangle is: \(area.breadth)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Area of rectangle is: 24.0
Area of rectangle is: 32.0

Yapılar, "uzunluk" için "uzunluk" için "100.0" ve "genişlik" için "200.0" olarak başlatma sırasında üyelik işlevleri için varsayılan olarak başlatılır. Ancak uzunluk ve genişlik değişkenlerinin 24.0 ve 32.0 olarak işlenmesi sırasında değerler geçersiz kılınır.

Değer Türleri için Başlatıcı Delegasyonu

Başlatıcı Temsilcisi, diğer başlatıcılardan başlatıcıları çağırmak olarak tanımlanır. Ana işlevi, birden çok başlatıcıda kod yinelemesini önlemek için yeniden kullanılabilirlik olarak hareket etmektir.

struct Stmark {
   var mark1 = 0.0, mark2 = 0.0
}
struct stdb {
   var m1 = 0.0, m2 = 0.0
}

struct block {
   var average = stdb()
   var result = Stmark()
   init() {}
   init(average: stdb, result: Stmark) {
      self.average = average
      self.result = result
   }

   init(avg: stdb, result: Stmark) {
      let tot = avg.m1 - (result.mark1 / 2)
      let tot1 = avg.m2 - (result.mark2 / 2)
      self.init(average: stdb(m1: tot, m2: tot1), result: result)
   }
}

let set1 = block()
print("student result is: \(set1.average.m1, set1.average.m2)
\(set1.result.mark1, set1.result.mark2)")

let set2 = block(average: stdb(m1: 2.0, m2: 2.0),
result: Stmark(mark1: 5.0, mark2: 5.0))
print("student result is: \(set2.average.m1, set2.average.m2)
\(set2.result.mark1, set2.result.mark2)")

let set3 = block(avg: stdb(m1: 4.0, m2: 4.0),
result: Stmark(mark1: 3.0, mark2: 3.0))
print("student result is: \(set3.average.m1, set3.average.m2)
\(set3.result.mark1, set3.result.mark2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

(0.0,0.0) (0.0,0.0)
(2.0,2.0) 5.0,5.0)
(2.5,2.5) (3.0,3.0)

Başlatıcı Yetkilendirme Kuralları

Değer Türleri	Sınıf Türleri
Yapılar ve numaralandırmalar gibi değer türleri için kalıtım desteklenmez. Diğer başlatıcılara başvurmak self.init aracılığıyla yapılır	Kalıtım desteklenir. Depolanan tüm özellik değerlerinin başlatıldığını kontrol eder

Sınıf Mirası ve Başlatma

Sınıf türleri, tanımlanmış depolanan özelliklerin bir başlangıç değeri, yani belirlenmiş başlatıcılar ve uygunluk başlatıcıları alıp almadığını kontrol etmek için iki tür başlatıcıya sahiptir.

Belirlenmiş Başlatıcılar ve Kullanışlı Başlatıcılar

Özel Başlatıcı	Kullanışlı Başlatıcı
Bir sınıf için birincil olarak kabul edilir	Bir sınıf için başlatmayı destekleyen olarak kabul edilir
Tüm sınıf özellikleri başlatılır ve uygun süper sınıf başlatıcı, daha fazla başlatma için çağrılır	Atanan başlatıcı, belirli bir kullanım durumu veya giriş değeri türü için sınıf örneği oluşturmak üzere kolaylık başlatıcıyla çağrılır
Her sınıf için en az bir atanmış başlatıcı tanımlanır	Sınıf başlatıcılara ihtiyaç duymadığında, kolaylık başlatıcılarının tanımlanmasına gerek yoktur.
Init (parametreler) {ifadeler}	kolaylık init (parametreler) {ifadeler}

Atanan Başlatıcılar için Program

class mainClass {
   var no1 : Int // local storage
   init(no1 : Int) {
      self.no1 = no1 // initialization
   }
}

class subClass : mainClass {
   var no2 : Int // new subclass storage
   init(no1 : Int, no2 : Int) {
      self.no2 = no2 // initialization
      super.init(no1:no1) // redirect to superclass
   }
}

let res = mainClass(no1: 10)
let print = subClass(no1: 10, no2: 20)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

res is: 10
res is: 10
res is: 20

Kullanışlı Başlatıcılar için Program

class mainClass {
   var no1 : Int // local storage
   init(no1 : Int) {
      self.no1 = no1 // initialization
   }
}

class subClass : mainClass {
   var no2 : Int
   init(no1 : Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   // Requires only one parameter for convenient method
   override convenience init(no1: Int) {
      self.init(no1:no1, no2:0)
   }
}

let res = mainClass(no1: 20)
let print = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

res is: 20
res is: 30
res is: 50

Başlatıcı Devralma ve Geçersiz Kılma

Swift 4, alt sınıflarının varsayılan olarak üye türleri için süper sınıf başlatıcılarını devralmasına izin vermez. Devralma, Süper sınıf başlatıcılara yalnızca bir dereceye kadar uygulanabilir ve bu, Otomatik Başlatıcı Devralma bölümünde tartışılacaktır.

Kullanıcının süper sınıfta tanımlanmış başlatıcılara sahip olması gerektiğinde, başlatıcıları olan alt sınıfın kullanıcı tarafından özel uygulama olarak tanımlanması gerekir. Alt sınıf tarafından geçersiz kılma yapılması gerektiğinde, süper sınıfa 'override' anahtar sözcüğü bildirilmelidir.

class sides {
   var corners = 4
   var description: String {
      return "\(corners) sides"
   }
}

let rectangle = sides()
print("Rectangle: \(rectangle.description)")

class pentagon: sides {
   override init() {
      super.init()
      corners = 5
   }
}

let bicycle = pentagon()
print("Pentagon: \(bicycle.description)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Rectangle: 4 sides
Pentagon: 5 sides

Atanmış ve Kullanışlı Başlatıcılar İş Başında

class Planet {
   var name: String
   init(name: String) {
      self.name = name
   }
   convenience init() {
      self.init(name: "[No Planets]")
   }
}

let plName = Planet(name: "Mercury")
print("Planet name is: \(plName.name)")

let noplName = Planet()
print("No Planets like that: \(noplName.name)")

class planets: Planet {
   var count: Int
   init(name: String, count: Int) {
      self.count = count
      super.init(name: name)
   }
   override convenience init(name: String) {
      self.init(name: name, count: 1)
   }
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Planet name is: Mercury
No Planets like that: [No Planets]

Kullanılabilir Başlatıcı

Bir sınıf, yapı veya numaralandırma değerleri tanımlanırken herhangi bir başlatıcı hatası olduğunda kullanıcı bilgilendirilmelidir. Değişkenlerin ilklendirilmesi bazen şu nedenlerden dolayı başarısız olur:

Geçersiz parametre değerleri.
Gerekli harici kaynağın olmaması.
Başlatmanın başarılı olmasını engelleyen koşul.

Swift 4, başlatma yöntemiyle atılan istisnaları yakalamak için, yapıyı, sınıfı veya numaralandırma üyelerini başlatırken bir şeyin fark edilmeden bırakıldığını kullanıcıya bildirmek için "kullanılabilir başlatıcı" adlı esnek bir başlatma üretir. Kullanılabilen başlatıcıyı yakalamak için anahtar kelime 'init?'. Ayrıca, kullanılabilen ve kullanılamayan başlatıcılar aynı parametre türleri ve adlarıyla tanımlanamaz.

struct studrecord {
   let stname: String
   init?(stname: String) {
      if stname.isEmpty {return nil }
      self.stname = stname
   }
}
let stmark = studrecord(stname: "Swing")

if let name = stmark {
   print("Student name is specified")
}
let blankname = studrecord(stname: "")

if blankname == nil {
   print("Student name is left blank")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Student name is specified
Student name is left blank

Numaralandırmalar için Kullanılabilir Başlatıcılar

Swift 4 dili, numaralandırma üyeleri değerleri başlatmaktan çıktığında kullanıcıyı bilgilendirmek için de numaralandırmalar için Failable başlatıcılara sahip olma esnekliği sağlar.

enum functions {
   case a, b, c, d
   init?(funct: String) {
      switch funct {
      case "one":
         self = .a
      case "two":
         self = .b
      case "three":
         self = .c
      case "four":
         self = .d
      default:
         return nil
      }
   }
}
let result = functions(funct: "two")

if result != nil {
   print("With In Block Two")
}
let badresult = functions(funct: "five")

if badresult == nil {
   print("Block Does Not Exist")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

With In Block Two
Block Does Not Exist

Sınıflar için Kullanılabilir Başlatıcılar

Numaralandırmalar ve yapılar ile bildirildiğinde, kullanılabilir bir başlatıcı, uygulaması içindeki herhangi bir durumda bir başlatma hatasını uyarır. Ancak, sınıflarda kullanılabilir başlatıcı, yalnızca depolanan özellikler bir başlangıç değerine ayarlandıktan sonra arızayı uyarır.

class studrecord {
   let studname: String!
   init?(studname: String) {
      self.studname = studname
      if studname.isEmpty { return nil }
   }
}

if let stname = studrecord(studname: "Failable Initializers") {
   print("Module is \(stname.studname)")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Module is Optional("Failable Initializers")

Kullanılabilir Bir Başlatıcıyı Geçersiz Kılma

Başlatma gibi, kullanıcı da alt sınıf içindeki bir süper sınıf kullanılabilir başlatıcıyı geçersiz kılma hükmüne sahiptir. Süper sınıf kullanılabilen başlatma, bir alt sınıfta kullanılamayan başlatıcı ile de geçersiz kılınabilir.

Alt sınıf başlatıcı, kullanılabilir olmayan bir alt sınıf başlatıcısı ile kullanılabilir bir üst sınıf başlatıcısını geçersiz kılarken, üst sınıf başlatıcısına kadar delege edemez.

Bulunamayan bir başlatıcı hiçbir zaman başarısız bir başlatıcıya delege edemez.

Aşağıda verilen program, mevcut ve bulunamayan başlatıcıları açıklamaktadır.

class Planet {
   var name: String
   
   init(name: String) {
      self.name = name
   }
   convenience init() {
      self.init(name: "[No Planets]")
   }
}
let plName = Planet(name: "Mercury")
print("Planet name is: \(plName.name)")

let noplName = Planet()
print("No Planets like that: \(noplName.name)")
   
class planets: Planet {
   var count: Int
   
   init(name: String, count: Int) {
      self.count = count
      super.init(name: name)
   }
   override convenience init(name: String) {
      self.init(name: name, count: 1)
   }
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Planet name is: Mercury
No Planets like that: [No Planets]

Başlangıç! Kullanılabilir Başlatıcı

Swift 4 'init?' Sağlar isteğe bağlı bir örnek kullanılabilir başlatıcı tanımlamak için. Belirli bir 'init!' Türünün örtük olarak sarılmamış isteğe bağlı bir örneğini tanımlamak için belirtilir.

struct studrecord {
let stname: String

   init!(stname: String) {
      if stname.isEmpty {return nil }
      self.stname = stname
   }
}
let stmark = studrecord(stname: "Swing")

if let name = stmark {
   print("Student name is specified")
}

let blankname = studrecord(stname: "")

if blankname == nil {
   print("Student name is left blank")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Student name is specified
Student name is left blank

Gerekli Başlatıcılar

Başlatma 'gerekli' anahtar sözcüğünün her bir alt sınıfını bildirmek için init () işlevinden önce tanımlanması gerekir.

class classA {
   required init() {
      var a = 10
      print(a)
   }
}

class classB: classA {
   required init() {
      var b = 30
      print(b)
   }
}

let res = classA()
let print = classB()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

10
30
10

Bir sınıf örneğinin serbest bırakılması gerekmeden önce, bellek alanını serbest bırakmak için 'deinitializer' çağrılmalıdır. 'Deinit' anahtar sözcüğü, sistem kaynaklarının kapladığı bellek alanlarını serbest bırakmak için kullanılır. Deinitialization yalnızca sınıf türlerinde kullanılabilir.

Bellek Alanını Boşaltmak İçin İlk Durumdan Çıkarma

Swift 4, kaynakları boşaltmak için artık ihtiyaç kalmadığında örneklerinizi otomatik olarak serbest bırakır. Swift 4, Otomatik Referans Sayma'da açıklandığı gibi otomatik referans sayma (ARC) aracılığıyla örneklerin bellek yönetimini yönetir. Örneklerinizin ayrılması kaldırıldığında genellikle manuel temizlik yapmanız gerekmez. Bununla birlikte, kendi kaynaklarınızla çalışırken, kendi başınıza ek temizlik yapmanız gerekebilir. Örneğin, bir dosyayı açmak ve ona bazı veriler yazmak için özel bir sınıf oluşturursanız, sınıf örneğinin serbest bırakılmasından önce dosyayı kapatmanız gerekebilir.

var counter = 0; // for reference counting
class baseclass {
   init() {
      counter++;
   }
   deinit {
      counter--;
   }
}
var print: baseclass? = baseclass()

print(counter)
print = nil
print(counter)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

1
0

Print = nil ifadesi atlandığında sayacın değerleri, başlatılmamış olduğundan aynı kalır.

var counter = 0; // for reference counting

class baseclass {
   init() {
      counter++;
   }
   deinit {
      counter--;
   }
}
var print: baseclass? = baseclass()
print(counter)
print(counter)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

1
1

Bellek yönetimi işlevleri ve kullanımı, Otomatik referans sayma (ARC) aracılığıyla Swift 4 dilinde ele alınır. ARC, sistem kaynaklarını başlatmak ve yeniden başlatmak için kullanılır, böylece örnekler artık gerekli olmadığında sınıf örnekleri tarafından kullanılan bellek alanlarını serbest bırakır. ARC, bellek kaynaklarını etkin bir şekilde yönetmek için kod örneklerimiz arasındaki ilişkiler hakkındaki bilgileri izler.

ARC'nin İşlevleri

ARC, init () tarafından yeni bir sınıf örneği oluşturulduğunda her seferinde bilgileri depolamak için bir bellek parçası ayırır.
Örnek türü ve değerleri hakkındaki bilgiler bellekte saklanır.
Sınıf örneğine artık ihtiyaç duyulmadığında, daha fazla sınıf örneği depolaması ve alımı için bellek alanını deinit () ile otomatik olarak serbest bırakır.
ARC, deinit () yalnızca kullanılmayan örneklere uygulanacak şekilde şu anda başvuran sınıf örneklerinin özelliklerini, sabitlerini ve değişkenlerini izler.
ARC, sınıf örneği şu anda kullanımdayken serbest bırakmayı kısıtlamak için bu sınıf örneği özelliğine, sabitlerine ve değişkenlerine 'güçlü bir başvuru' sağlar.

ARC Programı

class StudDetails {
   var stname: String!
   var mark: Int!
   
   init(stname: String, mark: Int) {
      self.stname = stname
      self.mark = mark
   }
   deinit {
      print("Deinitialized \(self.stname)")
      print("Deinitialized \(self.mark)")
   }
}

let stname = "Swift 4"
let mark = 98

print(stname)
print(mark)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Swift 4
98

ARC Güçlü Referans Döngüleri Sınıf Örnekleri

class studmarks {
   let name: String
   var stud: student?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

class student {
   let name: String
   var strname: studmarks?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

var shiba: studmarks?
var mari: student?

shiba = studmarks(name: "Swift 4")
mari = student(name: "ARC")

shiba!.stud = mari
mari!.strname = shiba

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Initializing: Swift 4
Initializing: ARC

ARC Zayıf ve Sahipsiz Referanslar

Sınıf türü özelliklerinin güçlü referans döngülerini çözmenin iki yolu vardır -

Zayıf Referanslar
Sahipsiz Referanslar

Bu referanslar, bir örneğin bir referans döngüsündeki diğer örneklere başvurmasını sağlamak için kullanılır. Daha sonra örnekler, güçlü referans döngüsünü önemsemek yerine her bir örneğe atıfta bulunabilir. Kullanıcı bazı örneklerin 'nil' değerleri döndürebileceğini bildiğinde, bunu zayıf referans kullanarak gösterebiliriz. Örnek nil yerine bir şey döndürecekse, bunu sahipsiz referansla bildirin.

Zayıf Referans Programı

class module {
   let name: String
   init(name: String) { self.name = name }
   var sub: submodule?
   deinit { print("\(name) Is The Main Module") }
}

class submodule {
   let number: Int
   init(number: Int) { self.number = number }
   weak var topic: module?

   deinit { print("Sub Module with its topic number is \(number)") }
}

var toc: module?
var list: submodule?
toc = module(name: "ARC")
list = submodule(number: 4)
toc!.sub = list
list!.topic = toc

toc = nil
list = nil

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

ARC Is The Main Module
Sub Module with its topic number is 4

Sahipsiz Referans Programı

class student {
   let name: String
   var section: marks?
   init(name: String) {
      self.name = name
   }
   deinit { print("\(name)") }
}

class marks {
   let marks: Int
   unowned let stname: student
   
   init(marks: Int, stname: student) {
      self.marks = marks
      self.stname = stname
   }
   deinit { print("Marks Obtained by the student is \(marks)") }
}

var module: student?
module = student(name: "ARC")
module!.section = marks(marks: 98, stname: module!)
module = nil

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

ARC
Marks Obtained by the student is 98

Kapanışlar için Güçlü Referans Döngüleri

Belirli bir örneği yakalamak için sınıf örneği özelliğine ve kapanışın gövdesine bir closure atadığımızda güçlü referans döngüsü oluşabilir. Kapanışa güçlü referans, 'self.someProperty' veya 'self.someMethod ()' ile tanımlanır. Kapaklar için referans türleri olarak güçlü referans döngüleri kullanılır.

class HTMLElement {
   let samplename: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      if let text = self.text {
         return "<\(self.samplename)>\(text)</\(self.samplename)>"
      } else {
         return "<\(self.samplename) />"
      }
   }
   init(samplename: String, text: String? = nil) {
      self.samplename = samplename
      self.text = text
   }
   deinit {
      print("\(samplename) is being deinitialized")
   }
}

var paragraph: HTMLElement? = HTMLElement(samplename: "p", text: "Welcome to Closure SRC")
print(paragraph!.asHTML())

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

<p>Welcome to Closure SRC</p>

Zayıf ve Sahipsiz Referanslar

Kapanış ve örnek birbirine atıfta bulunduğunda, kullanıcı bir kapanıştaki yakalamayı sahipsiz bir referans olarak tanımlayabilir. Bu durumda, kullanıcının aynı anda örneği serbest bırakmasına izin vermez. Örnek bazen bir 'nil' değeri döndürdüğünde, kapanışı zayıf örnekle tanımlayın.

class HTMLElement {
   let module: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      [unowned self] in
      if let text = self.text {
         return "<\(self.module)>\(text)</\(self.module)>"
      } else {
         return "<\(self.module) />"
      }
   }
   init(module: String, text: String? = nil) {
      self.module = module
      self.text = text
   }
   deinit {
      print("\(module) the deinit()")
   }
}

var paragraph: HTMLElement? = HTMLElement(module: "Inside", text: "ARC Weak References")
print(paragraph!.asHTML())
paragraph = nil

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

<Inside>ARC Weak References</Inside>
Inside the deinit()

'Sıfır' olabilen bir isteğe bağlı olarak sorgulama, özellikleri, alt simgeleri ve yöntemleri çağırma işlemi, isteğe bağlı zincirleme olarak tanımlanır. İsteğe bağlı zincirleme iki değer döndürür -

isteğe bağlı bir 'değer' içeriyorsa, ilgili özelliğini, yöntemlerini ve alt simgelerini çağırmak değerleri döndürür
isteğe bağlı bir 'nil' değeri içeriyorsa, tüm ilgili özelliği, yöntemleri ve alt simgeleri nil döndürür

Yöntemlere, özelliklere ve alt simgelere yönelik birden çok sorgu birlikte gruplandırıldığından, tek bir zincirin başarısızlığı tüm zinciri etkileyecek ve "sıfır" değeriyle sonuçlanacaktır.

Zorla Açmaya Alternatif Olarak İsteğe Bağlı Zincirleme

İsteğe bağlı zincirleme, isteğe bağlı değerden sonra "?" isteğe bağlı değer bazı değerler döndürdüğünde bir özellik, yöntem veya alt simge çağırmak için.

İsteğe Bağlı Zincirleme '?'	Yöntemlere, özelliklere ve aboneliklere erişim İsteğe Bağlı Zincirleme '!' Açmayı zorlamak
? özellik, yöntem veya indis çağırmak için isteğe bağlı değerden sonra gelir	! değerin sarmalanmasını zorlamak için özellik, yöntem veya alt simge çağırmak için isteğe bağlı değerin arkasına yerleştirilir
İsteğe bağlı "sıfır" olduğunda zarif bir şekilde başarısız olur	Zorla sarmalamadan çıkarma, isteğe bağlı "sıfır" olduğunda bir çalışma zamanı hatasını tetikler

İsteğe Bağlı Zincirleme Programı '!'

class ElectionPoll {
   var candidate: Pollbooth?
}

lass Pollbooth {
   var name = "MP"
}

let cand = ElectionPoll()
let candname = cand.candidate!.name

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

fatal error: unexpectedly found nil while unwrapping an Optional value
0 Swift 4 0x0000000103410b68
llvm::sys::PrintStackTrace(__sFILE*) + 40
1 Swift 4 0x0000000103411054 SignalHandler(int) + 452
2 libsystem_platform.dylib 0x00007fff9176af1a _sigtramp + 26
3 libsystem_platform.dylib 0x000000000000000b _sigtramp + 1854492939
4 libsystem_platform.dylib 0x00000001074a0214 _sigtramp + 1976783636
5 Swift 4 0x0000000102a85c39
llvm::JIT::runFunction(llvm::Function*, std::__1::vector > const&) + 329
6 Swift 4 0x0000000102d320b3
llvm::ExecutionEngine::runFunctionAsMain(llvm::Function*,
std::__1::vector<std::__1::basic_string, std::__1::allocator >,
std::__1::allocator<std::__1::basic_string, std::__1::allocator > > > const&,
char const* const*) + 1523
7 Swift 4 0x000000010296e6ba Swift 4::RunImmediately(Swift
4::CompilerInstance&, std::__1::vector<std::__1::basic_string,
std::__1::allocator >, std::__1::allocator<std::__1::basic_string,
std::__1::allocator > > > const&, Swift 4::IRGenOptions&, Swift 4::SILOptions
const&) + 1066
8 Swift 4 0x000000010275764b frontend_main(llvm::ArrayRef,
char const*, void*) + 5275
9 Swift 4 0x0000000102754a6d main + 1677
10 libdyld.dylib 0x00007fff8bb9e5c9 start + 1
11 libdyld.dylib 0x000000000000000c start + 1950751300
Stack dump:
0. Program arguments:
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/
usr/bin/Swift 4 -frontend -interpret - -target x86_64-apple-darwin14.0.0 -
target-cpu core2 -sdk
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/
SDKs/MacOSX10.10.sdk -module-name main
/bin/sh: line 47: 15672 Done cat <<'SWIFT 4'
import Foundation
</std::__1::basic_string</std::__1::basic_string</std::__1::basic_string</std::
__1::basic_string

Yukarıdaki program, sınıf adı olarak 'seçim anketi'ni ilan eder ve üyelik işlevi olarak' aday'ı içerir. Alt sınıf, 'anket kabini' ve 'MP' olarak başlatılan üyelik işlevi olarak 'ad' olarak ilan edilir. Süper sınıfa yapılan çağrı, isteğe bağlı "!" İle bir "cand" örneği oluşturularak başlatılır. Değerler kendi temel sınıfında bildirilmediğinden, 'nil' değeri depolanır ve böylece sarmalamaya zorlama prosedürü tarafından ölümcül bir hata döndürülür.

İsteğe Bağlı Zincirleme Programı '?'

class ElectionPoll {
   var candidate: Pollbooth?
}

class Pollbooth {
   var name = "MP"
}
let cand = ElectionPoll()

if let candname = cand.candidate?.name {
   print("Candidate name is \(candname)")
} else {
   print("Candidate name cannot be retreived")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Candidate name cannot be retreived

Yukarıdaki program, sınıf adı olarak 'seçim anketi'ni açıklar ve üyelik işlevi olarak' aday'ı içerir. Alt sınıf, 'anket kabini' ve 'MP' olarak başlatılan üyelik işlevi olarak 'ad' olarak ilan edilir. Süper sınıfa yapılan çağrı, isteğe bağlı "?" İle bir "cand" örneği oluşturularak başlatılır. Değerler, temel sınıfında bildirilmediğinden, 'nil' değeri konsolda saklanır ve else eylemci bloğu tarafından yazdırılır.

İsteğe Bağlı Zincirleme ve Özelliklere Erişim için Model Sınıflarını Tanımlama

Swift 4 dili, birden fazla alt sınıfı model sınıfları olarak bildirmek için isteğe bağlı zincirleme kavramını da sağlar. Bu kavram, karmaşık modelleri tanımlamak ve özelliklere, yöntemlere ve alt simge alt özelliklerine erişmek için çok yararlı olacaktır.

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var street: String?

   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let rectname = rectangle()
if let rectarea = rectname.print?.cprint {
   print("Area of rectangle is \(rectarea)")
} else {
   print("Rectangle Area is not specified")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Rectangle Area is not specified

İsteğe Bağlı Zincirleme Yoluyla Yöntemleri Çağırma

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }

   func circleprint() {
      print("Area of Circle is: \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if circname.print?.circleprint() != nil {
   print("Area of circle is specified)")
} else {
   print("Area of circle is not specified")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Area of circle is not specified

Circle () alt sınıfında bildirilen circleprint () işlevi, 'circname' adlı bir örnek oluşturularak çağrılır. İşlev, bir değer içeriyorsa bir değer döndürür, aksi takdirde 'if circname.print? .Circleprint ()! = Nil' ifadesini kontrol ederek kullanıcı tanımlı bir yazdırma mesajı döndürür.

İsteğe Bağlı Zincirleme ile Aboneliklere Erişim

İsteğe bağlı zincirleme, o alt simgeye yapılan çağrının bir değer döndürüp döndürmediğini doğrulamak için bir alt simge değerini ayarlamak ve almak için kullanılır. '?' belirli bir alt simge üzerindeki isteğe bağlı değere erişmek için alt simge parantezlerinin önüne yerleştirilir.

Program 1

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname =  radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if let radiusName = circname.print?[0].radiusname {
   print("The first room name is \(radiusName).")
} else {
   print("Radius is not specified.")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Radius is not specified.

Yukarıdaki programda 'radiusName' üyelik işlevi için örnek değerleri belirtilmemiştir. Dolayısıyla, işleve program çağrısı yalnızca başka bir bölümü döndürür, oysa değerleri döndürmek için belirli üyelik işlevi için değerleri tanımlamamız gerekir.

Program 2

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()
circname.print?[0] = radius(radiusname: "Diameter")
let printing = circle()

printing.area.append(radius(radiusname: "Units"))
printing.area.append(radius(radiusname: "Meter"))
circname.print = printing

if let radiusName = circname.print?[0].radiusname {
   print("Radius is measured in \(radiusName).")
} else {
   print("Radius is not specified.")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Radius is measured in Units.

Yukarıdaki programda, üyelik işlevi 'radiusName' için örnek değerleri belirtilmiştir. Bu nedenle işleve program çağrısı şimdi değerleri döndürecektir.

İsteğe Bağlı Türdeki Aboneliklere Erişim

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }

   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()
circname.print?[0] = radius(radiusname: "Diameter")

let printing = circle()
printing.area.append(radius(radiusname: "Units"))
printing.area.append(radius(radiusname: "Meter"))
circname.print = printing

var area = ["Radius": [35, 45, 78, 101], "Circle": [90, 45, 56]]
area["Radius"]?[1] = 78
area["Circle"]?[1]--

print(area["Radius"]?[0])
print(area["Radius"]?[1])
print(area["Radius"]?[2])
print(area["Radius"]?[3])

print(area["Circle"]?[0])
print(area["Circle"]?[1])
print(area["Circle"]?[2])

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Optional(35)
Optional(78)
Optional(78)
Optional(101)
Optional(90)
Optional(44)
Optional(56)

Abonelikler için isteğe bağlı değerlere, alt simge değerlerine atıfta bulunularak erişilebilir. Alt simge [0], alt simge [1] vb. Olarak erişilebilir. "Yarıçap" için varsayılan alt simge değerleri ilk önce [35, 45, 78, 101] ve "Daire" [90, 45, 56]] olarak atanır. . Ardından alt simge değerleri Yarıçap [0] olarak 78 ve Daire [1] olarak 45 olarak değiştirilir.

Birden Fazla Zincirleme Düzeyini Bağlama

Birden çok alt sınıf, isteğe bağlı zincirleme yoluyla süper sınıf yöntemleri, özellikleri ve alt simgeleriyle de bağlanabilir.

Çoklu isteğe bağlı zincirleme bağlanabilir -

Alma türü isteğe bağlı değilse, isteğe bağlı zincirleme isteğe bağlı bir değer döndürür. Örneğin, isteğe bağlı zincirleme yoluyla String varsa, String? Değer

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?

   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if let radiusName = circname.print?[0].radiusname {
   print("The first room name is \(radiusName).")
} else {
   print("Radius is not specified.")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Radius is not specified.

Yukarıdaki programda, üyelik işlevi 'radiusName' için örnek değerleri belirtilmemiştir. Dolayısıyla, işleve program çağrısı yalnızca başka bir bölümünü döndürürken, değerleri döndürmek için belirli üyelik işlevi için değerleri tanımlamamız gerekir.

Alma türü zaten isteğe bağlıysa, isteğe bağlı zincirleme de isteğe bağlı bir değer döndürür. Örneğin eğer String? İsteğe bağlı zincirleme yoluyla erişilirse, String döndürür mü? Değer ..

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()
circname.print?[0] = radius(radiusname: "Diameter")
let printing = circle()

printing.area.append(radius(radiusname: "Units"))
printing.area.append(radius(radiusname: "Meter"))
circname.print = printing

if let radiusName = circname.print?[0].radiusname {
   print("Radius is measured in \(radiusName).")
} else {
   print("Radius is not specified.")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Radius is measured in Units.

Yukarıdaki programda, üyelik işlevi 'radiusName' için örnek değerleri belirtilmiştir. Bu nedenle, işleve program çağrısı şimdi değerleri döndürecektir.

İsteğe Bağlı Dönüş Değerlerine Sahip Yöntemlerde Zincirleme

İsteğe bağlı zincirleme, alt sınıf tanımlı yöntemlere erişmek için de kullanılır.

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("Area of Circle is: \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if circname.print?.circleprint() != nil {
   print("Area of circle is specified)")
} else {
   print("Area of circle is not specified")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Area of circle is not specified

Bir örneğin türünü doğrulamak için Swift 4 dilinde 'Type Casting' devreye giriyor. Örnek türünün belirli bir süper sınıfa veya alt sınıfa ait olup olmadığını veya kendi hiyerarşisinde tanımlanmış olup olmadığını kontrol etmek için kullanılır.

Swift 4 tipi çevrim, bir değerin tipini kontrol etmek için 'is' ve 'as' ve tip değerini farklı bir türe dönüştürmek için iki operatör sağlar. Tür atama, örnek türünün belirli protokol uygunluk standardını takip edip etmediğini de kontrol eder.

Bir Sınıf Hiyerarşisi Tanımlama

Tür atama, belirli bir sınıf türüne ait olup olmadığını öğrenmek için örneklerin türünü kontrol etmek için kullanılır. Ayrıca, aynı hiyerarşi olarak yapmak için bu örnekleri kontrol etmek ve kullanmak için sınıfların hiyerarşisini ve alt sınıflarını kontrol eder.

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [ Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz

Tip Kontrolü

Tür denetimi 'is' operatörü ile yapılır. 'İs' türü kontrol operatörü, örneğin belirli bir alt sınıf türüne ait olup olmadığını kontrol eder ve bu örneğe aitse 'true' döndürür, aksi takdirde 'false' döndürür.

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [
   Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0
for item in sa {
   if item is Chemistry {
      ++chemCount
   } else if item is Maths {
      ++mathsCount
   }
}

print("Subjects in chemistry contains \(chemCount) topics and maths contains \(mathsCount) topics")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Subjects in chemistry contains 2 topics and maths contains 3 topics

Downcasting

Alt sınıf türünün aşağı çevrilmesi iki operatörle yapılabilir (? Ve as!). "As?" değer nil döndürdüğünde isteğe bağlı bir değer döndürür. Başarılı downcast'i kontrol etmek için kullanılır.

'gibi!' aşağı değerlendirme sıfır değer döndürdüğünde isteğe bağlı zincirlemede tartışıldığı gibi sarmalamaya zorlama döndürür. Downcast arızası durumunda çalışma zamanı hatasını tetiklemek için kullanılır.

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [
   Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0

for item in sa {
   if let print = item as? Chemistry {
      print("Chemistry topics are: '\(print.physics)', \(print.equations)")
   } else if let example = item as? Maths {
      print("Maths topics are: '\(example.physics)', \(example.formulae)")
   }
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series

Typecasting: Herhangi Bir Nesne

'Herhangi' anahtar sözcüğü, işlev türleri dahil herhangi bir türe ait olan bir örneği temsil etmek için kullanılır.

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [
   Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0

for item in sa {
   if let print = item as? Chemistry {
      print("Chemistry topics are: '\(print.physics)', \(print.equations)")
   } else if let example = item as? Maths {
      print("Maths topics are: '\(example.physics)', \(example.formulae)")
   }
}

var exampleany = [Any]()

exampleany.append(12)
exampleany.append(3.14159)
exampleany.append("Example for Any")
exampleany.append(Chemistry(physics: "solid physics", equations: "Hertz"))

for print in exampleany {
   switch print {
      case let someInt as Int:
         print("Integer value is \(someInt)")
      case let someDouble as Double where someDouble > 0:
         print("Pi value is \(someDouble)")
      case let someString as String:
         print("\(someString)")
      case let phy as Chemistry:   
         print("Topics '\(phy.physics)', \(phy.equations)")
      default:
         print("None")
   }
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series
Integer value is 12
Pi value is 3.14159
Example for Any
Topics 'solid physics', Hertz

AnyObject

Herhangi bir sınıf türünün örneğini temsil etmek için 'AnyObject' anahtar sözcüğü kullanılır.

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let saprint: [AnyObject] = [Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0

for item in saprint {
   if let print = item as? Chemistry {
      print("Chemistry topics are: '\(print.physics)', \(print.equations)")
   } else if let example = item as? Maths {
      print("Maths topics are: '\(example.physics)', \(example.formulae)")
   }
}

var exampleany = [Any]()
exampleany.append(12)
exampleany.append(3.14159)
exampleany.append("Example for Any")
exampleany.append(Chemistry(physics: "solid physics", equations: "Hertz"))

for print in exampleany {
   switch print {
      case let someInt as Int:
         print("Integer value is \(someInt)")
      case let someDouble as Double where someDouble > 0:
         print("Pi value is \(someDouble)")
      case let someString as String:
         print("\(someString)")
      case let phy as Chemistry:
         print("Topics '\(phy.physics)', \(phy.equations)")
      default:
         print("None")
   }
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series
Integer value is 12
Pi value is 3.14159
Example for Any
Topics 'solid physics', Hertz

Mevcut bir sınıfın, yapının veya numaralandırma türünün işlevselliği, uzantılar yardımıyla eklenebilir. Tip işlevselliği uzantılarla eklenebilir, ancak işlevselliğin geçersiz kılınması uzantılarla mümkün değildir.

Swift Extension Functionalities -

Hesaplanan özellikler ve hesaplanan tür özellikleri ekleme
Örnek ve tip yöntemlerini tanımlama.
Yeni başlatıcılar sağlamak.
Abonelikleri tanımlama
Yeni iç içe türler tanımlama ve kullanma
Mevcut bir türü bir protokole uygun hale getirmek

Uzantılar, "uzantı" anahtar kelimesiyle bildirilir

Sözdizimi

extension SomeType {
   // new functionality can be added here
}

Mevcut tür, bir protokol standardı olması için uzantılarla da eklenebilir ve sözdizimi, sınıfların veya yapılarınkine benzer.

extension SomeType: SomeProtocol, AnotherProtocol {
   // protocol requirements is described here
}

Hesaplanan Özellikler

Hesaplanan 'örnek' ve 'tür' özellikleri de uzantılar yardımıyla genişletilebilir.

extension Int {
   var add: Int {return self + 100 }
   var sub: Int { return self - 10 }
   var mul: Int { return self * 10 }
   var div: Int { return self / 5 }
}

let addition = 3.add
print("Addition is \(addition)")

let subtraction = 120.sub
print("Subtraction is \(subtraction)")

let multiplication = 39.mul
print("Multiplication is \(multiplication)")

let division = 55.div
print("Division is \(division)")

let mix = 30.add + 34.sub
print("Mixed Type is \(mix)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Addition is 103
Subtraction is 110
Multiplication is 390
Division is 11
Mixed Type is 154

Başlatıcılar

Swift 4, uzantılara göre mevcut bir türe yeni başlatıcılar ekleme esnekliği sağlar. Kullanıcı, önceden tanımlanmış türleri genişletmek için kendi özel türlerini ekleyebilir ve ek başlatma seçenekleri de mümkündür. Uzantılar yalnızca init () 'i destekler. deinit () uzantılar tarafından desteklenmiyor.

struct sum {
   var num1 = 100, num2 = 200
}

struct diff {
   var no1 = 200, no2 = 100
}

struct mult {
   var a = sum()
   var b = diff()
}

let calc = mult()
print ("Inside mult block \(calc.a.num1, calc.a.num2)")
print("Inside mult block \(calc.b.no1, calc.b.no2)")

let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100))
print("Inside mult block \(memcalc.a.num1, memcalc.a.num2)")
print("Inside mult block \(memcalc.b.no1, memcalc.b.no2)")

extension mult {
   init(x: sum, y: diff) {
      let X = x.num1 + x.num2
      let Y = y.no1 + y.no2
   }
}

let a = sum(num1: 100, num2: 200)
print("Inside Sum Block:\( a.num1, a.num2)")

let b = diff(no1: 200, no2: 100)
print("Inside Diff Block: \(b.no1, b.no2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Inside mult block (100, 200)
Inside mult block (200, 100)
Inside mult block (300, 500)
Inside mult block (300, 100)
Inside Sum Block:(100, 200)
Inside Diff Block: (200, 100)

Yöntemler

Uzantılar yardımıyla alt sınıfa yeni örnek yöntemleri ve tür yöntemleri eklenebilir.

extension Int {
   func topics(summation: () -> ()) {
      for _ in 0..<self {
         summation()
      }
   }
}

4.topics(summation: {
   print("Inside Extensions Block")
})

3.topics(summation: {
   print("Inside Type Casting Block")
})

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Type Casting Block
Inside Type Casting Block
Inside Type Casting Block

konular () işlevi, işlevin herhangi bir bağımsız değişken almadığını ve herhangi bir değer döndürmeyeceğini belirtmek için '(toplama: () → ())' türünde bağımsız değişken alır. Bu işlevi birden çok kez çağırmak için, blok başlatılır ve topic () ile yönteme çağrı başlatılır.

Değişen Örnek Yöntemleri

Örnek yöntemleri, uzantı olarak bildirildiğinde de değiştirilebilir.

Kendini veya özelliklerini değiştiren yapı ve numaralandırma yöntemleri, örnek yöntemini, tıpkı orijinal bir uygulamadaki değiştirme yöntemlerinde olduğu gibi, mutasyon olarak işaretlemelidir.

extension Double {
   mutating func square() {
      let pi = 3.1415
      self = pi * self * self
   }
}

var Trial1 = 3.3
Trial1.square()
print("Area of circle is: \(Trial1)")

var Trial2 = 5.8
Trial2.square()
print("Area of circle is: \(Trial2)")

var Trial3 = 120.3
Trial3.square()
print("Area of circle is: \(Trial3)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Area of circle is: 34.210935
Area of circle is: 105.68006
Area of circle is: 45464.070735

Abonelikler

Halihazırda bildirilmiş örneklere yeni abonelikler eklemek uzantılarla da mümkün olabilir.

extension Int {
   subscript(var multtable: Int) -> Int {
      var no1 = 1
      while multtable > 0 {
         no1 *= 10
         --multtable
      }
      return (self / no1) % 10
   }
}

print(12[0])
print(7869[1])
print(786543[2])

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

2
6
5

İç içe Türler

Sınıf, yapı ve numaralandırma örnekleri için iç içe geçmiş türler de uzantıların yardımıyla genişletilebilir.

extension Int {
   enum calc {
      case add
      case sub
      case mult
      case div
      case anything
   }
   var print: calc {
      switch self {
         case 0:
            return .add
         case 1:
            return .sub
         case 2:
            return .mult
         case 3:
            return .div
         default:
            return .anything
      }
   }
}

func result(numb: [Int]) {
   for i in numb {
      switch i.print {
         case .add:
            print(" 10 ")
         case .sub:
            print(" 20 ")
         case .mult:
            print(" 30 ")
         case .div:
            print(" 40 ")
         default:
            print(" 50 ")
      }
   }
}
result(numb: [0, 1, 2, 3, 4, 7])

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Protokoller, Yöntemler, özellikler ve diğer gereksinim işlevselliği için bir şablon sağlar. Uygulama yerine sadece bir yöntemler veya özellikler iskeleti olarak tanımlanır. Yöntemler ve özelliklerin uygulanması, sınıfları, işlevleri ve numaralandırmaları tanımlayarak daha da yapılabilir. Bir protokolün uygunluğu, protokolün gereksinimlerini karşılayan yöntemler veya özellikler olarak tanımlanır.

Sözdizimi

Protokoller ayrıca sınıflar, yapılar ve numaralandırmalarla benzer sözdizimini izler -

protocol SomeProtocol {
   // protocol definition 
}

Protokoller, sınıf, yapı veya numaralandırma türü adlarından sonra bildirilir. Tekli ve Çoklu protokol bildirimleri de mümkündür. Birden fazla protokol tanımlanmışsa, bunların virgülle ayrılması gerekir.

struct SomeStructure: Protocol1, Protocol2 {
   // structure definition 
}

Süper sınıf için bir protokol tanımlanması gerektiğinde, protokol adı süper sınıf adını virgülle takip etmelidir.

class SomeClass: SomeSuperclass, Protocol1, Protocol2 {
   // class definition 
}

Özellik ve Yöntem Gereksinimleri

Protokol, belirli sınıf türü özelliğini veya örnek özelliğini belirtmek için kullanılır. Depolanmış veya hesaplanmış bir özellik olup olmadığını belirtmek yerine yalnızca türü veya örnek özelliğini belirtir. Ayrıca, özelliğin "elde edilebilir" mi yoksa "ayarlanabilir" mi olduğunu belirtmek için kullanılır.

Özellik gereksinimleri, özellik değişkenleri olarak 'var' anahtar sözcüğü ile bildirilir. {get set}, tür bildiriminden sonra elde edilebilir ve ayarlanabilir özellikleri bildirmek için kullanılır. Getirilebilir, tür bildiriminden sonra {get} özelliği ile belirtilir.

protocol classa {
   var marks: Int { get set }
   var result: Bool { get }
   
   func attendance() -> String
   func markssecured() -> String
}

protocol classb: classa {
   var present: Bool { get set }
   var subject: String { get set }
   var stname: String { get set }
}

class classc: classb {
   var marks = 96
   let result = true
   var present = false
   var subject = "Swift 4 Protocols"
   var stname = "Protocols"

   func attendance() -> String {
      return "The \(stname) has secured 99% attendance"
   }
   func markssecured() -> String {
      return "\(stname) has scored \(marks)"
   }
}

let studdet = classc()
studdet.stname = "Swift 4"
studdet.marks = 98
studdet.markssecured()

print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

98
true
false
Swift 4 Protocols
Swift 4

Değişen Yöntem Gereksinimleri

protocol daysofaweek {
   mutating func print()
}

enum days: daysofaweek {
   case sun, mon, tue, wed, thurs, fri, sat 
   mutating func print() {
      switch self {
         case sun:
            self = sun
            print("Sunday")
         case mon:
            self = mon
            print("Monday")
         case tue:
            self = tue
            print("Tuesday")
         case wed:
            self = wed
            print("Wednesday")
         case mon:
            self = thurs
            print("Thursday")
         case tue:
            self = fri
            print("Friday")
         case sat:
            self = sat
            print("Saturday")
         default:
            print("NO Such Day")
      }
   }
}

var res = days.wed
res.print()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Wednesday

Başlatıcı Gereksinimleri

Swing, kullanıcının protokolleri normal başlatıcılara benzer tip uyumluluğunu takip etmesini sağlar.

Sözdizimi

protocol SomeProtocol {
   init(someParameter: Int)
}

Örneğin

protocol tcpprotocol {
   init(aprot: Int)
}

Protokol Başlatıcı Gereksinimlerinin Sınıf Uygulamaları

Atanmış veya kullanışlı başlatıcı, kullanıcının, ayrılmış 'gerekli' anahtar kelimesi ile standardına uyması için bir protokolü başlatmasına izin verir.

class SomeClass: SomeProtocol {
   required init(someParameter: Int) {
      // initializer implementation statements
   }
}

protocol tcpprotocol {
   init(aprot: Int)
}

class tcpClass: tcpprotocol {
   required init(aprot: Int) {
   }
}

Protokol uygunluğu, 'gerekli' değiştirici tarafından açık veya miras alınan uygulama için tüm alt sınıflarda sağlanır.

Bir alt sınıf, süper sınıf başlatma gereksinimini geçersiz kıldığında, "geçersiz kılma" değiştirici anahtar sözcüğü ile belirtilir.

protocol tcpprotocol {
   init(no1: Int)
}

class mainClass {
   var no1: Int        // local storage
   init(no1: Int) {
      self.no1 = no1  // initialization
   }
}

class subClass: mainClass, tcpprotocol {
   var no2: Int
   init(no1: Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   // Requires only one parameter for convenient method
   required override convenience init(no1: Int) {
      self.init(no1:no1, no2:0)
   }
}

let res = mainClass(no1: 20)
let print = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

res is: 20
res is: 30
res is: 50

Tipler Olarak Protokoller

İşlevsellikleri bir protokolde uygulamak yerine işlevler, sınıflar, yöntemler vb. İçin türler olarak kullanılırlar.

Protokollere şu türlerde erişilebilir -

Parametre veya dönüş türü olarak işlev, yöntem veya başlatma
Sabit, değişken veya özellik
Öğe olarak diziler, sözlükler veya diğer kapsayıcılar

protocol Generator {
   typealias members
   func next() -> members?
}

var items = [10,20,30].generate()
while let x = items.next() {
   print(x)
}

for lists in map([1,2,3], {i in i*5}) {
   print(lists)
}

print([100,200,300])
print(map([1,2,3], {i in i*10}))

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

10
20
30
5
10
15
[100, 200, 300]
[10, 20, 30]

Bir Uzantı ile Protokol Uyumluluğu Ekleme

Mevcut tip, uzantılar kullanılarak yeni bir protokole uyarlanabilir ve uyumlu hale getirilebilir. Uzantılar yardımıyla mevcut tiplere yeni özellikler, yöntemler ve abonelikler eklenebilir.

protocol AgeClasificationProtocol {
   var age: Int { get }
   func agetype() -> String
}
class Person {
   let firstname: String
   let lastname: String
   var age: Int
   
   init(firstname: String, lastname: String) {
      self.firstname = firstname
      self.lastname = lastname
      self.age = 10
   }
}

extension Person : AgeClasificationProtocol {
   func fullname() -> String {
      var c: String
      c = firstname + " " + lastname
      return c
   }
   func agetype() -> String {
      switch age {
         case 0...2:
            return "Baby"
         case 2...12:
            return "Child"
         case 13...19:
            return "Teenager"
         case let x where x > 65:
            return "Elderly"
         default:
            return "Normal"
      }
   }
}

Protokol Kalıtımı

Swift 4, protokollerin özellikleri tanımlı özelliklerinden devralmasına izin verir. Sınıf kalıtımına benzer, ancak virgülle ayrılmış birden fazla miras alınan protokolü listeleme seçeneğiyle.

protocol classa {
   var no1: Int { get set }
   func calc(sum: Int)
}
protocol result {
   func print(target: classa)
}
class student2: result {
   func print(target: classa) {
      target.calc(sum: 1)
   }
}
class classb: result {
   func print(target: classa) {
      target.calc(sum: 5)
   }
}

class student: classa {
   var no1: Int = 10
   
   func calc(sum: Int) {
      no1 -= sum
      print("Student attempted \(sum) times to pass")
         
      if no1 <= 0 {
         print("Student is absent for exam")
      }
   }
}

class Player {
   var stmark: result!

   init(stmark: result) {
      self.stmark = stmark
   }
   func print(target: classa) {
      stmark.print(target: target)
   }
}

var marks = Player(stmark: student2())
var marksec = student()

marks.print(target: marksec)
marks.print(target: marksec)
marks.print(target: marksec)
marks.stmark = classb()
marks.print(target: marksec)
marks.print(target: marksec)
marks.print(target: marksec)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 5 times to pass
Student attempted 5 times to pass
Student is absent for exam
Student attempted 5 times to pass
Student is absent for exam

Yalnızca Sınıf Protokoller

Protokoller tanımlandığında ve kullanıcı sınıflarla protokol tanımlamak istediğinde, önce sınıfı ve ardından protokolün miras listesini tanımlayarak eklenmelidir.

protocol tcpprotocol {
   init(no1: Int)
}
class mainClass {
   var no1: Int        // local storage
   init(no1: Int) {
      self.no1 = no1  // initialization
   }
}
class subClass: mainClass, tcpprotocol {
   var no2: Int
   init(no1: Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   
   // Requires only one parameter for convenient method
   required override convenience init(no1: Int) {
      self.init(no1:no1, no2:0)
   }
}

let res = mainClass(no1: 20)
let print = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

res is: 20
res is: 30
res is: 50

Protokol Bileşimi

Swift 4, protokol oluşturma yardımıyla birden fazla protokolün aynı anda çağrılmasına izin verir.

Sözdizimi

protocol<SomeProtocol, AnotherProtocol>

Misal

protocol stname {
   var name: String { get }
}
protocol stage {
   var age: Int { get }
}
struct Person: stname, stage {
   var name: String
   var age: Int
}
func print(celebrator: stname & stage) {
   print("\(celebrator.name) is \(celebrator.age) years old")
}
let studname = Person(name: "Priya", age: 21)
print(studname)

let stud = Person(name: "Rehan", age: 29)
print(stud)

let student = Person(name: "Roshan", age: 19)
print(student)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Person(name: "Priya", age: 21)
Person(name: "Rehan", age: 29)
Person(name: "Roshan", age: 19)

Protokol Uygunluğunun Kontrol Edilmesi

Protokol uygunluğu, tür çevrimine benzer 'eşittir' ve 'as' operatörleri tarafından test edilir.

Bir örnek protokol standardına uyuyorsa is operatörü true, başarısız olursa false döndürür.
as? downcast operatörünün sürümü, protokolün türünün isteğe bağlı bir değerini döndürür ve örnek bu protokole uymuyorsa bu değer sıfırdır.
Downcast operatörünün as versiyonu, downcast'i protokol tipine zorlar ve downcast başarılı olmazsa bir çalışma zamanı hatasını tetikler.

import Foundation

@objc protocol rectangle {
   var area: Double { get }
}
@objc class Circle: rectangle {
   let pi = 3.1415927
   var radius: Double
   var area: Double { return pi * radius * radius }
   init(radius: Double) { self.radius = radius }
}
@objc class result: rectangle {
   var area: Double
   init(area: Double) { self.area = area }
}
class sides {
   var rectsides: Int
   init(rectsides: Int) { self.rectsides = rectsides }
}
let objects: [AnyObject] = [Circle(radius: 2.0),result(area:198),sides(rectsides: 4)]

for object in objects {
   if let objectWithArea = object as? rectangle {
      print("Area is \(objectWithArea.area)")
   } else {
      print("Rectangle area is not defined")
   }
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Area is 12.5663708
Area is 198.0
Rectangle area is not defined

Swift 4 dili, esnek ve yeniden kullanılabilir işlevler ve türler yazmak için 'Genel' özellikler sağlar. Yinelemeyi önlemek ve soyutlamayı sağlamak için jenerikler kullanılır. Swift 4 standart kitaplıkları jenerik kod ile oluşturulmuştur. Swift 4'ün 'Dizileri' ve 'Sözlük' türleri genel koleksiyonlara aittir. Diziler ve sözlükler yardımıyla, diziler 'Int' değerlerini ve 'String' değerlerini veya diğer türleri tutacak şekilde tanımlanır.

func exchange(a: inout Int, b: inout Int) {
   let temp = a
   a = b
   b = temp
}

var numb1 = 100
var numb2 = 200

print("Before Swapping values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping values are: \(numb1) and \(numb2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Before Swapping values are: 100 and 200
After Swapping values are: 200 and 100

Genel İşlevler: Tür Parametreleri

Genel işlevler, 'Int' veya 'String' gibi herhangi bir veri türüne erişmek için kullanılabilir.

func exchange<T>(a: inout T, b: inout T) {
   let temp = a
   a = b
   b = temp
}
var numb1 = 100
var numb2 = 200

print("Before Swapping Int values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping Int values are: \(numb1) and \(numb2)")

var str1 = "Generics"
var str2 = "Functions"

print("Before Swapping String values are: \(str1) and \(str2)")
exchange(a: &str1, b: &str2)
print("After Swapping String values are: \(str1) and \(str2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

İşlev değişimi (), yukarıdaki programda açıklanan değerleri takas etmek için kullanılır ve <T>, bir tür parametresi olarak kullanılır. İlk kez, 'Int' değerlerini döndürmek için exchange () işlevi çağrılır ve exchange () işlevine yapılan ikinci çağrı, 'String' değerlerini döndürür. Köşeli parantezlerin içine virgülle ayrılmış birden çok parametre türü dahil edilebilir.

Tür parametreleri, tuttuğu tür parametresinin amacını bilmek için kullanıcı tanımlı olarak adlandırılır. Swift 4, genel tür parametre adı olarak <T> sağlar. Bununla birlikte, Diziler ve Sözlükler gibi tür parametreleri, 'Sözlük' türüne ait olduklarını belirlemek için anahtar, değer olarak da adlandırılabilir.

struct TOS<T> {
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
}

var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)

let deletetos = tos.pop()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Type Parameters]
[Swift 4, Generics, Type Parameters, Naming Type Parameters]

Genel Bir Türün Genişletilmesi

Yığın özelliğini, öğenin üstünü bilmek için genişletmek, 'uzantı' anahtar kelimesine dahildir.

struct TOS<T> {
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
}
var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)

extension TOS {
   var first: T? {
      return items.isEmpty ? nil : items[items.count - 1]
   }
}
if let first = tos.first {
   print("The top item on the stack is \(first).")
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

["Swift 4"]
["Swift 4", "Generics"]
["Swift 4", "Generics", "Type Parameters"]
["Swift 4", "Generics", "Type Parameters", "Naming Type Parameters"]
The top item on the stack is Naming Type Parameters.

Tür Kısıtlamaları

Swift 4 dili, 'tür kısıtlamalarının' tür parametresinin belirli bir sınıftan miras alıp almayacağını belirtmesine veya protokol uygunluk standardını sağlamasına izin verir.

func exchange<T>(a: inout T, b: inout T) {
   let temp = a
   a = b
   b = temp
}
var numb1 = 100
var numb2 = 200

print("Before Swapping Int values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping Int values are: \(numb1) and \(numb2)")

var str1 = "Generics"
var str2 = "Functions"

print("Before Swapping String values are: \(str1) and \(str2)")
exchange(a: &str1, b: &str2)
print("After Swapping String values are: \(str1) and \(str2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

İlişkili Tipler

Swift 4, ilişkili türlerin protokol tanımı içinde 'ilişkili tür' anahtar sözcüğü ile bildirilmesine izin verir.

protocol Container {
   associatedtype ItemType
   mutating func append(item: ItemType)
   var count: Int { get }
   subscript(i: Int) -> ItemType { get }
}
struct TOS<T>: Container {
   // original Stack<T> implementation
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
   
   // conformance to the Container protocol
   mutating func append(item: T) {
      self.push(item: item)
   }
   var count: Int {
      return items.count
   }
   subscript(i: Int) -> T {
      return items[i]
   }
}
var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Type Parameters]
[Swift 4, Generics, Type Parameters, Naming Type Parameters]

Cümleler nerede

Tür kısıtlamaları, kullanıcının genel bir işlev veya türle ilişkili tür parametreleri ile ilgili gereksinimleri tanımlamasını sağlar. İlişkili türler için gereksinimleri tanımlamak için 'where' cümleleri tür parametre listesinin bir parçası olarak bildirilir. 'where' anahtar sözcüğü, tür parametreleri listesinin hemen sonrasına yerleştirilir ve ardından ilişkili türlerin kısıtlamaları, türler arasındaki eşitlik ilişkileri ve ilişkili türler.

protocol Container {
   associatedtype ItemType
   mutating func append(item: ItemType)
   var count: Int { get }
   subscript(i: Int) -> ItemType { get }
}
struct Stack<T>: Container {
   // original Stack<T> implementation
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }

   // conformance to the Container protocol
   mutating func append(item: T) {
      self.push(item: item)
   }
   var count: Int {
      return items.count
   }
   subscript(i: Int) -> T {
      return items[i]
   }
}
func allItemsMatch<
C1: Container, C2: Container
where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
(someContainer: C1, anotherContainer: C2) -> Bool {
   // check that both containers contain the same number of items
   if someContainer.count != anotherContainer.count {
      return false
   }
   
   // check each pair of items to see if they are equivalent
   for i in 0..<someContainer.count {
      if someContainer[i] != anotherContainer[i] {
         return false
      }
   }
   // all items match, so return true
   return true
}  
var tos = Stack<String>()

tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Where Clause")
print(tos.items)

var eos = ["Swift 4", "Generics", "Where Clause"]
print(eos)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Where Clause]
[Swift 4, Generics, Where Clause]

Kod bloklarına erişimi kısıtlamak için modüller ve soyutlama erişim kontrolü ile yapılır. Sınıflar, yapılar ve numaralandırmalar özelliklerine, yöntemlerine, başlatıcılarına ve aboneliklerine göre erişim kontrol mekanizmaları ile erişilebilir. Bir protokoldeki sabitler, değişkenler ve işlevler sınırlandırılmıştır ve erişim kontrolü aracılığıyla genel ve yerel erişime izin verilir. Özelliklere, türlere ve işlevlere uygulanan erişim kontrolü 'varlıklar' olarak adlandırılabilir.

Erişim kontrol modeli, modüllere ve kaynak dosyalara dayanmaktadır.

Modül, tek bir kod dağıtım birimi olarak tanımlanır ve 'içe aktar' anahtar sözcüğü kullanılarak içe aktarılabilir. Bir kaynak dosyası, birden çok türe ve işleve erişmek için bir modülde bulunan tek bir kaynak kod dosyası olarak tanımlanır.

Swift 4 dili tarafından üç farklı erişim seviyesi sağlanmaktadır. Bunlar Genel, Dahili ve Özel erişimdir.

S.No	Erişim Düzeyleri ve Tanım
1	Public Varlıkların, tanımlayıcı modülü içe aktaran başka bir modülden bir kaynak dosya olan kendi tanımlama modüllerinden herhangi bir kaynak dosyada işlenmesini sağlar.
2	Internal Varlıkların kendi tanımlama modüllerinden herhangi bir kaynak dosyada kullanılmasını sağlar, ancak bu modülün dışındaki herhangi bir kaynak dosyada kullanılamaz.
3	Private Bir varlığın kullanımını kendi tanımlayıcı kaynak dosyasıyla sınırlar. Özel erişim, belirli bir kod işlevinin uygulama ayrıntılarını gizlemede rol oynar.

Sözdizimi

public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}

public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}

İşlev türleri için Erişim Kontrolü

Bazı işlevler, işlev içinde herhangi bir dönüş değeri olmadan bildirilmiş bağımsız değişkenlere sahip olabilir. Aşağıdaki program a ve b'yi sum () işlevinin argümanları olarak bildirir. Fonksiyonun içinde, a ve b argümanlarının değerleri, fonksiyon çağrısı sum () çağrılarak geçirilir ve değerleri yazdırılır, böylece dönüş değerleri ortadan kaldırılır. İşlevin dönüş türünü özel yapmak için, işlevin genel erişim düzeyini özel değiştiriciyle bildirin.

private func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

30 20
50 40
30 24

Numaralandırma türleri için Erişim Denetimi

public enum Student {
   case Name(String)
   case Mark(Int,Int,Int)
}
var studDetails = Student.Name("Swift 4")
var studMarks = Student.Mark(98,97,95)

switch studMarks {
   case .Name(let studName):
      print("Student name is: \(studName).")
   case .Mark(let Mark1, let Mark2, let Mark3):
      print("Student Marks are: \(Mark1),\(Mark2),\(Mark3).")
   
}

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Student Marks are: 98,97,95

Swift 4 dilinde numaralandırma, bir numaralandırmanın bireysel durumları için otomatik olarak aynı erişim düzeyini alır. Örneğin, öğrencilerin adı ve üç konuda güvence altına alınan işaretlere erişmeyi düşünün, numaralandırma adı öğrenci olarak bildirilir ve enum sınıfında bulunan üyeler, dize veri türüne ait adlardır, işaretler veri türü Tamsayı'nın mark1, mark2 ve mark3 olarak temsil edilir. Öğrenci adına veya puan verdikleri notlara erişmek için. Şimdi, anahtar durumu, bu vaka bloğu yürütülürse öğrenci adını yazdıracak, aksi takdirde öğrenci tarafından güvence altına alınan işaretleri yazdıracaktır. Her iki koşul da başarısız olursa, varsayılan blok yürütülür.

Alt Sınıflar için Erişim Kontrolü

Swift 4, kullanıcının mevcut erişim bağlamında erişilebilen herhangi bir sınıfı alt sınıflamasına izin verir. Bir alt sınıf, üst sınıfından daha yüksek bir erişim düzeyine sahip olamaz. Kullanıcının dahili bir üst sınıfın genel bir alt sınıfını yazması kısıtlanmıştır.

public class cricket {
   internal func printIt() {
      print("Welcome to Swift 4 Super Class")
   }
}

internal class tennis: cricket {
   override internal func printIt() {
      print("Welcome to Swift 4 Sub Class")
   }
}

let cricinstance = cricket()
cricinstance.printIt()

let tennisinstance = tennis()
tennisinstance.printIt()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Welcome to Swift Super Class
Welcome to Swift Sub Class

Sabitler, değişkenler, özellikler ve alt simgeler için Erişim Kontrolü

Swift 4 sabiti, değişkeni veya özelliği, türünden daha genel olarak tanımlanamaz. Özel tipte bir kamu mülkü yazmak geçerli değildir. Benzer şekilde, bir alt simge, dizininden veya dönüş türünden daha genel olamaz.

Bir sabit, değişken, özellik veya alt simge özel bir tür kullandığında, sabit, değişken, özellik veya alt simge de özel olarak işaretlenmelidir -

private var privateInstance = SomePrivateClass()

Getters ve Setters

Sabitler, değişkenler, özellikler ve abonelikler için oluşturucular ve ayarlayıcılar, ait oldukları sabit, değişken, özellik veya alt simge ile otomatik olarak aynı erişim düzeyini alır.

class Samplepgm {
   var counter: Int = 0{
      willSet(newTotal) {
         print("Total Counter is: \(newTotal)")
      }
      didSet {
         if counter > oldValue {
            print("Newly Added Counter \(counter - oldValue)")
         }
      }
   }
}

let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

Başlatıcılar ve Varsayılan Başlatıcılar için Erişim Kontrolü

Özel başlatıcılara, başlattıkları türden daha düşük veya buna eşit bir erişim düzeyi atanabilir. Gerekli bir başlatıcı, ait olduğu sınıfla aynı erişim düzeyine sahip olmalıdır. Bir başlatıcının parametrelerinin türleri, başlatıcının kendi erişim düzeyinden daha özel olamaz.

Başlatma 'gerekli' anahtar sözcüğünün her bir alt sınıfını bildirmek için init () işlevinden önce tanımlanması gerekir.

class classA {
   required init() {
      let a = 10
      print(a)
   }
}
class classB: classA {
   required init() {
      let b = 30
      print(b)
   }
}
let res = classA()
let print = classB()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

10
30
10

Varsayılan bir başlatıcı, bu tür genel olarak tanımlanmadıkça, başlattığı türle aynı erişim düzeyine sahiptir. Varsayılan başlatma genel olarak tanımlandığında dahili olarak kabul edilir. Kullanıcının başka bir modülde argümansız başlatıcı ile başlatılabilir olması için genel bir türe ihtiyacı olduğunda, türün tanımının bir parçası olarak açıkça bir genel argümansız başlatıcı sağlayın.

Protokoller için Erişim Kontrolü

Var olan bir protokolden işlevleri miras almak için yeni bir protokol tanımladığımızda, her ikisinin de birbirinin özelliklerini devralması için aynı erişim düzeylerini bildirmesi gerekir. Swift 4 erişim kontrolü, kullanıcıların 'dahili' bir protokolden miras alan 'genel' bir protokol tanımlamasına izin vermez.

public protocol tcpprotocol {
   init(no1: Int)
}
public class mainClass {
   var no1: Int      // local storage
   init(no1: Int) {
      self.no1 = no1 // initialization
   }
}
class subClass: mainClass, tcpprotocol {
   var no2: Int
   init(no1: Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   
   // Requires only one parameter for convenient method
   required override convenience init(no1: Int) {
      self.init(no1:no1, no2:0)
   }
}

let res = mainClass(no1: 20)
let print = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

res is: 20
res is: 30
res is: 50

Uzantılar için Erişim Kontrolü

Swift 4, kullanıcı bu uzantıyı protokol uygunluğu eklemek için kullandığında, kullanıcıların bir uzantı için açık bir erişim seviyesi değiştiricisi sağlamasına izin vermez. Uzantı içindeki her protokol gereksinimi uygulaması için varsayılan erişim düzeyi, kendi protokol erişim düzeyiyle sağlanır.

Jenerikler için Erişim Kontrolü

Jenerikler, kullanıcının tip parametrelerindeki tip kısıtlamalarına erişmek için minimum erişim seviyelerini belirlemesine izin verir.

public struct TOS<T> {
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
}

var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)
let deletetos = tos.pop()

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Type Parameters]
[Swift 4, Generics, Type Parameters, Naming Type Parameters]

Tür Takma Adları için Erişim Denetimi

Kullanıcı, farklı erişim denetimi türlerini ele almak için tür takma adları tanımlayabilir. Aynı erişim seviyesi veya farklı erişim seviyeleri kullanıcı tarafından tanımlanabilir. Tür takma adı 'özel' olduğunda, ilişkili üyeleri 'özel, genel türden dahili' olarak ilan edilebilir. Tür takma adı genel olduğunda, üyeler 'dahili' veya 'özel' ad olarak takma ad olamaz

Tanımladığınız tüm tür diğer adları, erişim kontrolü amacıyla farklı türler olarak değerlendirilir. Bir tür takma adının, takma adını verdiği türün erişim düzeyinden daha düşük veya ona eşit bir erişim düzeyi olabilir. Örneğin, özel tür bir diğer ad, özel, dahili veya genel bir türe takma ad verebilir, ancak genel tür bir diğer ad, dahili veya özel bir türe diğer ad veremez.

public protocol Container {
   associatedtype ItemType
   mutating func append(item: ItemType)
   var count: Int { get }
   subscript(i: Int) -> ItemType { get }
}
struct Stack<T>: Container {
   // original Stack<T> implementation
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
   
   // conformance to the Container protocol
   mutating func append(item: T) {
      self.push(item: item)
   }
   var count: Int {
      return items.count
   }
   subscript(i: Int) -> T {
      return items[i]
   }
}
func allItemsMatch<
   C1: Container, C2: Container
   where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
   (someContainer: C1, anotherContainer: C2) -> Bool {
   
   // check that both containers contain the same number of items
   if someContainer.count != anotherContainer.count {
      return false
   }
   
   // check each pair of items to see if they are equivalent
   for i in 0..<someContainer.count {
      if someContainer[i] != anotherContainer[i] {
         return false
      }
   }
   // all items match, so return true
   return true
}
var tos = Stack<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Where Clause")
print(tos.items)

var eos = ["Swift 4", "Generics", "Where Clause"]
print(eos)

Yukarıdaki programı oyun alanını kullanarak çalıştırdığımızda, aşağıdaki sonucu elde ederiz -

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Where Clause]
[Swift 4, Generics, Where Clause]

Hızlı Kodlama ve Kod Çözme

Swift 4 yeni bir Codable Herhangi bir özel kod yazmadan ve değer türlerinizi kaybetme konusunda endişelenmenize gerek kalmadan, özel veri türlerini serileştirmenize ve serileştirmenize olanak tanıyan protokol.

struct Language: Codable {
   var name: String
   var version: Int
}
let swift = Language(name: "Swift", version: 4)
let java = Language(name: "java", version: 8)
let R = Language(name: "R", version: 3

Langauage'ın Kodlanabilir Protokol ile uyumlu olduğuna dikkat edin. Şimdi bunu basit bir satır kullanarak Json Veri Temsilcisine dönüştüreceğiz.

let encoder = JSONEncoder()
if let encoded = try? encoder.encode(java) {
   //Perform some operations on this value.
}

Swift, veri türünüzdeki tüm değerleri otomatik olarak kodlayacaktır.

Aşağıdaki gibi Dekoder işlevini kullanarak verilerin kodunu çözebilirsiniz:

let decoder = JSONDecoder()
if let decoded = try? decoder.decode(Language.self, from: encoded) {
   //Perform some operations on this value.
}

Hem JSONEncoder hem de onun özellik listesi muadili PropertyListEncoder, nasıl çalıştıklarını özelleştirmek için birçok seçeneğe sahiptir.