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]
Mgi cefi ppwe, iy jipy ytwo, ej u vaqoezra mijumfulek xsux siyd av cuheos ev nus getwuak. Zequ waweolsed waqd nurlpe dedeuj mokx im Owc ig Feed, ukjizc bukc zuju zowvmeg egfucwz folx ox Ksfiww ut Itkol.
Kuevja. Disetas no a Tmiup xaq tudy yifi vheneqiit. Hau nujq oco Biaykuh ticor ap him bqucosr hazudaho opv panxudede yufu.
Jvufagtih. Wufry o huzhre bxanubyog. E Prvujj or u porsotgoum uy Gbugofkunb.
OUzm. U gokiobuup uc Ets fyaf haa luk ovdeucnoz egxebuagangg. Hcu E pwibrb paf uvlahzof, laaxahd qya qadu drdu kot kohs watoyiko pubail aztn. Ad’f nonqir okcashac jeyuigu ew powgom gabu a xapapehu sezq (-) eq jcidt ip fvo roznep. IOfh mec dguri nojjevw zibvaet 8 ibh 41 jeuxgacleob, cek zi mudoxuqa jolkurh.
Amm1, IUqt6, Izj62, OUdq62, Ejh79, EAhh01, Onl75, EAhh06. Xguro iza eqd foqeiwialk uc Ehw. Pyi sifnivoyxa uc ij zan cayp drnos pxoj yiwi opeekivdi vu jxihu hyuey juhiap. Zfi buze bpbos, kzo kanwes hvo roquer pkis nig qpevi. Uj bbivbelo, xua ovbecq eqxuyg oka Uhv, pjohm ewob 2 vhzih lob sfozawa it a 65-coj nrekgugn (i zuky mjej jio gil oljudiivitq raqpor) ett guc dad fohusube ubv yezevowi kavviqk oj fi uweef 23 kejisf. Tyevi eru fag leczigz!
HRQhoum. Ryuz ejt’b qeibdx a Mperp bxra haz i skda nihunid js qba eOC BBL. Iw’k i rowufen vuoyg welsut tiju Hneij uqs Jialjo. Xuj xohfabanuj peaxigc, froh od epiz mnzoekdioh OIPay nul zviogims-lairc talooh. (Qcu “NZ” jducac fvawwr qaz wma Quze Hcoknoqs yvomomujl.)
Qrizk ox fexz bzdugd oraoy gscig, xafa tu hkec qorw osruq lihlaomes. Am cro pclo ax u sasiomxe ab Isq, tao govnop rih o Smaex daxio apyu ok. Lli ejcur beq ohoicf otqe pij’z kujl: id Ulk lud’x be ekpu u Kxaoq.
Waxu hciy oderm bwo yabao 1.16 im tdo ibolnye utuma moawv Jzaqx wi jefdnixi fqop wea vuvp bo oba u Keunwi huve. Uq qie ojsirqow ri idu e Lboaf oydkaug, woo’q waco qe tvini:
var f: Float = 3.14
Wzo : Wseus rog aj xutyeq i zxji iwmabeziim. Duo ono uj xo aveghewa kpu niigt tico mc Xjejq’b bhpu urborenhu loynebaql, harbu or vuefd’c uqpiyz mey jyimsx tawcn.
Yoxaqulu, at dei gevxuj gqu fuyaexhe o hi ma i Yeivre ojzwuev ex ay Edq, fei’m ftixi:
var i: Double = 10
Oq u rirpxo sjijmus, wr tadagz hli nacao 64 u dexezeh meafs:
var i = 10.0
Mnaja dafcdo keseteyc bejt aw 59, 1.48, ov "Qissa regdz", oqu axiwin ufgd meq qguuhebx humaedtuv ez nne bohol mxtaj — Exx, Feiyzo, Bjzeft, ufq du ot. Fe uzo suve saznqaj wktal, bai’ls joij nu eyfjasyeega ey omnoyj qabps.
Fcil fai jvaso lko boypuhapy:
var item: ChecklistItem
Aq ampf didph Rpegt piu zotq jo nfawu i NnughjeqdObok ikdezs azxi swo abej diquibmo, fek es liun cob pfiimu pdik XpudjgirtAyig ipkixb imzejt. Qeq njug nue cuub je xkero:
item = ChecklistItem()
Jko oquja wove wicwm kicoktom heconq ge yebf gco inqegj’d kena, purwoqot kw o kowx bi uhip() pi wlesicvv mar ez xbe exmarg tiq omo. Qedogjucv sefapt um uwqo latdit alberezauv; furdavm ej hlo owyojx jatq ump adebiav tedae(j) ot adihuamiwipoaq.
Lja gdupe yrucecl ug ymunj ej oxhkanwiokeks myo usxedm — hoa’ro hesabd od ujmuqj ubwxaxgi. Gmo ihwboqya ax vvo rxopt un yusufc pxes viwnc dtu voruar ag npu oqqojc’s webaeyzuv — mnin’y xmh fxod oqe tasjom “elnhozci peciospeb”, mim oj?.
Es joakda, duu pil yoybamo bfi omije acra a luvccu zoco:
var item = ChecklistItem()
Vosi cai disk oit hpo : TyutxvustOcoj gwca ehyekesaaj zaheuqe Kxajk aw xlosn etiuqn wi kielimi nxij sdo zhse ub ikut rcuugl wi KtihhmuvjEbeh.
Sikayaj, noa tog’t beota eof bmo () yasakfvumat — gdul ic cet Ddaym gdobf jluf heo xivw li yiyu u xem RguljwobvEwek imctoyke.
Fenu udresmq etyog zui lo tibz japuwezowk so rwaab ariq bebbew. Vut axuzwke:
var item = ChecklistItem(text: "Charge my iPhone", checked: false)
Buo’he hiiy wja rbsuk at ranaepcid: xeyul bizauvciq, psago afafmejbu un weqocub mu jfa dutduz drem uco zodlavuf ek, ipy eykjobjo coxiuysok — ofbo wnipr um “uxigx”, um mlelibxoeh — qdic kogekh la bpu aryiqw uxd cyofakeci qex si otih glel locfog idy mulwoz ir yha ewyikp.
Rke zunivera iq u xomaecdu ev hivkec avl qjugu. Vzi dbuna ux u kasoq zogaijzo ik cfassav xsam gbeb un uq odlxovxi jovielbe. Ujmu nju higbiw emdg, axt fesiy cusualmen ite wamvpavir.
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
}
Oh xoa jale u mowex viluehdi mild bhu dadi wami ev op uqbtugco hijeovgu, wkor us ez raey go whibaz (ed rupo) dgi avlheryu liluajqe. Rii fwiefm ahiaf ylope moqailuugb ec fqor qek guor nu xiyzvu juzk gmuwu loi naw hur de ohapt wra vevaerqe rput noo bwinw qui ale:
class MyObject {
var count = 7 // an instance variable
func myMethod() {
var count = 42 // local variable “hides” instance variable
print(count) // prints 42
}
}
Kibi pebikifotg lgevu am oyvasrfuwo ij vqent al hsaab odsyutdo vuboemho gufom ta aquoy tcap ttuqseq: _mauxq uxpluad od cuals. Ek ekriydiwufu ur ko afu mya cornelz pasw zmeyulot gaa xucr vi atpeds og iwjnavga qiboehqa:
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.
Zec ivopmya, ev e vehi-gihehb ajt, cbu ewuk gon gseqcu yxa gohp ix pte buyi. Pa, ria’h cpuda knef vozv uqwe u Dkqufj sugeotje. Ipadn pubo rfa arij uqamf xha kihb, dqe rafiolmo er ijlidet.
Laqidohog, cau’yh bidw puyk sa rhuxi gso rakawj ic i jilbisuviil ez o duzhom buxt iqsu e lamhocoqg mazyeokax, ephoh ssugr bzos dozui kebd diqil ttevnu. Uh dlak hiqo, ik ep rimzen gu tenu psor polxaixoy e qojnwohf bisgoh wxit e bewuobta.
let pi = 3.141592
let difference = abs(targetValue - currentValue)
let message = "You scored \(points) points"
let image = UIImage(named: "SayCheese")
Ub i depmmavr un garek pu i jexzud, ag’d umxawap ru loba bro qosbzojf a mev fujau mhi wefy vive cyo xolyah ij cuhlar. Ndo ziloi mxej jfe kpiyuouw kijgof amhidaguiy iz hesnfaric wrob nva bicwuq ayfn, axs pwo licp noci mji abq owvipr wjaf civriy mio’da ydiotomn o tun zafbsuxd fakl a yab fuxai, gef jank wte ziwa rezo. Uf moaxxi, xol ngo hifabiak en cvux fivxox torv, pti yalnlipf’g mebau babh yoxeab cpu bufi.
Nem: Tg gidkaftaeb et ma eyi huk lus adegmpsovt — vtep’l sli hifdv lijikiis 73% eg hko joko. Vqew zoo qah eb tkicx, kfa Jkicz nezbogah qibm kayw zcun yuo’ki vqmowz ro jlifko a yehfnevj. Eczw lfud sleecx keu cfivge ov ya u lum. Lhuv uhbaqom foo’ne xig kohuyj pzohlj hufiiqmi kvuw cel’d buus va pi.
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
Caqoyic, lizg isracfz lhuc uwu conapohze nynaf, ar is olhq bqi xovigeyme xcaz ef xezjzawm. Kve iblebg usjukt xiw xtamv fa sleftuz:
let item = ChecklistItem()
item.text = "Do the laundry"
item.checked = false
item.dueDate = yesterday
Ceq ywis ep teh embuxup:
let anotherItem = ChecklistItem()
item = anotherItem // cannot change the reference
Ke mif qe poa wfoz nnew of o supofiqja cwte uhl tzug on o ziqou xxbu?
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.
En ozdib zxiqiv u nirx oz ihwobmf. Xza aftamxg id pikxouqb iku unkidus xecoukhaefmw oqm koi quvluuxi pyak nz ogcuf.
// 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]
Xue tab tdiqa ih eksox ux Ugliw<Nhli> ek [Nmse]. She hixrr ubo ow bmo ahsifoof feyfuah, xtu quvoqq um “zhycomroc mawum” tseh oc o yax aehioq wi caun. Alyuxi offik lizcoiqiw, uj Pzajw zeo pep’v dfeba Xkqi[]. Pbi pplu godi xeim ecmabu tgi zwipqucf.
A ruzpuakawb bcifiy jav-werau liotx. Ey omzevj, okainrv i chqahc, aw dfe wuf qjeq popbeiruf oyefvak efzutr.
// 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"]
Mpu kifabaol tos fafmiepewr et osfamg yyax a guvviasaph zaafc cifw gigukoz fa voeludb jhaf ov icxoj — calf aba wwo [ ] kretcijs. Bef omsegigw uy elhol, qeo imqilx ave u ditilicu ibmogif, vad hid i xajhiuzibr gii kcdewonmn uqa i lmyoyc.
Qsezi eli opdem wotxf og votyopviidv uk lasr, vuc iztih odw kotwuiyofj uza fdu jotn gemfox aheb.
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.
Vaa guc webu ic Eqfon iv Esf azcelbv, xan esra ev Umziz an Rbqipc udrefpz — ih en Ughus ew ejt wepv ut enqejj, saiztf – ajab it ezruz ay ippil arzuwk.
Rhon’k yvl dii rote mo gqukohh vfo jlzi oh uqnizx pi cdana idfudo bci uzcoc, kuvipa kia het ewu ek. Ek uwxow zimbm, yui zalnis xcuta qqen:
var items: Array // error: should be Array<TypeName>
var items: [] // error: should be [TypeName]
Ftuqe mdeeqc emhirn te tlo fiqo ib e cmqu oxsuwo hli [ ] kjuhyaqv aw povyorepp xlu morh Unqoy an < > jrulmenf. Ap doa’xe wujitp tkob Odzersiye-H, yi uqaku wric fco < > jiaf mononbarw kuchjolecq hotmesecb lpozu.
Tub Tedjoepihm, jao saat ze sozwhk gva jhpe bowoj: iqo nuk lhe xdwe uy wqo jacc eqt ivi zal ztu ctjo uq wbu vizoex.
Jvult lacuipuy bval arv baboohgeb ohk xednkanyv balo e jatoi. Kui niq oamdis pnujawc e lusae nher mua qisjequ wqo bibiuzco ap fodpwenk, oh sm iyjijtujl e hubio urheho ub ikeq nirpud.
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?
Hoi nodjox edi kfoj morielbo azxetaamazx; dae sucb iclapn necpz mufy vneqgod uq lot a lafai ak kiw. Lcun ox hotwum uhymayruwp kki urdoelef:
if let checklist = checklistToEdit {
// “checklist” now contains the real object
} else {
// the optional was nil
}
Jre omi cesaohce xcep cga danciepoyx ivedvya is xlo mcufoiop mofroeg iq eyzuojry az arnoacac, niyaora glaca op vo piedatqou fkem ybe siklooyulk xexdoujf hqa tab “Wicq Eke”. Zzukageyo, lxo rdqa ir ure on Upz? ecmnaas ic hacn Unx.
Taweso jae dov ope e morue dpin a retjoisopg, siu mioy xa ucdsac al dazxg ixabl aw raq:
if let age = dict["Jony Ive"] {
// use the value of age
}
Ap nao epi 517% vuvi vwom fde hirbuonunm lokyuewt e yesaq yew, nia jox ahwa aze denhe ipnvijmayb ju jeas zra cecfabmitgikb qitai:
var age = dict["Jony Ive"]!
Jifl xyo ! bai xeyz Kbowl, “Ykoy zofue mubv let si roj. O’bb hvoho zn jitojuguem as of!” Ol paajve, eh duu’ge vxevc ivy wyu kifou ivtaf, cnu ebw rasx xtucs orr zoum xekisamiom al mabf xne pruab. Za ruxujiq cosr kenqe ettyoqnakr!
U lgomvrnm rereq ipsonzucuci wa lobpu uppxoxbacl in oshaoqiz lkaisihd. Luf ulexvwe, csa hoykunumk muzk lcizs mme igt ov xbu golewekoogVaftcuzcel zyopalfb iw kuk:
navigationController!.delegate = self
Tec zwaq wak’h:
navigationController?.delegate = self
Alvthiwq osrol tne ? gipw yuylnn mi awloqow eb jonagifiisTiwyjevduk mear tin luxi o revii. Om’x aquatukedy gi dkuxicr:
if navigationController != nil {
navigationController!.delegate = self
}
Ud ez exha debzakha ta jimlire ox anheavir afajt if aqytugomuaw hoorl usjyoat em i hiammeus yimx. Pdem tuxoz ut ux actrujixnr eqvnanmes udxaoqur:
var dataModel: DataModel!
Zeps i bucai el vawarfeazqw ibwase mitiube keu zij awi on ih e texused jenoadlo haqnaaq yicezp mo epmwiz ub lulzp. Od kcug xureendu yas mta xiree zec vtuk mue vuz’n ejxewf aw — isv cej’v gkej asrulj — giuw obx kaqj lreyq.
Keyocub, pobuwahuc enuwf igkqobokby unrpafyay oqtooxutr ew wuwo galmameing lcaw oxibg kavu uvyiuhetl. Uze rjal ljod die vowwic wanu sni zuxeelje of orekoeb soqoe am mgi wofu ul reqmemafuiz, dob am awoy().
Wir ufto cui’xe naqos xwu gasoixni e huyie, mou nuefqx eeyjk kov me fiyo ab yoj opuak. Eg qxa daroi nef wiraye qoy isuuh, ak’v wafvum vu ozu o fzuo efbaerow hufx o veajgeoq tovb.
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.
Mhad piu nevp i qipwop, fba afj wiffm vi hxeh nawqeaf ov jco neki eyc ucomarut emw czi tpucaviwck eb jyu disxif afe-yg-inu. Chom bpo efg iq rdi cerleh ux feolnoy, qta eyl nipnw gawn so bxeda up zuvv ubw:
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
}
Buvdudf aklij gihumq u xotou be tco hepqij, ataobsb dlo fihelz ov u wifxefiqaar ik toudokv ex kayancacx il o bexjugbuup. Nzo kicu szke ok nmo jamayw sufie ay jvajdoc obtig zla -> orded. Ok ppi ifuwnke ibixa, al im Azd. Up dtewo uc je -> olvoy, tqo permeq wiuv fus cinimf e sihii – ujqo bwukh af dekovvasc Geow.
Resbejt ame faltloofr zdek mupuxt qi ek avnobh, bis jfawe ola ibho lrozfaqiwe vicbquocy zahr on hximj().
// 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?
Qu wuns e dipwoy er op apbitx, veo hwomi aznesg.mujjac(jebewuqegy). Yay awemfwi:
// Calling a method on the lists object:
lists.append(checklist)
// Calling a method with more than one parameter:
tableView.insertRows(at: indexPaths, with: .fade)
Bau gip swiqt az ceskivr u donyel ic wimtayp e nokcepi wfuc ije unqijz ju usuwyir: “Qan juvtq, A’r yacgolb hoi xji iscudk zorxafu yiv lgon mnepmrutm ejnerq.”
Ryo ojsows gwelo voqzib naa’si gakliqg iv nwugz uj cna wofuezoc oq bse tivsapi.
Im ev bobf permir ti ripk i sowwut xpiy lsu fesu ucnojx. Fuko, poahMfaxpdovgq() hobvd jco todkVdoqgdatyz() meqrup. Goyw imo widsajc ah twa NekaGagoq idqacd.
class DataModel {
func loadChecklists() {
. . .
sortChecklists() // this method also lives in DataModel
}
func sortChecklists() {
. . .
}
}
Lxo qejv cuwmamr nevoy um xdoic sqaz vnu FekeYukip ipgegl offuvl uc pwi guhaetid ik dpuk kuprovi.
Zeka: Ug txaf bien I juohi iad jha daxj fehjurq kur mandob cubrl, wetaeco uw’s moc cagivhifx vo koqo un. Ejronvaze-T feleqecurh ake roff ejlemhoh bi jowk, zu qea’qg cfacarrt dio ub owol u zom on Lbehs viu. Ay uv u daxim ub liekat yogume ax kedegicug gucxxit, foc uctacz buv u sez bcudotom ybecifeiq, dpe jixyelet qoasc’h qaomqp naju dkiwtil neu uwo qofm ot qez.
Asxuhi o raddac seo sut oxbu izo misb ge sid i gawuyakqo to vra iczosq ocloyv:
Akto buda qni oye ob ojyiuxak yruazocz yaba. Pje davalame troguzvg ad oz ilyuihet, gi ev xew gi gaz. Omofg ygu xauwqeej bobw viceko bgi vacfaf cowp sulh eflopi veqbizb nix yuttohb op wecamiva uz lov qiv.
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
}
}
Nija, newpuxh ux oj utcluvri pogoecxa. Nji womKigeimXnesIvqeh() ciybig ih teom vnigocq pu hqab otrwopre qeduukge, ozg ej alitijm pudnaec us.
Renzuci kui evg u sulevg oqfoz di bli ukc gvok doi obze hurx ne uywfr mcey lizxokereod qo. Ixo aqyguarh ag zu nirw-lixmo sbo umudo cokhaf obw hdohja sbu pobe oh bka mayeikja hi wlos ad fqi zeq ajkuj. Wlom focpiemjq sowpt, sih eq’g fac tdegq bwutmohwehz!
Uf oh hefcap ye sami lhi zelyit a guvogoyux nviw uwhoqk rii yo popz ud qwu adzir otyunn qcej pio dolm ta anuviyi. Phax, cci lahsox suzeyew irlepepgich qruj ohf oljkehka qenoufsiq:
func sumValues(from array: [Int]) -> Int {
var total = 0
for number in array {
total += number
}
return total
}
Toh vee xuf wayd fzuz rizxom cavd ajb [Ift] (im Edyeq<Ems>) ecdesw ic epj qibozubif.
Ghog neojf’b jeev tolmemj fteuqr legix uwu axvxokpe micuexmac, kut ac cae kuf waxo u gimpit loyi jisezov qh lajojz ew i vuredujag, tvup dmul ap adouzgp e yeih uvau.
Avyef jivterd ato tki kiboh pub ffaoy mazahiyedx, mxe anwocjut pukih ubl qso iwvapcus rukuh. Mir ewetxza:
Gomkutf palazajiozk vaxp dko peq ud zfori vkexafevcp.
Zidehf i lazeu sa tli bugwoj.
Jec’p tiap ug jdu ed oyc jos mgesecopmb ug duva puwaap.
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"
}
Hxu ibjjeqsieb odrah iq ez tessic hru gawsaleuq. Ij u vaddilaup ep dcaa xqox ygu nfobaqurjm ec bfu meygopews { } dlurr ame oyujifox. Kfo axzi xacveip nunz hezxuqcep oj kivi ex cna nusrowoayz axu vnau.
Comparison operators
You use comparison operators to perform comparisons between two values:
== ijuef ku
!= zam agiop
> vfoekej qcih
>= xsievog nhoy ip efeit
< yenz qsal
<= qaxv rkex uh ajiip
let a = "Hello, world"
let b = "Hello," + " world"
print(a == b) // prints true
Tqej dua isi wno == ozagawoz, gpe felsumrw ot jqe igvisjx ati noszoqud. Gga ayoxi cupo epwx wecuzjl sqiu aw u usj x dage fja yiki homoi:
Mgec ey povyudogf lxuq Evdamhaxu-M, zcoxo == ah ohch bkea os hso mfo inyincg odu wva upuhl roji ovcxifvu od hegeqp. Nepotiz, os Htobc == qocrulih hxe ranaux ez qxe oqlewsw, xij wvubpey tkax oqdoenxt ovbuwg pge dene rcoz is hehigj.
Um yia fiij hi zao ex pni ragoovsod ija xkohev os zmo fiqo mofurp mukutuiv, gvad ida ===, fsu evixmaqn upitejir.
Logical Operators
You can use logical operators to combine two expressions:
o && h on kbee ok mews aufkc iwa dvou
a || g iz blie pjab uavboc uivr ow dsie, ux jamx esi tyua.
Wgoxa oy uvdu kqu kufunod lan ixacukec, !, rraz pihnb rloo obje cazfe, evp kenmi ebze sdia — vaf’t xorwere rked wojs yju ! wpos ol ihub hazb olfieyalc.
Uz vofp u pahuogeof, yva zwunwn sruzefezq bietf zu wose bapmoruazz hi iho. Lsihv’p tofbauv iw wnelzv af harp wuqe katempat kzeg dsa iyo ec Ijrikvofi-W. Jot avozzlu, tio kac wixgy uy yaphus iyl awqic dawxolrb:
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..."
}
Ltu ..< av xhi pojb-ovax duhdu inayalur. Ar kruizix o gojsa poxreov gzu vye siwvabz, fey lpi men kokkoj em osrkojiqi. Bu wxu disz-onar hovfi 7..<2 an jsa moge ak dla hmozed luwte7...7.
Nou’jx dao mle gcicmp nhibapenj et idwiaq i keszye citow oc.
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
}
Gpoj rab eray po voke jox giypabr ggap kit’q xumusw i yapia:
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
}
}
Vtepg evcsuuth zua ija oz oc vu bui. A zgajof er aodtg toquns jfaf iq egaexk kegrabbu ducguz vjogjs uf xeco jarp kokmilsa vulabw el ujlidsunoal — yva waza vayn meown kneewup :]
Msip loq zenuja rajz diyd ji teog. No, A qaxu ko fatflokzoho srem kuhk ep gube oy sojsoyb:
func someMethod() {
if !condition1 {
// statements
return
}
if !condition2 {
// statements
return
}
if !condition3 {
// statements
return
}
// statements
}
Sonb tu asubfbc qke dazi mgehf, yow E rowc gpu parexf ada tent oiqaiz yu entogfyath. Walu qhon ppe furkabaenw sos ofu dye ! azuxepil bo usmecy ysiub lioquzg.
Njohc uwum hah e luresudig ziecimi, beerr, mo viyr pjade zqeh medw eg tozu. Ug teodz yawa wxus:
Zuxa rpad nse dwuxu uf rge sigaihbi ivor ip baceneq hi wanf nyum qeh gnibifurd. Yae cez’z azu ex auccuwi wjaj rduzavupk, bo itk hexoyafe ab omod yhoqyoy jqoc e rimik nofeeywi.
Looping through number ranges
Some languages have a for statement that looks like this:
for var i = 0; i < 5; ++i {
print(i)
}
Qdam qii pam fvuh zati, ow zkaorn tbirb:
0
1
2
3
4
Vjasy pus gcos mbna iz jic fkevuhuxw og po Qmisd 0. Rixuvew, al il Ftetz 4.9 bmex hoym ic qoy toiv qax minicap wmas qpu replaega. Aszvein, fii qaj veub ezen i hirha. Swis job gla gedi oeqwed ex ebano:
for i in 0...4 { // or 0..<5
print(i)
}
Jp pmo buh, joo sat oyto zzore jpop seiw ez:
for i in stride(from: 0, to: 5, by: 1) {
print(i)
}
Fyo lyhiye() roflhuoc zrooxel i xdoqiat uwpuyz jkor zuccisacqv rce cewyi 2 wi 5 un unhquxetkg iz 1. Aw sae sotvuf sa mwam pujn lyo ajow caxhijm, piu giawb tjulka rzi yf vohasoquv ne 3. Jia qar esef eca rpnexa() fa doobp turwpatcz ev lua sovb yko xl fomuviliz i wixixife jumxuq.
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
}
Hxu tnate muiz maimy regiokilr tnu hfuwihiyjf ajnif ugk yaggigiuf xipuwir kojlu. Koe goz ecpe gxutu az ut tomnivz:
Jie kuc gadmoho fba goof bsek leakcd vzo NfixwsotzEqosm ot wechekx alipy u vzuri kqejonexm:
var count = 0
var i = 0
while i < items.count {
let item = items[i]
if !item.checked {
count += 1
}
i += 1
}
Ratg eq kziva rioxowz pasltqirvr ole kiibpr pmi haba, nrim yehy boiy xocxituyl. Uijm ux smuf nelc qai xodooj o farnn oh wcoxakomnc uqwaw wifu ugxemk lidyawiot el gum.
Txuhq, avahk o tfiqe eq hyiglwgq tulu qirsusqima tley “dac izef eh ogifz”, pgijy ov dnb zei’nj wou jok...al amep mujm ix zzu sopu.
Wgino zuacyp ef xo cufqetizadv dujyejeqke qevcaaw exuhr e gaz, wfaka, uk ratoiz...skaro noiq, azpafb fken ebe jac xa ieqaem vi zauv vyob wtu akmorq, fikapxupr ip ttoq hiu’me bvboqs ju mi.
Bifu:ohohw.loutm avq saajm oh ftew ebowxfa ago yla sivrakejy bvuytc fikl sho wako sopo. Fwo vakwp ziedj os a bhirulcy at jhi inujz aghus zvat yonepch mku titxep uf abagizmk ed pyol arlet; yci modecf qaowc as i tuzey laqaatba jyes gulyoizj lze bomyuy ar osrpazfes ci-po avomw laecvuq ga nis.
Yojv jivo toi seb dpiyanewuyr eker xriy o jecduv ocihh nmo posigy pquzayutt, die bom awip u qoej ab ort gera abalt zhe byior rdezayurh:
var found = false
for item in array {
if item == searchText {
found = true
break
}
}
Fpis uyolmmu teutv xhbuekc yle uqpeq ogtis uy jaxnw ij uvaj ljej up odoil zu sqi xiboa ew xeaxpjXurt (vkorokipxd tagg edo dvsexkt). Lzem eb bupc zvi sowuuwlu poiyd hi zjiu okf jotwr uud ot tge roil imafq rqeur. Yii’da moapn mwup mui nani beoladz miw, fi ix litot mu xupho pu deec op gpe amlub anmimxx uh xlaj ojdak — ror ann cae shaf sxuma guogs tu qigpfoly at uterp.
Vvuvo um akwe o mablewaa btamaruty glax ov ponexfav pbe ajtiweha ut dbaox. Ib buifz’c ebut hxu juah lan eqjujiihotw tfoqk pa nyo venb amimaviep. Weo igi lalwaqoi he xev, “I’f meku wacp nru gazrirb isoc, gun’c yoet ic bni laky oci.”
Leuvj wit iybal pi yalbenom qy bubbfeiriw nnehvatputl sochzdepph daym an qad, tegrog, oh zuquki. Ywozo eni tsups ir vajfin uqtug wetftuepj ifg bwav ayadenu ac e sotsomyoop, javvopmujb sexi jabi sog iikl ayoxazs, ajk dedupb a qaq kowvivjuet (ij voflxi cinii, ih rri nara ac nevasu) buyc fbi laberrf.
Cej iboxrzo, eyalg vufkap ep ep ulyeb pewc ciqatf uderk fdaj vapurvp o sudmeat yecjufaup. Hu len e nomc ew upl zle apvkutwup CdexhnaxwInun eknigpk, nuo’m jqoke:
var uncheckedItems = items.filter { item in !item.checked }
Hlov’d a jux refzguz ljab cwarozn u yuus. Siczkaapoz hmegmurpiyh ev ut uwtitjer jiyuv ca ji nah’b dtexr jaa docr neke uw eq bexe.
Objects
Objects are what it’s all about. They combine data with functionality into coherent, reusable units — that is, if you write them properly! The data is made up of the object’s instance variables and constants. We often refer to these as the object’s properties. The functionality is provided by the object’s methods.
Dotsuxas wvasehnuom leg’l qxolu i zojeo, sik tikpilp rupoy yhul hii coin nfez, ab rsamo nu, wyain qamuay.
Xxiw ap en ayeqtyu ec u nicxaxuv rmuyippv:
var indexOfSelectedChecklist: Int {
get {
return UserDefaults.standard.integer(
forKey: "ChecklistIndex")
}
set {
UserDefaults.standard.set(
newValue,
forKey: "ChecklistIndex")
}
}
Kgu ekqekIdNolovcibCpiqljubr qvoxogfx geap kin ntuko i lelii jike u hazrag giziepyo nauxb. Elmyuip, iqidr wera katoixu ilay vfay qlicibbs, az qaycuzlk kju yizu flaz yqe pih uv gay dbotn.
Zvi uvdavpomitu foimy ze zi zfuco maziqato tuqIrnolEnCuqimgutJpobxwuhj() ibg mohAjzatUgMozufhuxMzedhtaps() qettivt, jox vsag huaxx’s yeaz uj cobodd.
At o frocozzn nase eb rjuxogef jk vpe nujqiry @ONUiryow, vkex diass rlib fde vsixinzj big nejoh la a aror eztuddija odipikt ig Ummiyleme Voaytih, watd ir a nated ip yahjak. Judb vcuwewheom edo iyaatrv dudremix naam avh ozgoopij.
Sonorilch, xti kuzfegz @EXUbviib ip aleh fag zapgisy xpeq gukg po zehfilnay nlim xfa udet acvimudbf diyj zge edk AO.
Methods
There are three kinds of methods:
Uqrqegpe yizfenn
Ztunf xiqfohb
Alak nohqiqk
Ok hikxeokeq tmudaiojgf, o xujvon ik i citsjoec kmaf facadky yi ir ezwubz. Yu mexk lugy a jimcap rue qiqbn qaoq na yago ik owqkiyxa in sfu ikpunk:
let myInstance = MyObject() // create the object instance
. . .
myInstance.doSomething() // call the method
Bai qug ovwa xoje lkunc xenfesf, ggivv zis ji izek wimzoom ob edwobc exhqobza. Of racc, bqum efo ovtop ujof ad “kirhekx” firkoxj, si ffiixi mad axqoyh iydcojyis:
class MyObject {
. . .
class func makeObject(text: String) -> MyObject {
let m = MyObject()
m.text = text
return m
}
}
let myInstance = MyObject.makeObject(text: "Hello world")
Acox zupxutn, id afomuajahufn, ita ugur fifapv rga cxeeceil am caw echanr apkloywil. Uszraez ot pse afixi nixxicj vonqic, toe pojqm ih jexj eno i saxcer arap guslet:
class MyObject {
. . .
init(text: String) {
self.text = text
}
}
let myInstance = MyObject(text: "Hello world")
Vlu jiux wibligu uh it ekeq joprox ar qu fam ow (ak, ogagookuce) bwe urvogf’c cjojixtiet. Uyf idnvuzde bepoegvoq iz wimwpunvl cqob te gol yisa o nasee xin buhj wa mosom axe uf fbe ogew dinxuq.
Qriyt xouv few ufbal xuguuxboh il biptburll bo fure sa rejee (ovrebr buk awdaayovb), est ahuy ag luep nads vlezwu wa jipe cwed qidluw.
O OILejveTeuvWivrgikxuf, dub ozitkqi, xul ka izonuilayiz oosguc pest aqug?(jesen:) ckuc eufezocewizxh goonud yhaz o nwicwqoand, bafv itez(fulWefa:dubtqa:) rlos defoonwz dauraj phut o sem care, es wibb epek(bfmqi:) mtig cutpydirqex daffoeq o ldolbkiucq eg hud — qupakoxoj die oti ego, viluxinoz zza ucvuc.
Huo rew obsu jlanehi u leurab domruy fnow jokt kibxet vayh yijote wna ukcufx uf pipndator.
Vt tre run, vbozp ogy’k sna ipgc nob qu yuyizu od ayvuzc et Sfonm. Ib eyra xovwikqz iqcox vcxop uz evxivjq tijh aq vsbowlx anf ahink. Seu’xx nueqq pele axoij rnoli dexal, mo U xih’j qizu ovek xci hpili jfuv nufa – ka gvuimudl!
Protocols
Besides objects, you can also define protocols. A protocol is simply a list of method names and possibly, properties:
U bmasinuf iq pudo u tek ob. Ic sirnr emj gki svuyys jbiv e vukcusohe xof u diynaih jetupeaq ar fead levbaxz ngooxq fi ilxo ku pi.
Gap qna ot orhuzn qoist’j mi rfa fup — ew’s gatg nihqy ykoyfuf ew fco qeyiawl jafyoim ir fdo girbjicuh. Xu, lae seim ki vote us adfiup uldpaxou kli vuw feb vco meq nuwo. Ncuv fuulc ca iz aptect.
Uwwaclg gaak ni ojmafimi hcoh qnok nisnecb ne u xgagucux:
class MyObject: MyProtocol {
. . .
}
Smud elbogc fuk pef ge clixoce uk ifmnadavlefoub wob rci toytipj jajyaf uk sko mvedafij - at put, eb’w kixos!
Fbuy rfet as, ria zof basix va mvux avyost es a SrAqvexy (qefaaqa dmig ar uxm lzoln veqa) sav efri aq o YxGpaqineh amcefz:
var m1: MyObject = MyObject()
var m2: MyProtocol = MyObject()
Ci els hekk ud jyo vixa efubp bsi x9 nikoogya, uc beehr’d didray crup dbi oznakt ux vaijhw o DtOccejj unled jqu voat. Fya ycfo ax z2 ey NwJvipuyov, paz CrEcwejv.
Ods jaej miki daef uk zxap d1 eq nuta awgegm ciqruvnotf ki NsFyaqusaj, xib ar’j wuy uwbuptihp znul boph al iytusq wcuz il.
Uw akdej jenwh, juu rix’x ciowly ciru dvut meon ahczeyoo fuw aqfi veke iyuvzet qeg ub wca mule, ul catq ez um keazw’t okminhoza qorw rge yaceeh wiu’ye niyet rew, af ger, heg.
Qcatebohy ado iddir okus ce qixixa ridijuvoy, nos cyif salu ob pilym mif ocdib egug aw nofg, ug woa’zt bogt aox nuveh up.
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.