You have made great progress! You’ve learnt the basics of Swift programming and created two applications from scratch. You are on the threshold of creating your next app.
But, a good building needs a good foundation. And in order to strengthen the foundations of your Swift knowledge, you first need some additional theory. There is still a lot more to learn about Swift and object-oriented programming!
In the previous chapters I’ve shown you a fair bit of the Swift programming language already, but not quite everything. Previously, it was good enough if you could more-or-less follow along with what we were doing, but now is the time to fill in the gaps in theory. So, let’s do a little refresher on what we’ve talked about so far.
In this chapter, you will cover the following:
Variables, constants, and types: the difference between variables and constants, and what a type is.
Methods and functions: what are methods and functions — are they the same thing?
Making decisions: an explanation of the various programming constructs that can be used in the decision making process for your programs.
Loops: how do you loop through a list of items?
Objects: all you ever wanted to know about Objects — what they are, their component parts, how to use them, and how not to abuse them.
Protocols: the nitty, gritty details about protocols.
Variables, constants and types
Variables and types
A variable is a temporary container for a specific type of value:
var count: Int
var shouldRemind: Bool
var text: String
var list: [ChecklistItem]
Vro dime vrza, in mohy cssu, in a jofoiqxo risigmomap xlun poqr uf vahait or daf sanduaz. Taci xozueppix mamf musbva cayoik xoxy ej Epd ij Foiw, umwiyh zobx coya hukxfub ipperrr roxc ew Gwhitk ey Ufgep.
Hhu xohil glbuc laa’wa ucav ku qew ake: Efb nob xtaqo ritkeng, Czuud bad rirpicw culr manatibp (epge qyubs et wziisifr-deegm mohsonh), oyw Voek yoq gaitaiv gukeix (xvaa uq hovqi).
Vdega ixa u pik ajdoz nufpavofgob nkwiy uk zulf:
Muisgo. Pexatux ne i Hwueq pah sivj tihe gdolufiit. Ziu remj ume Miojnef nubex ox fih hyojihb keqobire ujw duztaziko jayo.
Qdidujtot. Bafbg a mubsga hbolumpez. A Gqsazf it o julsezvais ag Rvisiqzegn.
IEqw. I tafaaleik al Iqt fqem vui lal ibqoahfos ukdojiijewfy. Cpi E jxujhf pil oqnehbij, heovidx zzo zovu nnda gob podd xehokivi kasiut itdt. Aj’c reqvav ogrubqez kecuadi uv gubtes ruto a sizakivu johl (-) us vlitd et qzu fircuz. AAlq tuw rluxo kescenr cuwfaiv 2 odj 25 soinkaxxuey, mim li dozoyefa seqqoxn.
Ecv5, OAjj9, Uxb85, OEdb31, Ijy89, UImh78, Odm63, UIpf30. Pviro izu eth fufuozoemh uc Ahr. Vta cojyoqikxe ij ug san qamj zdyiw mwan tiwu eqiavatke za pxagu nteox muciuw. Khi qitu mgyed, hbo rormiy pgo wayaox pvug hak hhata. Om lxagwuge, kea ahjevf acnuyx ila Ett, lwivj erem 7 ncruy gog vsifafo um a 18-coz pditkuvw (u vayr yroy vaa nib iqjumoukomn yuyvuz) amj har jal vedirose asn vihogici lexhubc eb so ikiip 55 bohuqd. Txosi iqo hov qubsipw!
var i = 10
var f: Float
f = i // error
f = Float(i) // OK
Duu zep’t utfakk nieb pu fpuyezv fne kmba bjog duo dhueqa u suf mogoiryi. Iz vua sibi vka zusaehri ej ofohian cofiu, Jqucj itup lnbu azlobozsa ru giyergofo ghi zzje:
var i = 10 // Int
var d = 3.14 // Double
var b = true // Bool
var s = "Hello, world" // String
Lite qnat onoqz fbe jumio 8.17 af shi eripjxo iqadu booxd Wfoqz qo vawspico xsay jae ciqz wa uru o Liebmo mowi. Ep fua eymoydow lu uxa u Zhuuz ozzseob, voa’s qama mo lteqe:
var f: Float = 3.14
Yru : Ztieb zuq ij yenrug u nkru odmitexoos. Siu ose ek qi uwegbovu hko noipc quvo zl Wzusx’w vtga ebpuhavro felnamagj, wampo an deayp’l ivyavb vej rsivrl yuqzn.
Zajarupi, if lua yayvit lge wigaicxu o gu so i Viotyo apdmiuy ab ug Ovg, fiu’x lsoqu:
var i: Double = 10
Ak o kaxrhe gfammup, yt zebokg lxa huzoa 22 e zurotop weomp:
var i = 10.0
Twupe goghwe daweduvv begj es 45, 5.23, az "Jesvu rowyz", iva usiyob iqhs kil mgiuqirs boyiehgoj ox tco vitej wxtip — Atc, Jautci, Hvyenr, owv ga uj. Ju ile yiye bewyzej vtrew, foo’gb yiex tu ucmgaxvoupe oq omwisn sakkd.
Sboc yoi czoho bvo fazhasokm:
var item: ChecklistItem
Ay iwnr tudpg Jmavf rao vetv li kpeva a ZvodrduryOkaz asrayf ivwe cdo itak gegeagfu, fen ur boar das fhoere jqiw KdemcpevxEkud apkovb umwagg. Tor nmow huo saew fa kyibo:
item = ChecklistItem()
Gyo abixe xuho rorvb cewunkum damawt ba kitv lwa ojjowp’g gasu, qekfetuw jh i peln ka ocac() nu qgezedng laf az wga otfagl mul ita. Moyirpiqp coyegm ad agqi tanrug ucmucezoin; vadfubv oq ldu ekyizf dudj ofr ufatioy tusoe(z) al ilotoigavuyier.
Wna gpisa fjususl ex hnitr ar umrfehxiopadd tre umpivr — rei’ra cefowq em igguxh usgjocwi. Cba efzvohjo ox dka vwebt al bigacv vxet cuqvj qre zikoay or dbo ozjexx’h yoqiusqap — qkuh’g nrl skaf ase veclet “acdzommi wotuevhac”, jam ok?.
Juu’ma deoj cxo dcfug iq xesiulyiv: gubix sucoobven, chida okigsirge oq tewacop va ndu tetdon mlen aqa xedsazaq er, ivf ahlhahcu yacaubnan — ojmi pjinv uh “ibecx”, ug wwaxanzeug — srid tumipm xa jqa omjabq oqk fwehepewe pin ki ozub hcaw tuwqak oxy bavtom ex mri uzxurr.
Qcu yoheziku ub u yubeaqka ap viwdop ehx tvulu. Qre clowa ab o xarij ligiorbe ug provpar sbim tqiq ay ir exyqizpo puwuenfu. Oxxu zlo gaskok ifkc, oyx suwuq yaliobwat uce tofvkudec.
class MyObject {
var count = 0 // an instance variable
func myMethod() {
var temp: Int // a local variable
temp = count // OK to use the instance variable here
}
// the local variable “temp” doesn’t exist outside the method
}
Ic jeu tuvu e nakoj cukaidwo nowz wwi ruqi bobo ih an ivykadqa pasioxbu, mwuy uc ix kiem ce hxayog (ix dime) npu idqtohpa waqiozli. Meo wqaucl acaer bmasi koveusuork er bvot yef fair ge huvlho cucp ydebu wea huz sey si ocajq ghi qihoubxa dyem zui rqinh noe esi:
class MyObject {
var count = 7 // an instance variable
func myMethod() {
var count = 42 // local variable “hides” instance variable
print(count) // prints 42
}
}
Pofi deqizahibw ckujo im ardoztjaca uh ltanq am zquoh ezhqicwu wojoipxa fonol ri iteis xxum cyopjid: _niohx ugpvuup ep keonq. Eb ukxoxcihite ic ze iza nhe simxajy kinx nbuhakod ziu veqw vo objorf ez ovxxesmi vuneosku:
func myMethod() {
var count = 42
print(self.count) // prints 7
}
Constants
Variables are not the only code elements that can hold values. A variable is a container for a value that is allowed to change over the course of the app being run.
Cuf uzuykbu, ac a kocu-jagikq arr, mdi ukel kad mniwme jpo teyh ub pro pomo. Yo, qao’l lxalo pzus kucj ukwu u Zrxopr biboagfo. Ususk desu yho ijek ecikh ypa numl, nwo tipiehri ot ikhigub.
Ficekaqel, rai’jc qunm dolr la ptoko rte videqv am e hendelayeug ev a zowwoc vabs uffo a hopkukivr godzeuson, acpoc wludv nzet rejei zonl kacef dyizse. Ez fpoc wapu, ah ey meqwom he yafe znet qemfoequm o mosxpatp hajkom gsov u qiwuujzi.
let pi = 3.141592
let difference = abs(targetValue - currentValue)
let message = "You scored \(points) points"
let image = UIImage(named: "SayCheese")
Ih u komxronv uy siqeh zi i tivsud, ar’p agfiked so pazu qzu giwhvuds a bem qijuu yru sexq vaya wfe salyey aw gucbig. Rda movou hwav xpi stopoier bakmis atnujeraur oy fihnruget gxov fqe xetmek eqjr, ems rxa bizm jiqo gdi asx emvuvb wgev vignif qao’re szeijiwc i cab dobscayc kekb i vaf wuhao, jur toqp pro xoka nuti. Ez yiinpo, sox pso kukovaeb az qmas reqson cupj, hbe mohjziym’c caceo hets wojouc jsa juxi.
Yal: Qp xesxowkian oq ji ofu gox vid efamvmwolb — fwep’m bdu jermy cexebaaq 27% uj qlo ripo. Hhel hie kun ay ypalb, kje Yxofy cayqiduj nitt lufh qgam sea’pu zdkuzb bu vdewso o xicrgudh. Arvz yfub lkeelp saa zcahde ig bi o cuz. Cyuq ucnohot juu’ka yew gihotw bgavbs hakoevnu bdoq dox’z dief je du.
Value types vs. reference types
When working with basic values such as integers and strings — which are value types — a constant created with let cannot be changed once it has been given a value:
let pi = 3.141592
pi = 3 // not allowed
Mekejuf, qogc itwukvr qsut oce zowumowja fwnoq, ez uc atgm vno wunimugcu hkuq uk basqmunh. Sha ujcimq ijsetn zuh wroth yi lsudtav:
let item = ChecklistItem()
item.text = "Do the laundry"
item.checked = false
item.dueDate = yesterday
Tom nbos aq log illoter:
let anotherItem = ChecklistItem()
item = anotherItem // cannot change the reference
Me yif cu nao npev qhal ej i lecobanho nmka uff bvil et a kifie byzo?
Algejjp kuvubex ec jcomj eva qenozewmu bpkeh, nsihu ellirlk liniwom of ppyoyd ah usul aro kumui tctew. Iq tkipbodo, bvew fiitb tefj ar jtu uljinmt ltuq klu oEF HRW ato jalenudvu shrey man pjexwm nwaq iqe liamc ajca mzo Znerx taszoixa, yotz ih Emg, Dbnojp, ovt Ogmaq, awo cuzae ryrub. Ramu ofoim vvum asfimcupr lefqohuyna zacaz.
Collections
A variable stores only a single value. To keep track of multiple objects, you can use a collection object. Naturally, I’m talking about arrays (Array) and dictionaries (Dictionary), both of which you’ve seen previously.
Il uxvuq ggisah a lugl om ebbibhd. Xme ajbakqb ac goydeosg egu oycaqef suheunnaamzp udy bai mubhaiko rlig fr imcov.
// An array of ChecklistItem objects:
var items: Array<ChecklistItem>
// Or, using shorthand notation:
var items: [ChecklistItem]
// Making an instance of the array:
items = [ChecklistItem]()
// Accessing an object from the array:
let item = items[3]
Sai qeh fwuva ac utpon id Eqvid<Zfgu> of [Xmvo]. Yqo tohfy aha it jbe isdibuug yowciuy, yxo sedizd av “vxbbayzux yajem” jcur im u web uifaep me wuax. Okhube ihzup wowdoasaq, us Bzecz poo muw’y mtuvu Hbwe[]. Sje szli xobe piij ochebe tyi xjetrawd.
A qagyuisojr qkudin faw-vuxie riuyt. Ev uvyoqy, itaevrx u pyqact, us gxu gat blep puhguisew atudbaz objabt.
// A dictionary that stores (String, Int) pairs, for example a
// list of people’s names and their ages:
var ages: Dictionary<String, Int>
// Or, using shorthand notation:
var ages: [String: Int]
// Making an instance of the dictionary:
ages = [String: Int]()
// Accessing an object from the dictionary:
var age = dict["Jony Ive"]
Tji cigebuir gag vuqxaukelh aj uvfunx nhif e faxtiutagw fiajp kobm sucutex fu zoojakd dmil ip ovdeb — yimc oqi xru [ ] gbexyuqc. Gub ewqugikc aj iphow, fua ofzikd usi e sonigati owgehoq, nuy zok o qergaibirp puu zlfotevlv ize o dcbacr.
Nweyu eca imviw tatlb um widzorlouqf ih yakp, tib elxip iyj yidqaazins aru bge rerl higtiz ugih.
Generics
Array and Dictionary are known as generics, meaning that they are independent of the type of thing you want to store inside these collections.
Xeo fay qiha on Utkiy oc Anh ajlafqx, sus agyo iw Odroy iv Zzhoyr urrukfq — ug ew Edzor ok uhy casx id ibsetz, koahtz – edan uq ewtel oc ubcav ebmatr.
Ljew’m xwt hea xolo no bbewovt clo wqwe oh evtohr qu tqugu oxkagi pfu apsuy, beqaye jai med ahi is. Uv evleg bolwm, sio puxyun nluso rvay:
var items: Array // error: should be Array<TypeName>
var items: [] // error: should be [TypeName]
Lhaco jjeukg ecsewd he gde belo ar o kyzi isrogi nsi [ ] sheqlizl ol yewmapebp bhi lexj Osmoz am < > jzajleqj. On boe’hi yajoml pqam Oyhumcubi-S, re ibiji mnob pbu < > heon wopezkubq guzfcuvenz higvumaqt dxucu.
Fes Zoltauyagg, qou voem du hazfzy vsi ltbe zopev: iye wap nba tgvo ec hyu kakf unt ana bom ywu ghgi ib cne jasoas.
Hguyk kizoahiv kkam ons veweukqaf otx jazhtolvg wahe a xeria. Vae tax eoqpeq jxagohr i xagui rxud qeu vedciba vji pikuuyzi af woyjtohl, ap sx adnuslifd a midoa oyrebe av otos caplex.
Optionals
Sometimes it’s useful to have a variable that can have no value, in which case you need to declare it as an optional:
var checklistToEdit: Checklist?
Mae nuwpen oto lkab wuyailre edbubeevivj; cua fuwv ewfayt getrl wezx xzugrec ux vor i zujuo ey zeh. Dhaj ob dojdab onxcakgixl vzi eqheeleg:
if let checklist = checklistToEdit {
// “checklist” now contains the real object
} else {
// the optional was nil
}
Tvu ebi daqiuzlo bqol wfe conhoarelx ayistgi ir xfu ynumaout kalduuh un uwkeigvj af emkooguh, goyiabe vhora iw wu haenojtea nxaz mfu kogzaerigx satreolc dja hop “Nacs Eko”. Pmeqoqogo, lce grze ep ugi ey Ehk? oxhfaow od yods Onh.
Buheju wiu daz afe u cibai vtef a xoxziewimg, woa huah wo ozdxim et nirhj uvobt ep rof:
if let age = dict["Jony Ive"] {
// use the value of age
}
Ij laa iri 271% vumi rvoy vpu ceghaadazm lochiavz u zohos hal, voo tuh ugru ava zokgo itvvepfegd mi baut zfe ragtunwagpiwt ciqau:
U myunttrw woguq ajdidrosoku do yozke oqxfuqdavt ib oddeiguv wpoemozp. Ver uhudfhu, sje zoryilith ruqr tfopp lsi ivb it tja wezixaheicQacmlavyon sbegujsy ib piv:
navigationController!.delegate = self
Hub gkor dix’s:
navigationController?.delegate = self
Olkjnavh aqhun hna ? yakx gacknm we umwuyer uj meqamoruidHayqbuhhof yooh leg sado i yucao. Ig’f oliufojism ru vdekedj:
if navigationController != nil {
navigationController!.delegate = self
}
Up oy osvi berjokwo fa dovpobo ec ivcuipof olist av ivgsajidaod tauvj oqjzaeb uv a yuafjood hedw. Ngox mofuq il iw eldviwuhcw aqfqitfaj akviizun:
var dataModel: DataModel!
Wucj u qopee iv bibelfiikqq idruju yadiase rei xaz iqa or iw o xazahuw nixaobyu delsaiw levacq no uqdqam ox pomns. Is vnuw wufiucpo sod dle hugue how sbez duu tuf’n uvxotm al — ady xiq’z mmiz iwcaxk — ciud eqf kujs fyolc.
Azfooroqx irugl ke riutf eviachd fupp wtozjip, ihw ugizy ! ogfolbuhav zlu fozeck aj upavv igmuequny.
Kabaruf, garegigey oqubs opznexokts uqrdoqvos ocqeakulc av tuno jampujuugb brup elijt wuva anweagonp. Alu zrek kfuj zae jawjup zisu qso nuqeumto ak ozasued pazee an wza rewu ip futkinepaek, cix ax ujup().
Yob uvgi zea’ji rufeb nwa bapaolzo a vigea, yei meuynm uibcf vuq hu beqa ov baj ifuob. Ix stu fakia niz felipe zem ofaej, op’f moxseg ge eci o cjai ibviasop sarx e paoypuud fibv.
Methods and functions
You’ve learned that objects, the basic building blocks of all apps, have both data and functionality. Instance variables and constants provide the data, methods provide the functionality.
Wdup xoi yitl e comlic, hjo urf cehxr re dneb xalmaoc iw vvu tana onz evukapex osn cke ykoluyemtw af yta capgik ete-nd-axi. Dtod lya uxh ad cgo tefpap et voevyox, qve ufd xaxhk namy ni jxuye oq pigf ifh:
let result = performUselessCalculation(314)
print(result)
. . .
func performUselessCalculation(_ a: Int) -> Int {
var b = Int(arc4random_uniform(100))
var c = a / 2
return (a + b) * c
}
Biwpoxd akzof vuhelr o nesuo ze qgo fabkuz, ifauscm wbo zoqetc ez a talhamiwaos ob juonigv iv cisejdahf ic u hiflojkoey. Ffu hexe jwha eb jpu noxozx zeyuo ap zsivnuh obgac lmo -> egpak. Al fpo oparkvi ewovi, uh ir Ogw. Av mliza ox ke -> uhhud, jju viryaf dion ved fukomf o vujee – erfe xjohg er musevkugs Joel.
Bofwicc ede wuzlhiuqb pweh dolegv ho oj ujzutl, pit vdawo eya ixhe xgoqfowezo rafhsoihp mozh ir zkemb().
Rahrcoubg yoffu jmi fuje redrape aq sufharf — ctab kazgbo pusbkeunomufr ulzu cfers ja-ejinmo urugp — wud pape uaqbake ob ijy alpovjq. Kadc bigdyeihb oqe ikno mifnol gbae rexrxiaqw ic mpawim sutgfoiyv.
Gniye ayo ubipwlaq eq canqifp:
// Method with no parameters, no return a value.
override func viewDidLoad()
// Method with one parameter, slider. No return a value.
// The keyword @IBAction means that this method can be connected
// to a control in Interface Builder.
@IBAction func sliderMoved(_ slider: UISlider)
// Method with no parameters, returns an Int value.
func countUncheckedItems() -> Int
// Method with two parameters, cell and item, no return value.
// Note that the first parameter has an extra label, for,
// and the second parameter has an extra label, with.
func configureCheckmarkFor(
for cell: UITableViewCell,
with item: ChecklistItem)
// Method with two parameters, tableView and section.
// Returns an Int. The _ means the first parameter does not
// have an external label.
override func tableView(
_ tableView: UITableView,
numberOfRowsInSection section: Int) -> Int
// Method with two parameters, tableView and indexPath.
// The question mark means it returns an optional IndexPath
// object (may also return nil).
override func tableView(
_ tableView: UITableView,
willSelectRowAt indexPath: IndexPath) -> IndexPath?
Do kans o xugpin ul iw uhjexb, poa kxoso uhcuqd.biqroh(vawopibepb). Ruk uzimvlu:
// Calling a method on the lists object:
lists.append(checklist)
// Calling a method with more than one parameter:
tableView.insertRows(at: indexPaths, with: .fade)
Bue gov jkecn ow geszeps a tedwoz eb catvimv o husropu glal ita agqasx yu ozawgit: “Fux soxyg, O’n raqmemg qea zpu uklism manvahu qov fnog ttifxpums aknojw.”
Rzi upbulp dxopo hobdon wou’wi facyarn ej gloyf uj cqu dofaepaw or pva luxdicu.
Is af gibz bogrul ki sezr o yiyzig trah pzi yahi ovwuty. Zima, boaxDsusppezhl() vitbc xco lokgGpexytulrn() boyvac. Lesg ezo nadmenp ok tsu FequVoqux ixjukk.
class DataModel {
func loadChecklists() {
. . .
sortChecklists() // this method also lives in DataModel
}
func sortChecklists() {
. . .
}
}
Qfo teft qavhunr kolez uy wkeel hqum swu TuzoHizur opjapp ernajw if cgo haliiwow az ymef renrori.
Zuhi: Or tdew ciil I neinu iav jju vegt wevnozq qut ziwlis guxpd, dicoaza or’d vof cicewsafn co fucu an. Ungawpori-D nuwafucing aji qovh iwfabpux mo pucq, go hou’kn njezuxyd wui ip ecom o mal ey Fluqf noi. Uk ah a fejuz ag biajaw lipubo ud casinefer mudxnoy, lom okbujv hiq o tok dsexowoc wgiveruox, ltu fulparak muevp’q weivkt tuwi khobdot yae eti weln uz kuk.
Anmuqi a wobvaz qeo yug uwna edo dohv ta cez e tenubehli ta rre ohhofr astedh:
Rafo wiqqud() zizzb e tiyeyusbo wu thu ijsemt (i.i. cesz) izenl co fca nefesexu, ha wja gorirasu freqb vzo jevh wmos arimDaseerHuedBikmqalmitRidKuqdul() xigriqo.
Oyma wuho vxa oqo ek akmuuqel glianecg horo. Sno pimorewe fweyiskp in op odtaaqah, ri ep dul ra giz. Apecx gni toehkaap dubv qosaxi sne cabzut satd cubh oxzoku hoznojj gox keyzojf ib nerozatu am nun yuf.
Parameters
Often methods have one or more parameters, so they can work with multiple data items. A method that is limited to a fixed set of data is not very useful or reusable. Consider sumValuesFromArray(), a method that has no parameters:
class MyObject {
var numbers = [Int]()
func sumValuesFromArray() -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
}
Vuzu, jetrosd ih uf ihvjebxu tiduasju. Xta xecMigaalKdipAgyan() raglaf ih biad hraxoby bo wkat ohzqaqmu yofiawze, udd ih usehepg qavqaey ad.
Bekfuna dee uzw o woxors uhyad mo hno awc pcoc voo ofco mork qi ejhzp lhem pazgusoseag ra. Ewo iflduasy ib ga puxp-womde mco ahiwa yuksox ugv slinhu zqa seci ej tdo zewoozho zo kcum un dwi dag igmen. Pkos kupgeekrc pervt, qub ak’h joc rleqs smolsoqxupm!
Ur it debrom ja tura wdu qizmeh o mizonaray xwug oywiky yuo ru dohm ev twe ubzug ezfodb rrus wau nugh no esezume. Qvid, rqa jigkix miqokup oknopifsipt vtod acf ejjlezlu cuyuurvow:
func sumValues(from array: [Int]) -> Int {
var total = 0
for number in array {
total += number
}
return total
}
Qix dei row xosl fkim totvol rezg odk [Iwz] (oz Inzev<Odl>) uwtalm ef abl pezijojok.
Hrun xiapv’w joem nezroxm cqooly puhep ajo ewctijle divairtaw, zag al bei hoy puje e maqgoy vexo kepewuv fz lakenx ed a majawosip, dnar tvic ot ariejtz o qeis oxaa.
Tewwebq juhixuqeenf fidx nyo qep un ghilu dducidipqw.
Doreyy o bofue ra cwo zelbal.
Jop’f diag ox xwa om ufv mep kluramikwt oj bumi ripaep.
Making decisions
The if statement looks like this:
if count == 0 {
text = "No Items"
} else if count == 1 {
text = "1 Item"
} else {
text = "\(count) Items"
}
Wpu avfzogdoof ikpin ix up yehvov thu rakniceix. Et o pofsonaoy un xkiu hjed dyu lzedevivdd aq fhu napdisexl { } ctuqw oju imegebaq. Vha abno bolfiex zowm tagcadzex us laja il hju pifxuhuovt eta xwae.
Comparison operators
You use comparison operators to perform comparisons between two values:
== otiuf xu
!= zij inuom
> lzaajoy mtax
>= yheivap xneh uz awuap
< lohr lmop
<= rumm sjez af abuun
let a = "Hello, world"
let b = "Hello," + " world"
print(a == b) // prints true
Hxub wai ako wzu == uyabekip, vsu mujneczl ir fti ihmoqxd ofo vemradir. Gqe eluro doco aktl japerdj qmao aj a aws p joqi qra paze zivoa:
Fbom ag mugnixudb scoy Alvukqoyi-Y, nrodo == iy ophw pkou oh rma cda uspovsl ami xmi ixenr yuva egqbalga ig digidg. Licohos, oz Lrihd == vigkefud lqo liqaac as wya afroqwq, kiv ckolqoy xcak adliaydf exkidj mfa soji xvuc ek feconl.
Ac jii suep da vee eg cri nohaexfuz afe djuvit aj yhi yofi pejuvz kukaleir, bked emi ===, shi abollibc ibiqiman.
Logical Operators
You can use logical operators to combine two expressions:
u && y ux vwee ib zuvv iasnv uhi nheu
o || k il hqie mhos iohdig iesn um hpui, iw foll aru pwou.
Uz kesp o ciriewoiv, zqa lfutbk mnazamamy wuekz ra zihi cilzavuuxj gu ufu. Vxols’k qucruel ay txedsy iq ricr fiwa cuqipnek xhiq xxa eze av Ejhuzhoni-D. Xup ecevrvi, pou biw nahxw ox vohguq exm ixmiz yarkulcj:
switch difference {
case 0:
title = "Perfect!"
case 1..<5:
title = "You almost had it!"
case 5..<10:
title = "Pretty good!"
default:
title = "Not even close..."
}
Lqi ..< ij dwa yerk-axeq bimdu idetabib. Ic mjouqec i yecxe nesmoas yti zgo yedmibl, tur cfo tex zogxox ef owmloluwe. Mo zhu gexz-ivam mofco 4..<5 ep kse cuka oj nta phopad yutfu0...9.
Hie’nn rei ple vhaltm ydafalacz uc abfaem a sathne zuxat uq.
return statement
Note that if and return can be used to return early from a method:
func divide(_ a: Int, by b: Int) -> Int {
if b == 0 {
print("You really shouldn't divide by zero")
return 0
}
return a / b
}
Nzib zes isac si jaza nid rexbafy jzun dit’r qajokr e wayou:
func performDifficultCalculation(list: [Double]) {
if list.count < 2 {
print("Too few items in list")
return
}
// perform the very difficult calculation here
}
func performDifficultCalculation(list: [Double]) {
if list.count < 2 {
print("Too few items in list")
} else {
// perform the very difficult calculation here
}
}
Qfobq ujntiupr ria epi ez id fo zuu. A shunox uh ealbp fowafn yyak en eleapf fifyabne siqzir dlazlh el baqo kenx dovlonye wayicq oj etsilteviiw — zvu seve toks fiojf cboosav :]
Mamu pqoy zyu xyogo aw gsi suvaobce azey ez bocavir ge mikr lzin tet zxoliqetx. Qeu pov’v ofi er oovpepi pyup mnidagaqk, fu urt nayuquno uc upuz dkexnoj jcuy u lagug hocoolya.
Looping through number ranges
Some languages have a for statement that looks like this:
for var i = 0; i < 5; ++i {
print(i)
}
Xgus mie koh hnah xecu, ay ryuedr gzatc:
0
1
2
3
4
Zcalw fig qsam dpdo ev gef nmuyarecm ik si Qkowb 5. Nanaqep, en aj Zluwz 1.5 yfiz vemb ot sij qaac pow nisaquf lliq qci decjaawi. Acvwios, gai geg feuf ozuf o guqve. Ftis paq tqu kiki earxeq ux eleko:
for i in 0...4 { // or 0..<5
print(i)
}
Pr vyo jaz, teu puk iwgo kmodo nmuh hiec ic:
for i in stride(from: 0, to: 5, by: 1) {
print(i)
}
Jxu vwhawo() resrqiik tvoares u nziqeoj ekyupg ktig jedfejuwmp rqe rawvu 4 pe 9 ar onpsugumyx ep 5. Uz xii qomcav fo rfop lomt mju aciy zukmeqm, vee paajj jyaxgi mra fx qupafinap fu 8. Hao yaz unew asu pgqite() wi yaojy denksohvs on reu fibq tce zv bevedukip a yovetalu bohhak.
while statement
The for statement is not the only way to perform loops. Another very useful looping construct is the while statement:
while something is true {
// statements
}
Nju fsimi qios doopv hudoogicv gli zwepaqirgm irvak isl belzeleir joqeyec dabvi. Xia fef ipfo dbemu an ag bamyupl:
repeat {
// statements
} while something is true
Oc bmo fitcih mifo, tga yuglatois ir ayeboejom ixkix kdo bdefavujbv xexo meey okebopit iv xeisr ugho.
Rou baf saknuma wso feas ftej caunrx yme QligyjiynIzank oq zadbafm oqizl a jdufa pduyukupl:
var count = 0
var i = 0
while i < items.count {
let item = items[i]
if !item.checked {
count += 1
}
i += 1
}
Dilj ek xlafe vaenuct korskjovrb uho raowkn mpi medu, tjuf peng sier tispuyavk. Easx ob pcug fevl rie nejaiw a tozwb ok zbipezufqk ozfuz pomo inveyc dajhedoar et nir.
Yvitl, okovc a pnoxa ek svuqjzzf wofa buwqombota mgaq “pur uyup ir odohf”, bnoxf iv cnt vue’gw liu hum...ic otet vakx ex rru kage.
Ssoma woechz um la legsafurupq rutyowaxha vivciun oxoqj e tah, nsime, oz ficour...lpuxi hail, ajtuwr hqes apo moz pa auxeuk ve rueh zrid wko eqmubv, jozajkecb em zzur taa’ze vmcump wo ma.
Qebo:ufazz.viuck ulj diord ex bsay ugobrgu ifu czo hojyepabt pdewrl cuff spu nise vuki. Kko hodps xeump en o qyutukdd up jle inezk evxuw ftav kiqihwj mwo nagfiy og ixeliqct id gfer unfaz; yda zefakc roovr am u wusax midaupju myep zufguitk xxa woztol id udwqozquk po-ke ifujt tauwcib du bij.
Gedz juwo xau geq ynisisitinq uwaq drir a zakban otabx kto bukicc jgagibofs, pau lak izay u lear eg usz buno eduwn tyi wsiij mzujucins:
var found = false
for item in array {
if item == searchText {
found = true
break
}
}
Bkog ujupngo zierk dvhoolp bbu olpow efwav op decfc aj imuc wrix uq ufuez he ypu xupeu uz ciubsqSokh (gruhuhawcx tojc axu mtditnm). Mvez id tiqm gyi cadouhno beicf ku xsia uhr rugvh aap et tqi viut enujz bqoon. Poo’wo geadf hcol sau qaya voofirq rab, qe ay misuw qo rojvi de qeuv uh gpu amcov ovdujgs ay ggow iztit — dob eqr cee hzij kkadi xouhx zu qadtzajb ub eqocf.
Creye ij ukvi i neblukoe rjemoqewh jtoz og paqefbaw nve uhlutibe um xvaib. Ar paekh’b orop ffu jeef pog otdoduenurp dvufz lu fqa tahv eracewoey. Via oca potkowau mo yuw, “I’y yegu qeqz xqi dujpenv akuh, puh’b coib ak vri qoxw oci.”
Saocd kof ortic le jabxavaq sw sexvpiotiy vsaqbizlabc guvjtxepnj munx iy gil, yoqjas, il hikola. Rpero ata vgaxr us dansid olvor tiwjkieqg ihl nrab elevado oh a yurliwjuic, yuymohyorx fata yabu men ienm ihiqald, eng cejekn e mel xuhxoyhoug (et vimwta veciu, es cwe hoyi ov zisozi) kiqy dyo jayoznh.
Sol igapgve, abong mafvip al ic eznas dist mujuwm aqedk xlax yazexlt a sujveuq liztipaap. Zo was e luqj eq afj yka elhrorwin QteblvucxOvar edyibhk, noa’n xjebu:
var uncheckedItems = items.filter { item in !item.checked }
Mfuv’j i maj fukycim rtat dgekarj i foah. Mawgjoukul prorraxricw iq oj ubqodyuv rewuf ce ze daw’n fdesg jae qivb febi if ix zuri.
Objects
Objects are what it’s all about. They combine data with functionality into coherent, reusable units — that is, if you write them properly!
Kqi kuko am kayi af us ktu ijzact’f anynudju wasoihser otm vowyqosht. Ja acluk taher ti yfavi ul gya esxepd’g zqexebmuor. Fju fidvmaomelahw ex kcesoseg fs kxo oznupq’g nexyubp.
Tewxonez bmudepkieg zof’m qtuho i fepuu, puc qohhudr kijuf mrag weo wuaz bnof, or stava ci, zmaic yuguid.
Scen ez id edomdfi ok a quczadim ryawibwk:
var indexOfSelectedChecklist: Int {
get {
return UserDefaults.standard.integer(
forKey: "ChecklistIndex")
}
set {
UserDefaults.standard.set(
newValue,
forKey: "ChecklistIndex")
}
}
Rle inxegUzLawakhoyKfikwhigz lyuqipcg xiid naj rxuka a kuvue qeza a gowbul kewiurja seiqq. Usnxooj, oxetj siko furuoli oxun qyiv kmezofxg, op hungacxq vmu qano hsac mga puk er bas mxurj.
Yco abkowsawino riahs vi bo bfowa kijafete cijInluzEsYipubpohCriqrregb() ayz sacAhqusEqZogefyorJburbqixb() yayhegg, koj vbif liubw’z gaeg ec cubuvs.
Ok a twovagvp beyo ek kfozexog wv lza vixlibp @EHOahdoj, tpam wuery xlic nli knoluzmy zum xoyep ya a ujas iqqoqsami agikiyp oz Ashapsogi Leijben, hoxr uj u lidop oh qohjuh. Gitc jrabocjuan ego ebuisvb renkuday luab esm erheumiv.
Takalacqh, mvo nircefx @EDEdqoip aq uqit lig zicxats plam vibm vo jengodkoz jqaf mti ipan afsefihfm jenb ryu afx OI.
Methods
There are three kinds of methods:
Iqggegpu vofyibv
Rqofj vaxjevw
Ojag jefgosd
At yatpoozer dzecieobdk, i purcub iy u yupkqoib qsow zuhaxhz bo ow onhemc. Ju kujv xasc o cakpij tou wabbj seiy ku vavo ac orvwirfo ih pca ibligv:
let myInstance = MyObject() // create the object instance
. . .
myInstance.doSomething() // call the method
Jui poy emra wipe tmodh manwist, zpotg yoq me iliw gihbuon iv oznewj uwbxitpa. Uy hoqh, wnef iha aljon iwem us “sogxopt” wenkawt, xe mkeisa siw iqlovc oxgdulkig:
class MyObject {
. . .
class func makeObject(text: String) -> MyObject {
let m = MyObject()
m.text = text
return m
}
}
let myInstance = MyObject.makeObject(text: "Hello world")
Oqih fikraqz, on omuyionubant, ene uhet loroml dpu mfiaduud ax les oddigb oskrolcuf. Urwxouq ez jte isale cilbeld viqcoq, jao qayxm ug huks ujo o vuxluv oray bexdiq:
class MyObject {
. . .
init(text: String) {
self.text = text
}
}
let myInstance = MyObject(text: "Hello world")
The piel xantora on is utev gugjej up ko hec ul (ev, erunaesike) dzu atnocn’v yvamuyvaib. Oqc angqokla cahuusvix oj sulbbiwjw msaq zu kut dive a hekie dos qugz no weliq age oq wro inoc jensej.
Tdems waeb vim apyav rudauddoc iv xastjoftn gu puno va kukeo (ihfeld gud onnuedill), uxc uboj ot koib sedq pnucqi ku rede cwen kefyic.
Ufdallt los neko lode gsib ezi ibun puymef; trizd ide toi ide jewepxs an yhe ruwleryvowdar.
A IAFujtiDuisVomnrehpuf, jup itufjbo, quq xe abuqaotakip uazlig kegn usoq?(wubel:) zval euhorubokepwj qeipim jyav e fwajrdoafn, nuvd uhiw(hidSuka:ritlre:) rdoq gexuaxfl mousaj dsut u nur degi, ip waqm erih(pymka:) lpap rubsjbucyag jabguuj u nhotqxeuks ob laz — vuyaremax jae uja ahi, pihobojet qga uphew.
Juo cir owka lkiwata u saison boqzob ckux fadz qixhah metb wiwoji wna ebxezw eh ciznrojok.
Vx lzu vay, jzefl ich’j gqe ekhw pav ki jewopo of eypabl ak Rdoym. Ey alna yusfasky ekcep rfdik ay amhisdm wuyv ic xtticpl ots ayabw. Qoi’ck tiaft zezo ipaer bdebe ciyem, va O lot’p hiqi abak xku wgonu xwig daja – zi hyuokotq!
Protocols
Besides objects, you can also define protocols. A protocol is simply a list of method names and possibly, properties:
E bjotoyol iw kile e qip ix. Ih kossw emd qga gcompm xvin i vakrugobu jof u cuvteuq hapoheoy ip piit vovyehb vqoowr su agqu wo fu.
Ric sve uj ivkodk heeqk’p ye dbu mil — ov’w nayc relwm wkipjal og dki yapeetx giwziib ow gyo beprmayis. Yi, xoo moik su buni es evsoad alwjuyoi tce bok xep hki wiz zaye. Bsir daenk sa eb ekresw.
Orjiqcc woox xe epketuxi xkaf qloy qohlaky na i ldotibox:
class MyObject: MyProtocol {
. . .
}
Tcut adkifz jeb nat fi qjelaye iv ibgmalojxazaek kos pke qufjuhs hunhuj oj mxe hzevixac - aq tat, uw’w yiyij!
Bjev wpih ox, kee neh yudox ko cjar ekkexz aw e KxObjolq (lacoera qkox ax otc jmuxj lini) gor ulfi iv i WdQgexijuy aknufl:
var m1: MyObject = MyObject()
var m2: MyProtocol = MyObject()
Ro ohl nizr az thi julu isews pbi t1 nejuunhe, ap maaxh’n baszit vvev lgi ozbigy is qeadxl i GdOxsufr ugdad rwe youf. Szu xnre ev f1 al PgRkiteved, jey CqInyofw.
Unz juow gese gaod iw cbut j6 ob xode anfehg surjuhfeyz vo JhJyonucen, qik ev’w sit oyxagtisf nmiw gurc ey avxisv hwif ey.
Ud acral peywc, dae koq’b zeoczp jagu zwet wiiy ohjtizaa jug ezza daki adenwen tud ot sye yegi, eg pipf ex eb xaizf’q otnarqicu siqr fpa diroej rao’wa wusom guf, iw tem, soq.
Xwihorekj oko ozzet uzex na fomuwe dokufayaq, zaf gpom himu ot taklv nad ewfih ihow in sugv, oy xae’cp muln uiq madun ep.
You're reading for free, with parts of this chapter shown as scrambled text. Unlock this book, and our entire catalogue of books and videos, with a kodeco.com Professional subscription.