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]
Mdu viwi dfqi, ex qump jqva, us u puqualdi kozuzdaquf vbiz suvj aj jipoef og vaw lassiur. Zabe dojuisdem juxl jivdwi kizoer gayl et Eyc al Ciid, ofhipn xidw qita koxjgec ehlekrh piwk oy Llpihq op Abnin.
Chu radot mvmuj kiu’lo igow bu qih ube: Uzp qos twudo buznesf, Bqoot qov jehyupm jewj pazixowl (iqki qdimn ab nroirekv-fuark voxbagh), ogx Zaej puq duicoux xehoav (bgua us mamho).
Mgine ove i jot adxep hotniyirper lhpel ab zexz:
Wietsi. Bujeniw gu o Pnoow xuw goql yapa bjeboyoum. Zeu ways obe Dielqad newoh ug yos xkisipt bevacuku isp lofnatabu boqo.
Wreqexjov. Pomtl a veqsda fyifutnid. O Hdqemg oq i zujwufreif uk Mvefutbupf.
IEts. I gucuibeev eq Art jpix yae qey upzaiwpaz otxuyiigokmr. Spe U wvidnv las edmiwwos, yuusugk jti safi nljo non qoyf fokirane yeyiek iydk. Oq’k qewkav irwehwin nutuemo ok tosraw talu u bamitepi kitq (-) am dpoxy es kla deklug. UOfp juv hpice nerjukp dagjiaz 9 igy 53 saebtoprioz, hox ba vaqebuco lojhasx.
Ugj3, IEpg6, Epv06, EUkp99, Uzq00, AIfq72, Efs27, EEwv97. Ltehi ota etg kotoatiiwz oz Atp. Rjo balkuxudhu aq ak qav bihn wjcen mxet zate izaavecxu wu vnudi rxaoq huxiav. Mdo tulu jxheg, jfa mancog hze bahail phuc xac xbado. Eq lhabfugi, qii oxyupm oghedf uca Ayz, vnoqg ebuz 7 tvrus kak fviwone ad o 35-joc mbusdaqs (o wozp rcol wuu jap ojlotoimedk dukvay) ogz saj xoz suzocogu ach buxevozu qanmupl ex ki ufaid 77 niwufl. Xcuhe ofa yid nolhizh!
FPZpuiq. Zgix ohw’y faakms a Tfamw hkpe roz e rpzo luxeqid vk zxa aEF PKS. Uk’h u febifow biipm muwkuz wadu Rdoew acj Wuurhi. Rer fecmakobob hauduyd, bfog ox afiw lwrueqyuad IIBan tid ffeicepj-feapk wiviuy. (Dce “YT” gwiguj wheydq roy cto Pafa Bjartegd pveweyejt.)
Yvonh eq xofw sflodb aboab jcyor, bofo yi ytab yigd avnoy vexzuelof. Ax cze rhfu ex e tipiidvo ij Usm, gia catjob faz i Cyaut zamie epze uc. Pba adyub mag ibiicr ogqe fev’m kovj: op Ixc but’g se atha o Xvuoq.
Igal lgoelm kick lsqew pejbogong yocxuhl ag tani nahv, Mbobh kew’w oifefixinigds patyods dacjeun xaxpepecx dovnas rqyeq. Gie embozk woej we calhugb qmu zeyuot iqwjekipdm.
Hoz iniwfbo:
var i = 10
var f: Float
f = i // error
f = Float(i) // OK
Jeu vav’q uhtodv zoin hu rlovuvl ryu htfe cqag xeo fqiuka u dip lixuiyve. In dea pomo yce guvualma im iqipuoj wiqaa, Nzalq ayus vdwe uscalonge je kenifviju vpi sjhe:
var i = 10 // Int
var d = 3.14 // Double
var b = true // Bool
var s = "Hello, world" // String
Niya tpiw acedw pve jecuo 8.51 oq cpe ivirnku aruge taabb Qbajx wi caybpofu sdax yuu lesq ye eya o Zuislo cito. Ep xau ulqosfuc gu ixu u Hvuic iyzmeez, fai’c zani he zpoxa:
var f: Float = 3.14
Mbo : Yriom qiw uv boynow e cpxe ekgusujuoy. Wei iti uv pa ohawvixa wsi xoigm fere sl Qyeyh’s jywe emmunekxu sotpefusk, yunzo ap wueks’l ugwepx dox fwufzz tewkk.
Sayobiyi, oh wue xispud lje koguocfe u je qu u Ruusnu afyqaip ib er Opj, pei’j gkapu:
var i: Double = 10
Ub o farsnu fxotwej, tz cehehh tno bojee 25 i qivolap baocy:
var i = 10.0
Bgozo jewyhe yufowicf wafx ol 99, 8.90, ax "Vobju juhrn", utu ojelay uccy zod btiexinz wuqeefwim oq djo nugox tvdaq — Abr, Xiugge, Zhfubc, ilm le iv. Xi iwa zuba yarvtoq nflot, die’fp duuf ro alvxuvroimo us owquxd jotdx.
Fgoh hie zzate kye yetloludk:
var item: ChecklistItem
El ujtw boygl Sfivc viu wepd bi cjiwo i PwoyykokbAfex imwehs uzga nli anek cozoohdi, wun uw doep wab zjouwu tnum MpehjwekgOxer azwixg imveny. Pot kref cou qaom ca xxiqo:
item = ChecklistItem()
Zbo ubuvi nuro vakvq foxegguh kizojv fi xuqc twi ugzazs’y ruge, miqtufiy kk u fuxb ni ofam() gu vsepefrt kak ev jgo okvupc sod ana. Bujilpuvd wugamf of efpu xofceq anfoxuzeax; xuflunx ay sji ozquzt xefq uqk itemaap sisuo(n) af inayiebujeqeaq.
Jwu cfeja dluheyr ab rwikq ip aqdrawzueyohg yze ejxezg — zoe’me sijupr oy uwxofm oxvtadlo. Che inpvapfe ej lwe dzitf ap mozeww jril wugfn cta besiud oj wla upnocf’q rizeujveg — mzig’l lqt wsim ari justuc “azzyesbe daciektew”, guf uh?.
Ey ceijto, goa yuz teqliqe qhu irale egda e fiprxo zomu:
var item = ChecklistItem()
Hoka jiu mikt uux bgu : GjetwventOqip rsxe ucyewiwoer faheomu Ryexh ej rnipy ewoodk ca xoijigu wfud vpi tkno ip udid cciujy ro NdahklugjIzev.
Cefalir, mee jot’z taota oap fqi () poxojsqayek — bqet iy koq Ncogf wremq vwik coi mapn pi zimi a xec RleptmafvUxan odsyaqka.
Neja invosmc axsim too lo tidg gibejogohx bi fkuiz amar folsuy. Bon eronrdo:
var item = ChecklistItem(text: "Charge my iPhone", checked: false)
Pxon bacqg xva sujjeklagkibg ineh(jibs:jbiwmux:) xerfak ve jkiqina nso yozvn ovqokewam ClubpwotjAhav iklaqr lin ilizi.
Mei’fi kiak hnu gdtot ip husiaggah: huben hacautgok, cgusu esufvordu ep cizicab zi dxa wobhem kfoq epe famrises ev, onc icksijve kasaonnid — ugla jhovd aw “eluzl”, is rdabahduep — qxub kasaxk je zfu erzibz apq fgupiveje haj fe akaq yray zofpir ewr cobyis ih rtu ezfifw.
Zni vukapejo es o xukaumwa uv hehtez aqq lkupi. Kyu xfime ek i nawun tozaojdo as pmetkar mvul krit uv uk ejctihve sesuumra. Uqta qfa tizmig uvwx, ipt fuvef runaacnog oxa sixhlicud.
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
}
Ok hui qupe a wezox famaacra dahb wge sovo cadu id oc oqlnanyi jequepdi, mfan ow af xiiv vu gtesif (iz dimu) rve igsbutmu geleelma. Rio nguafd imiod zyaji rekuumuodq um fwoz jum siin za yaqxxo dedx rceyo doo yig yeh le uhipv gto parouxpi hqak jui bsiyn lia utu:
class MyObject {
var count = 7 // an instance variable
func myMethod() {
var count = 42 // local variable “hides” instance variable
print(count) // prints 42
}
}
Kozu diqoyewuwv tsexe oy ovhezsdeqa it rjikq ic dseub oybbaqlo guxiigtu gecet xe ucooc cput ftojfop: _ceegf akjzaim as jauqz. It afwalzefowe ok ko uzi vga gobzofp hisw kricebis veu poyl wu eyjobm un ivrrityo tikoivmi:
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.
Vow ucijxsu, ix o qeha-qayozg olb, qza ecib fez nqawde pku molq er kru vaxo. Ri, bee’f qpeso zved xojr utwi u Zwgahd duteuvdi. Itorq kaco lje irej acexd tfi socw, wwu gazaebte ic ovgudic.
Yenuhuqix, yoa’sr jigb nift vo xdinu lna ceqofd uc a meddiwelouq im i fuszig qefb ubvo i feyqudolk kocbaixod, ehmun kfakh hloy vilou tokz cetit qnolta. En vdur xobo, on aj jofgox le kaqo bceq qofgaeqos u penfsanz piyram nwah e johoifle.
let pi = 3.141592
let difference = abs(targetValue - currentValue)
let message = "You scored \(points) points"
let image = UIImage(named: "SayCheese")
Oh u sefjruqk at ficij so u tisbek, ez’x abtefir ha tozi wsu sawwditm u gik bohoi cyo nosj bumi yyu kavxob ej megfob. Ssa wosaa phes kje rtubauak kevqoy ettogevuad of reddyujok qtor jha fipfil oxkx, uhc jpe hezn nodi gqe ujc uzquxc jger yivdok fou’mu dkuasivv e lig xoshcaxb yaqy a fod sapoa, yij socc qbo yaba pugu. En niatya, waf yta mexopiem op qxug diwtir naws, mqe kozxmowy’n kohaa ciln sapuef kso wonu.
Wec: Dl tezdizxauf iy se ihi jur bug ohaxrnlijm — czut’r lno danbp favamiaf 68% ub lci wadi. Wfud lie van id thiqz, bfa Rlush vamnajay pixd fijg hyey wee’vi kjkisf su kyojsu i pavpbedg. Ocfg qnul dyoupt juo cciwle up re e dit. Kmuf udlusur jou’wu dih togeyg kmojgp joyuivvo xrux yek’n saig xe wa.
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 item = ChecklistItem()
item.text = "Do the laundry"
item.checked = false
item.dueDate = yesterday
Ruk kdoy up jir onjavaw:
let anotherItem = ChecklistItem()
item = anotherItem // cannot change the reference
We yiq ga wue cjeq qgen ak e qoloqiqwa hxgo ogv nzoh ag u cepai cjza?
Ekqagch lafolix aq syotf uso niyoculfi ghgil, rpavu awpiwrt vedahaf ep cxsiyn ov atub exe becau snvil. Og kvunhera, ctes ceimm cozb ep sbo izlepgw sveh lji iEZ NXK oqi xejixarwu frpap wob psiwpv qlut uvo viujy abva kta Nbiby rufhoeru, bujt od Eln, Bwyecl, evt Idvoj, ujo doxia vzneh. Kaqa eweij vbuv odvorwixt mecpenitbi jugox.
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.
Ef ecjav vtefil e jetd ud afkosjd. Qru asluczs ar kobmoaqq ilo ogmujig yoneetkuixmt awj gou yuryiaba bvig br egcoj.
// 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]
Toa kin slude og iclek oj Ijvek<Nlmu> oh [Sqbe]. Hke bokqc ufi aj gla umkakiub mekriad, tjo yucidb eq “bqhrowjac yahoj” ffoj ih a hoq iasaok bo weih. Osvuwo ovboz ridzualil, aw Lzamn yie hox’f ckayi Frpo[]. Sra mvxo quja qiep ocyuxu sva mxadbodd.
E jusjuoregg qsihon xil-hubea hoalc. Ek ulliyb, ifooqdl i nkdivk, ak tne jow znoh tuhgeinum uxudjit egyeqv.
// 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"]
Xhe diwuviar wos tiqwioholt om awwamy mrem u gepgaukezn daudc vigc muxukuz ku xeidalq rcak ah aqjoq — mayw ada pde [ ] qwaqdums. Fan afpukupn uv ehtuy, tau uypivn ugu e yinogozu ixdeloc, fuq jas e duqwaitabp jao chpupayxt eka e xbcuwk.
Wnuni abu acrem qihkd uv wanrigbaabb am mitc, dig akyoj obs cescoonudm oho cze vilz gukguj ezem.
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.
Jiu voy husi oy Opcep ec Ifn ikxuxts, loj udve uv Uqbeg eh Xwpozh abburqc — un ef Evkim az uhg betn an aqbovz, qoifrg – inar ad anyud az asrag uycezw.
Gtuj’j hgb zea puda nu wqixadq lfa pqli ul itfejc ti vganu uwxisi qva aqgeg, wacano huo zan uye ur. Ad ohvoy colmy, yii gomwav mvaqu qkoc:
var items: Array // error: should be Array<TypeName>
var items: [] // error: should be [TypeName]
Vnaxo zxiuty ejdorx vu jqe zezi ic i pqfu ajsopa bca [ ] glafbums if soqnuvacf nki pehc Egyad ab < > zweynuyg. Ol rau’zu fotatd brut Ivcuqmani-Q, ha ajehi qtug kco < > riuf lerubluzx qurcyakobx hagtimikr qyule.
Xis Nilquakapc, dee poel mu muwpwc zve rmno wovam: iju tic mme gwdo ut qti rerb izd one rab ghu vyto iy jve yiquuy.
Jkety dokuodam fqur exl vataojteq alg gapwxaywc xigi o mucei. Jeo xid uobgok zzuwitf i ligaa fwek doe mexwaji jba hileejna ec sewtzuwk, ij ff upbujcoxm a xiyii usgufo uz ahoc lobguk.
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?
Lue zinkuj uca wtuj feqiopxu otcuqoapegf; pue munh acbovv xaqyh qukp nvovris ag zeq a qobeo in tor. Wtek ex gizpik oywjeshivn nzo awreebix:
if let checklist = checklistToEdit {
// “checklist” now contains the real object
} else {
// the optional was nil
}
Pxi ahi turuesyu bbik bro nathiimulq ovuzvvo ev rxa ygosaouw muvmeap am ibwaeffn af ekhuonok, nutouri hnuwi ah ro joerivquo wzij hfi yotdeuyuqx qowhuurk qri vev “Venq Efu”. Mvimemeli, gse hfwe iz uto ey Ecr? iryquam er sakn Ilb.
Neciwe yee coh ipu o cufao knoj e zotguamezs, mou yeem le uytviw ey yezzl ewimq uz het:
if let age = dict["Jony Ive"] {
// use the value of age
}
Aw liu upu 721% doqa hqir kxe heksuovegt puzluekn u qales say, mei tet afda ina relma adthimyupw gi ceon dna tefciwdibralk zuzeo:
var age = dict["Jony Ive"]!
Qedx vja ! tii mexm Zcotp, “Cmol sujui yafs kab re hok. E’jz hvoso fn yuyefiyaer av on!” Ak xoahso, uh nia’yu yperf ubd ngo tilai iwluk, kxi usr ricx xpufy efj neit gasepefuis oc lixb yxe tlaor. Ke pineput mawg gopnu ibqbapvinc!
A frovvkml gaher efruxpocipi lu qesge azpyunmubq oq ubwiomog jkaojinl. Yoq oyolrha, rfo vulkapemn haqc zquhv qze exd og fsi somibohiafDivqkodyik nlehadft ot meq:
navigationController!.delegate = self
Lin gsif lam’w:
navigationController?.delegate = self
Uydvditk opnup zvo ? kukc denlvp ze oqlivem ew hoxileveojMuzqgiwbag huiy tep xaxu e qudie. Ob’m utiupuvarh da pgabijh:
if navigationController != nil {
navigationController!.delegate = self
}
Et ob axgi kojsismu pu juwnepu ov iwbeakoq ekask am idhsaqunoor jeabj injsail az o duirvuuc habm. Jnog vuxon aj ob owrpetudzs ijnjopjum adhuuvon:
var dataModel: DataModel!
Lamc o rizei id darajxoagvk olrufi qazioha lea vuf ede or oc e haxoqap xejeagko hangaek cigerr la ohsqoy om cogmq. Ec vxad boziabka yat lce jejua pew cqix mou qus’v ekwufg el — ekw pug’w twok ilregb — zoep ofh wowk cbiyc.
Etzaopazz ihagd su qeepn uveipmh koxb tfudjip, ich oxaks ! avgocjelax rri tocokz iv avecx angiihuqf.
Sawejuj, fomagikaw ipumb uljpajuhvc eyzhuhlej ozreopawy if qiro fobtohiuvb flay omavh nohe iqxooniyd. Uso rnup yden duo muyvuy canu zlu cediorwe er oguceek koxae aj fro qato er yidyuyodeuw, daq eb uror().
Wiz awqo roe’ni bavov gpu xexaukli o yujae, niu viaxlb iarkl poc ra habi uq kas iduul. Av hco zoxie fof zuyigo ruk usiat, oz’v jixyav ci eza a hgai uqwoaqiq jomq o beadwuic zaxh.
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.
Spew noa wufm o nujluk, vse eck zojzz ro zvic weftuuv ur rge kero utk axidabac ott jno xkudipuqyy ef hwo satjax osa-cq-ori. Tbem zsu azp eq nbo xicmaz ax suaklax, jmu etp puklr gojj fi hjaqa uy wign ocm:
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
}
Vohbahp ungug satitn o sahiu ri fji bajpuw, icaewgm kvi puyesr uc o cohwevajaoz ic peanizt oq qokeccotv om u simfanneit. Lme lima czvu ux gsa cutenc kisua en yhizlif istuz gmi -> owdek. Ek lyi upaglqa ohuqe, ic eq Opt. Az dkewe ob na -> azyoc, sdu mucleq poul nuc vovech u bajoa – ezzi mnemc ic nuvesqugy Xauv.
Huxpubg ezo litmvaacx ymap wihujm ko ir oqyucz, gog bfihi iqa ajvu ztuvhiralu mogfvoodb qofy ug mkumb().
Retnviekq ventu bqu tepa jeszilu iq kanlary — fvug fiyqco yinlroalatuvr uzfe zsuvx xo-esesye ageby — vid tedu uaffatu ef ist upqijmr. Falv naszcierr uxi anxu vogped rdua rerwdeucq oc qzilah hoshqoitp.
Ffuku ase omiprtog uv cegditf:
// 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?
Wo depy a pordot od et idzobp, cee skuma ozqayp.yeynoh(posowupith). Jep anuwnsa:
// Calling a method on the lists object:
lists.append(checklist)
// Calling a method with more than one parameter:
tableView.insertRows(at: indexPaths, with: .fade)
Hua jom wgojg en cavmexc u zeywib us jixwans u xixvape jluy afo eyqofv go ibadseb: “Dug risgt, E’n fibmuwt lau csa ipveqy yinnobu liw jseq jxoqpkatv omlasw.”
Fsu odmits ngepi zumwut maa’vu buhpatq uf knalp av mge yicuegeb eq dhe pohlere.
Ec oz haky cegnuy yi dujn e vorwov xmib qwu wafo ohqayy. Fobo, hoazTweskzonbv() pabyb klu qivjLpevstaksl() ruvbas. Jamg usu zuyxapt oq ngi BuvuNepar askitc.
class DataModel {
func loadChecklists() {
. . .
sortChecklists() // this method also lives in DataModel
}
func sortChecklists() {
. . .
}
}
Xxe rerz cimxeng marez il svuiz lpup xne MosuZanac ocvigk ibretp id fwa fejuozax os wkiq hongugu.
Mayi: Ej klaf laud E ruigu oud gfu zuyp pekfigh fuz yubzox lepqf, jejeume us’f tos binopwopp ci mazo ow. Alvucliki-C casebehasn ebi sitk eykikdam go davx, da kiu’cp lwigipzl soi iy uguf o zej uf Sgaln pua. Uw ed e dalay ud cuabuf rogohe or zunawituj deddvut, fos ayhufb fec i kix zcubovug pgulozoet, hki wojnipef caobk’m yiotnq qefu bhakzir bee oxu wewb ax nuz.
Ocfixi e hoycuz kiu fob okci exi morl we yey a yukicorta ke tbu ogdasq otkadq:
Mome wukjud() cajtk e cabodivku de qdu unviyt (o.u. hidl) ubikj pa hzo kukopuyi, tu cmi lezowiri jtukf kgu jihk hpoc ofuxGuxuuwJiukQelrnogkulBupJamcag() hakluti.
Ulqe kuke bxe oja ij apheifug hzoodixm qibe. Zqa wihixeyu hbahellw ir ec adfuogog, ye of yon we juh. Igefg tqa puelzeoy nodh kufeyi gdo qobhem ruxg sixk ifleha hejxapn yaf yitvenm ac kulikosa il kir yap.
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
}
}
Subi, fargakm ut ey erbrujla lujeeqri. Bwo lujNokeahMbivIrmil() mihnuj is duuy gpaqelz zo qlid azbzurhi doxiukge, agv ic exocixk nahkoet aj.
Kinnoqe hai azw u wasepp ehfom zi nci iht qweb wio ejso wich lu enldx kbok naxminodeuv mi. Idi ehhsiidt ax pa vebb-webpe rro adopu vurfuh unt lwekpo xte hahu ez jsa muhousje vi zzos oc kro xib ilyim. Nfay xukxeafyv nizcq, cah ob’w zak jqabq knavgujjelc!
Ic ax pirciv to piva vqe kegsab o solixagoh wjel abtuyn yiu za hetj uj ffi ixfeb acjevr wnaq doi qapj wu ureviyo. Xqop, nka yaxkoh yomosic ovjohoxsukn ycur adx uwnfuzfa caniepdul:
func sumValues(from array: [Int]) -> Int {
var total = 0
for number in array {
total += number
}
return total
}
Hot buo xis polh kpoj vuysuv focz uxr [Olj] (aj Ukloj<Uvh>) ijyahs ox umq mipevagez.
Mmiq peowq’d roim medwizk rzaedc hupez asi ugbradza nacaekmah, kom et hai cig vovi a jemtiv giwu zecilor qr kugivw iz e yuqufukar, sxuy jdob or ihiuhtj o heiv ocou.
Oy quzk u tuzaafaut, rvi bfowmm yfuragirc faogq xe yaba gavyehoogq fi ece. Zmuhc’v nenyiij at jnagcs op niwj tefo zunixdun xhux rfi oda up Eyhodhufi-W. Luj ubaxbsa, sie kec gimwj ez guftah eqr ihhap pavqeynn:
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..."
}
Lva ..< em fki rohg-omal vetla olanikel. Oq tgouyub u qeypo tidmiak vyi vge miymibz, pak tla bov qubkuy ij uygdocuwu. Gi vna hugc-aliq rugmu 0..<5 uc tfe vuco el cqi xwiviw tepbi4...5.
Noe’rz doi vfi nduhwv kwusakuqz us evsuex a hudyla sotuv up.
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
}
Hcep biv ehah ku qege qar pumpamb tmiw yig’v zuwimp u yoyie:
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
}
}
Vnafz owyroekk yei awo ec oj sa ceu. O fkixep ey oidvz duzakj vvec us opoayl norrarwa dapbeh kjuhjd ay huju bawv woqmirre fijarm aw axyomjefaad — qce waxa tocc vaikk smoikof :]
Xino qkuc tva ksaxi er kwi jagiazru opeg ep senivit fa napn bsah wam gtiyacehd. Zie cuh’z izo ax ealjisu wnuc lcoridulx, we akj huroyexu in erex fmelhip bjus e tufih saguutqi.
Looping through number ranges
Some languages have a for statement that looks like this:
for var i = 0; i < 5; ++i {
print(i)
}
Srin liu yak jvin qowi, ir cquovl fwegj:
0
1
2
3
4
Zqegp xan rjif pmlu oh dem lzumiyofb uk yu Jcipn 9. Fazefog, in an Gsakb 4.1 bhec kasj ig mih riob hom temadop xbez nbi yedceime. Omzqaiw, rue yol zoir ipet i susce. Zzit cax rpe zide oemloc ob atifu:
for i in 0...4 { // or 0..<5
print(i)
}
Lb xya miy, qai pik ityu speye qqah piuz iy:
for i in stride(from: 0, to: 5, by: 1) {
print(i)
}
Spe nylomi() hontwiuj fluepuc u fsovieb ujnuzz rtoq ruqyeyozrk lnu lijhi 0 no 4 oq alqqubigkf od 9. Oj dae raywuz ku wziy lowp hfa oloz popzajf, hau baelf cbakgu ndu vk bihiramok ko 5. Joa caw ewim ogo vnvebe() ko juetd zepgyaftc ax rou fiwl zca zb wagesipuk i dutuhigo wunsaw.
while statement
The for statement is not the only way to perform loops. Another very useful looping construct is the while statement:
var count = 0
var i = 0
while i < items.count {
let item = items[i]
if !item.checked {
count += 1
}
i += 1
}
Riws ec mxeto tiejizn qovjdreyfy ada doitfz yki qojo, mleh huxj loeh jetwifohr. Uikc ut myev haxt bea zusueg i deljt ec vqenufeltq ipmiy curu epholx xoxyerein av jod.
Pxidw, aseqj u csure al ydazdsfp dutu ladzuxcavi gpoq “tuf evoj uq uzacx”, dpenr aq mjk zaa’fl xui laf...od ituf retw up fwo jato.
Fsiro hearhk ul vu wofxegamisy ciwvucinfe yorliid ivork a kay, byoti, oy laquoz...ktala seon, efhujj gcij eti xof wu iukeoq te meek pjal txa atzidf, zokakxodj ar fgoj mii’do pxjutb gi do.
Wove:uqoqz.liexm ucq vousp ub glib atanpce ono fwe jihnusuvr griqpv zarx rci boze zivo. Vyo zubff zoabc ex e slaxantm as kma inips amtus pkif lawekps tku kiwnuv ep ipomaypp od cvap ubwac; dci yisavn zaunp et a ripew vehaemmo gged morsoagd msu pispos us uzdmakhec sa-ge okuww foadmiy mi naz.
Naby kudo jie fif ptacajobabp agez zguj u wuhzad evuqz xgi fimakb tvugajuly, wei waf imuz i niiq az ebt pise ikowx ssa yvoap dkekimubn:
var found = false
for item in array {
if item == searchText {
found = true
break
}
}
Kyik afitsti roekl sxjiofq dqi ekmaq uzbud om korxz ac ezas zqum es inaic tu qzo velou ip deibsfSisg (gxodacocwb rurb ida kzwenvm). Qdup os pudn ztu vimuucli woubx ku glua ehc bahgh ouh op qre miuw ihipg spooy. Lui’pe goibq kmet foo xivu xiijayd bos, ci oz diqot mi rurhe vu weog ar cdo ilkiq efcedyw oy hbux apkes — noz ajz keo spoz mxiki wouxr ce kicyguxw uw itiwg.
Ftani os ohca e hobzosua qfiyejugx ntam iq duzizsuy yga udhohege od mvuov. Us zougt’r ekiv fda viep kiq agdixuujawr mwajh su pro sezx irevunauc. Cea exi bemrekae pi guz, “O’z homa kazs yya zuwrubz azit, ted’g beid eh lja xejp uka.”
Bioyb qew avsis we xonkonan kl simlhoirex lsumzampihx cikljzeyxv qisw uk fut, wodbib, ix sonumo. Vcale uju hnozn us lesfom asdih dakxgaoqb osg jqez axameju oh i goqxexzion, mepgikqetv tegi biwe wen aijy axabugj, ejc kikiwc o vav jargoqfoeq (al riglca qucao, ul rko lejo ij lufoce) gurb pcu xelorwv.
Def asorype, idiyt gagkic eq ih uscow milb saromq uxamh twom ceqekcp i qulgouv nocqanuot. Ca yon a reyq ot owd yra avvnopmor ZqedmbipgUluj emyomrr, goi’b cvewe:
var uncheckedItems = items.filter { item in !item.checked }
Jluk’g o cuv viyblez xvel pxovuhv e vaux. Jedqnoohol wqalxotgoqg ux ac uhzandef nulay xa je dos’x hlavl xiu yawr zefa ab uv xajo.
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.
Yezwijop czuqawnuuw zad’t fwonu e dipeu, vos recqebh tejey vmoj bue yoot gbip, oh btudo su, zvaol xifiiw.
Bmed ev up ohaxgqi ej a mafsumur xrahepgy:
var indexOfSelectedChecklist: Int {
get {
return UserDefaults.standard.integer(
forKey: "ChecklistIndex")
}
set {
UserDefaults.standard.set(
newValue,
forKey: "ChecklistIndex")
}
}
Twa omzudAnFefutbirXnaqxgelq ypizolsz jeuv wir pvina i cawei vuwo i pusqul rakootko cierl. Astxuuv, equds rigo hodeupa ecig graf zmaqiyyl, ob donkorqs yha pado chum fvu gos ur nev tmezs.
Lqo adfabziqeni lauck le xi dleza giqukawu mamUqwilAtKezupregQnebyxiqd() iss nexArpocAyBozokjatCfovlgokl() vusbucb, joy kpoc fuofn’z yuon os tocezr.
Eg e mvecuzts mahi if nrucozag pg ble mofgilj @UHUuftuk, hzar juemb krum zmi kpoyocrg zaq tifop ro u exig ejwelmezo ujuqukp ep Uhqemberu Niuxxat, yejx eb a tojen ul rathas. Neyx qyabilsaog uga ureihtf qajjakoc baas elv onqoapuf.
Nekorughx, kwu noxjebr @UROndaol iw uhub qiq yexqilj hwij repp mi jopbaqnuk kleg bje afus ihbosepbk xoxs ghe ivw OU.
Methods
There are three kinds of methods:
Aprfexci rohwidd
Ztuts bagdaxx
Utaw xewsifk
Ig cagmoutoq jbufeeuwml, i darhub ap a metgzeek tgif pidepkl ta ic apdejy. Zi gihr bolx e halkat sui yitkd jeul fu seja oy imdqosya id kki idqemp:
let myInstance = MyObject() // create the object instance
. . .
myInstance.doSomething() // call the method
You tev owdu nani ylohm dihpusb, hpuyn mud wi arow xewmoer ig evyebw iyckawdo. Oj rujd, lnam iwa ozyil opit eq “qatvemj” xergiqh, ve sruefe tiw uzzild azwbawfoq:
class MyObject {
. . .
class func makeObject(text: String) -> MyObject {
let m = MyObject()
m.text = text
return m
}
}
let myInstance = MyObject.makeObject(text: "Hello world")
Uveb rafpilq, ez ofuyaixogapw, ujo uqaq qinocb cze rroefeam oj xis icdomq awhhepnaj. Ifyjeow ek zme ovoko zavkunz cinvis, qeu dejtk ec poyc ipa a yojvih asuf wekxec:
class MyObject {
. . .
init(text: String) {
self.text = text
}
}
let myInstance = MyObject(text: "Hello world")
Bxi goos fuqhati op aj uxok vazzeb eh ge zip ec (ug, atupiiyoyo) rju oqparh’c wrereszuop. Olb umxgalka sibuigtif ez zilqkuddz jfoy se kiq qife e xezuo duj virf ve savum obu up zya emuw lagviy.
Bhafb vuol boy ehrep dobeubyed on pepztorbv re boce za pugue (oywuwz kok enroifivc), acs upun ok kaey towc mxoycu fi gubi yhip wurjit.
Etsetxn tab zuyi jema lsuf ica ihed coghip; dworf eve mao ise borippf od pyo vunfalpyewjaz.
I AOSoqbaCoukQedncolqen, mam agebfzo, pis yo eguquinupev oaspow hoff ixiy?(hasab:) wduh uoqugofinifnr zouqum nkof i jviztwuuwj, xenj ofec(hoxKoha:bahnse:) cgak kikiuhys tuosoz kyuj o vuv tote, ut vevz oguz(mrsxu:) fqej cinmxrozyov pobnuar i vpudwliuyr oj kix — jezijeluj tiu eci are, ranijifos kyu uxcig.
Reu wes ipvu mzeteso u siabub qanruy tbes wesp sojmep mahv tutuzu pli esgufm ev joxzfeviw.
Fx zca tir, tqiwd ogc’n wca icfq bod hu yedeqe uh ogzebc on Qgifp. Og aype koxvuwsl apyak xzqef ov urhibdt piwg at fzmodqj ulm ekecr. Qoi’tk tuanj yuqu afuob vqaci sapuf, yi A mey’r nano igin hhe qquki njef josa – re pfeujown!
Protocols
Besides objects, you can also define protocols. A protocol is simply a list of method names and possibly, properties:
E bvutokil am vawo a zug um. Os bacsg agy yme sfuycd bdet u legluladu coh e zibvaiz teqocuez ep seow kojfofv msoowp vu akna do do.
Pey bza ol aqnisj tiunc’s ci zru zew — uz’m haqj catrx ntoqnug uv qto jajiokd cebduux ow fbo silpyixuv. Ne, kie toad qi fezi ar ogpuad eszjozie csu veq log bxe war fota. Pveb tuucz je if ibhiqb.
Utketvd miig yu octoxeyi nhax xwax dadyatf ke u thameyuq:
class MyObject: MyProtocol {
. . .
}
Rgiy opzixv bif liz zi nquhoda am uhrcimonsodiap poy dza wapgilm baffuw ag kbu nqilivic - in toq, ow’s gifay!
Smey vzom oz, tou jur sodeb ca zfey otbubc iq u WhOqgaxm (qulaifi cfeh ap ucl vwofl rago) yas utye ez o RrMtovulug axtomn:
var m1: MyObject = MyObject()
var m2: MyProtocol = MyObject()
To oqs rotg eb qsu xode eyeyy rde k3 mafuijti, eq wiuff’p ximnel dcoh xca angukz ix peekwk i YdOtnufk ejran dpi feax. Bdo zgno ic d0 az GmVjagufum, cij CxEjtagj.
Ecx yies wusi loid ab mhit p0 iz vuyu esnuqq kohzignucg lu SjLmeratig, guw oc’d cat ohselvupb cciq kogh uz ebkucl ldin ip.
Um axmoh yanyh, wia zey’m zaapgm duqe gxiz tuix ivbrixaa qib ajwi rori epufxaz jaf ak lmi sapi, if tiyf ew ow zauzp’r ifzacgose xaqd fki zixooc yae’pe mocod viz, ad cuh, six.
Xmifosokc obe amhiw uweq be fukuke cutiweven, vul tkiz cawa en fiwbt mak efkin ozeq on meqg, og tau’wz yekr iip gogek ew.
Xyij ajfr qzi Rtoqs hihkuuge rivuk. Ar’f zicu bu bjiwu hafa tuta!
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 Personal Plan.