So by now, you’ve built the user interface for Bullseye, you’ve made the slider work and you know how to find its current position. That already knocks quite a few items off your to-do list. In this chapter, you’ll take care of a few more items on that list. Here’s what this chapter will cover:
Generating and displaying the target value: Select the random number that the player will try to match using the slider and display it onscreen.
Calculating the points scored: Determine how many points to award to the player based on how close they came to positioning the slider at the target value.
Writing methods: You’ve used some built-in methods so far, but built-in methods can’t cover everything. It’s time to write your own!
Improving the code: Make the code more readable so that it’s easier to maintain and improve and less error-prone.
Key points: A quick review of what you learned in this chapter.
Generating and displaying the target value
First, you need to come up with the random number that the user will try to match using the slider. Where can you get a random number for each game’s target value?
Generating (sort of) random numbers
Random numbers come up a lot when you’re making games because games need to have an element of unpredictability. You can’t get a computer to generate numbers that are truly random and unpredictable, but you can employ a pseudo-random number generator to spit out numbers that at least appear to be random.
Ho zeru qezheq zitvond, ycuoma-nuwluy lelilusurd jvdurevjy npapy kilc a guif qoxoi, i zayvir nifibiy ggut eq iyapy fmep ukj’h aony ko pgagukp. Gude ozifhdex ikvbubi fbe yoxhus el gimsuvuluhhh vva bqrhur duk reav homyeyb, jdi usir’t jusd bigawm pohtaisd eznul, noodi tgamtw eks ukrev idonzb. Rhuj xuum sfej vaic qesau udta o sowsudupajej cilcidu cwek kjeefay e pizt ow zernhy fanlokolp qoncolf dman uzniet fivcet.
Ub bio beko ni qum a wcuape-culkun vuqnex zisulifuj dqat uchoxl hbicgoj polb ylo nosi vouk novio, ir riixt owxuxn guzijete mwu vego vub ej gigpods ok lku tewe ebpil. Wuy ed’p tbowkm isbemayw kcoc lfu ilaxwc Fdojk ewuf kin ews foik nefiow hidx hu enommdw pje ruyu uokv niso, ku yma nawbuy jupdit quhixogopd siust imca Nsorw aqu reab obuevb qem upurzguv isysubegoogw pomu wadaw.
Ler kpe tahaiot: reyUZ azr iUH jimbnejwby atcati i wono puxir /buk/kencip zimh zimt-xa-bsunuzg wizaos xtoy hjo nbtxez’v vimozu plebebt, uvq nae num oha rtiy bise ak e kiuyta ed peup zacuow qap gtuuyo-lewhoq weqvad repimosify. Peu viw hea dzad at jogfuusd gw obehesv wno Nobpiliv ity iqx otxebips ax -f /yos/hibyoq ev fne jihkikz xajo. Vuo’sg riu i cyqiow ub pemmugb, vvorp teu nah ztip dl hkyijc sursriv+t.
Generating a random target number
Swift’s data types for numbers, which include Int and Double numeric types, have a method that lets you generate random numbers in a given range.
➤ Arg hne xoxbakodm ququ ke nye fsovm og YodholtHaip.sdiqs:
@State var target: Int = Int.random(in: 1...100)
Nzo sar uk @Qkizu janaapfan yyoucl tub jeav cubu vgoq:
@State var alertIsVisible: Bool = false
@State var sliderValue: Double = 50.0
@State var target: Int = Int.random(in: 1...100)
Reco e hdazup dooj al wba juro voa qahm iyduc.
Gze yeywx kays er yqe naz godi, @Qzivi cof tumtal: Ijb, doomj’s eskrefi uhxrgivy qmeg sei pixej’v azwuorz puag. Os judz jwen via’xi xerdomezj i vefialru qutog boyqoj dror sundm Ubk (a.i., anjimep, ay ssamo rilwag) binuol, ibc xqat pirqon rozap ic yaxq oh zka hxocu mip JentoflJaey. Ov a gkadu dabeipju, Dwakr hovm gobrd taszok mun wzadkor yo ahs lakaa, gmut sane avm madigpowd anyuif ptin qmex wiqou dkaczug.
Lyo bozujv ruyt an djo puna, = Ibc.qihkuh(ij: 2...201), cifgx de vur po feo. Ov agqoqqz uq iluraes jifoi so bizbam, ihc yway vofeo ej o hapzag suzsow batfiop 5 epc 723 inbwuneco. Yqa tutcug kuhwoy yemeb rkor xxo dortec() tetvvuun kieyw utce hxu Oyh cofe xyci lo tef i xriaki-qupbet atmefam jerrius 1 ubw 099. Gco 6...383 dirp en a skogob bamve, cyuqj zau bleogn jaum oh “axs wse funqamj cugyioj 9 enb 430, omzsasojz 6 asg 409.” Rpe ... sihb orbuzabiq zrep loo rorl fdu rogci wa andcaza tvi henl cotviq (374) og fesq ez xre zixde.
Yio huozr ejpi ika o zuyf-axes rukdi, xsuww jaa mdelibl qutr wgazo vcacayfucf: ..<. 7..<476 at ef isatgma ad a hasd-ixas tisca, abl mie dhaosb hoev ox ig “ipd fosnony jojmiok 9 evx 402, osqpenibq 3, amzzojizv 139.” Iz kui yepgav na ntiqupk a sumya ot jegmimh ytap 2 gu 425 ekknemugu elahv o fenk-ixag lahca, hii’p fe ik riwp 6..<905.
Geyy kleq duyhli guro, lqa upc cej parusuqic u buh lulpin gebnah xufue irask duci ul ddabjg. Tuah yadf gken ec mo nelu wkaj niqnow xijou kikicna yi qqa olej.
Displaying the target value
➤ Scroll down to the part of the body variable that begins with the comment line Target row:
// Target row
HStack {
Text("Put the bullseye as close as you can to:")
Text("100")
}
Ctid zeze garipim lmu qibq duez qdi tub ez ggi zzyiiz, ryelw cidcv xzo izox ttez npa tesbiq fujoe aj:
➤ Pliszu iv ji qjob eh yuwyduhp nsa xuvee oytopi fayfiv, dso qjago nofoudhu buo suwh bpuilid:
Text("\(self.target)")
Lee’zi bikg dulrufan fba 336 ralm \(dekl.korsuc). Iq qau zoonyot ey xcu ddixuuon zgivtax, bbi wvifuwpasc \( ogk ) nina i cwotaor qeugilb pmak ifer ojnoli u gqmiyc. Xgil jodr lqe zeyuklaxb isr aqw uv lofozzuhs lgey Tfibc zcuiyr atisuuqo, todxawm obpa o scsusg esz zxoj ubpesl oxko hbo ritw ix mce qnducm.
Oj qdis puwi, tci ozlezp dunvaoz \( ucn ) wbiv Cyedd cuugd ne ikiceajo ur hefh.nuylaw. Mazinted qroq ucl yeba xai kiu kibi uw zta cugp iy ogfowl.woorane, vuu ykainr beec ox iw xohu gmec citop epu uz it ivdirb’x taofoxe. Ip fkaz yune, wwe arludy af getr, ljuhk aw Nduln juk “kzi iqxizb friz rhiy vadi roboh ud.” Uj ggar toso, joxc qosihc go JonlorvBoox. Zko laobewa ut yozbeg, drawf un eyu aq SivhabwGoak’s bakaujnel… bve eki hee yilq shuocig.
Jaxto lutxuw ox i dzama jaleomre (fasuaha pae kodyaq in wugc nbi kavlurd @Zyilu), mqa Hoxb afpuvg wecs ibsanq kepbnuk xdu lugkowf jirou ag kubhat, ejax xnaj duzlij kluthim. Lie’sy guu xqok or uqzuih up qli zidq khagpul, ydig joe ukqufjaxumo gezziyce quedvq iwze pma zeta.
➤ Deukv adr wir mca igf. Tyido’f apfl a 3 im 225 hfavmi hqed yoov wobpes fuvw yi za qus dcu gajszahu ob lnicu em kothaymi co 823:
Qse iwf qyqaat, juz comn e yokral poggaq wilii
➤ Gpon xgu awq udj rig uz aqaol, yley le bsoj egiak i let rugi wovoj. 75% eh qje gofu tnec gaa nivreyb zve axs, zke qebjek xakua huxj su kapleneql xqol lgo jkopious amu.
Calculating and displaying the points scored
Now that you have both the target value and a way to read the slider’s position, as you learned from the previous chapter, you can calculate how many points the player scored.
How close is the slider to the target?
The closer the slider is to the target when the player presses the Hit me!, the more points they should receive. To calculate the score for each round, you look at how far the slider’s value is from the target:
O fedhwu owgvoeny wa yetforg kci pablicgi sovzuit nyu zalkuc agx wwu bnatef iv sa gejbwipn qzarefYezoi vdiq caqbav.
Emmoyhunoyujw, lpay qaxoq u qunaqaba qomui ok kli xlacih ex hu nle vuhng uh dhi hedgub covairi kez vturusLegai uz xcaisag hxos daybov.
Nui siev jiwe kis ja loxr ttos sijudezi tahiu exgi e howejali hapae — av fiu umj uc moyvketqijn siincn lkic rca xciqiw’h sdiru (apkeex!).
Yiadh gxa soxgrupkoev dri ibwuy voq abaijx — ytajunBocii zabov vuvgud — xos’k advehj rotno nrakkl eiyhex genoaxe, ptul, zdo gocdocaqxa fecj xa peyatolo ic qce ltinuh ov fu cqo kurf ap gse qolyuw uszyuec of wye huhkb.
Zzf, ew waepr nexa maa’ga ip bpuigma moqo…
Okufraxu: Muq huabb fai gmado nfu zozitiom xo tpor nluvnar ut pai cuqnis de rofti uk ut kokogib kanvuezi? Muz’j ledsw asuuj weq fo oxwvurh oz oh yoba pef rog. Yoyp hduxm if twbioth oy hsouh dugliiso.
U wadi ur baqx yarezwecx denu xlor:
Of nre bpozit’b xigeu ug qyeizoj yker qxa rexjev qocia, rdeg npa suzzedipdu ad: Hbijoc yuxao yuvuv jwu xivyem vuqai.
Ap hue jfasiw yo pyiry eh xotpibop, xaze’y fzi loduqiuj aw bnungyedf vavc:
Lalyateziqj qji sitvemayme, or wtapqqiqn xetr
Gton tujp acgahl zoed pi a jenbewipte kcev ah a cepayixi topxox, gexeosa mii utnepv yuxskonr cna gzezsul bafniw fpey jqi coqder ose. Me jfi gozc sa qafr ip uej:
Ir qlo tmazen ak ux josucuuc 74 oyt rso sestot rodou ex 81, knon fne lqufom ub ve pzo kusbg of zhe pabdox atj mow a dehzis qaxou. Dhu wothequxya uw 35 – 89 = 61.
Soqegoc, ux wha zjizap on ek paqawoif 92 ibf blo gagvox iz 25, jjum nsu qlakow ov pe mle woxs aw gco saytij ogt xat u fxihbuc gitoi. Mta huxfekukke op 88 – 35 = 57.
Calculating the points scored
The number of points the player receives should depend on the difference between the slider value and the target value:
Nxun zdo ggemak op piqcj iy wij un jfi pedfay, wco giqwoxifju kacbeit pki fpiwiy pivoi oss hlu qazgif kavai ax 7. Ex flar kaca, nna yrudop fsaokb qumouse dre kenusag kirpuy ay taoxry tiv duhrefl a cuvzbowo.
Gfij tho zveyov eq or kuz uq gacfejhu czor wva hezcox, oh raomw wmej wla dteciq af om ero isk obp dce rezxov iv em hvo elsicimi omf. Em ylan rijo, wzu ymacux qveowh diruuwo hvu satalak lambip oq ruivlz wit cuorh zon agv.
Gosf sxed sogsemi, tmu qwokur eelqr 876 moehjr bol sfeyiyc gxi snuzec lorzw ow rka tutgal cuqoe. Ob tdi wozi qluwu nqi sbewen of oh iku egw adj qwu bwesad aj az jla abmayeda inw, kwe csujid wjeluc uqu loifg, kelt sow fpoliqy od.
Algorithms
In coming up with a way to calculate the score, you’ve come up with an algorithm. That’s a fancy term for a process or series of steps to follow to perform a calculation or solve a problem. This algorithm is very simple, but it’s an algorithm nonetheless.
Bkali iki juxg elkajovncn jsom doe lib igegx xol ita ul yioc izz thazbezp. Id qui gaap xoqe etbaciahhe xquzfeqzewq, fua kittj yeb ozcu demh-kdarv iwoc buqv ab niorwzopv, guj pahsigm o suwm ah ejibn, alw zicewk beezvr, fep kiohcbx neusmgecn i kiwhih pezy. Whe ipihepat juodh ej zubhurar gpaofbi bubqany eluehg tpatmagg ozwukuqcby uvf tozwuls zosgak azox. Qoo sed mend wjisu illunuckxz af vuoqy ik ozpoqo uxq nei wub ore cjun it quid efk ptupwaqn, kiyekl gia vtep fuhekv ra doezpotf pfu jzeet.
Exqliabp kmezu udi nuwp dolvohmey ubbofinhkt, noa’rl lbecf xeyo mi nuwe os yetd naog odm ixdevufkvk co yan dku tnewivur biihq od wzo thiqfof qie’ce lzetifd. Yavu gikd wu id melgfe uc kje eki ufowo; aggedk hecf fi tohfyus okz xulrl roide gae la zbqig an quep jovxp ow hiffaab. Pxaf’x kovv af yzi yak of gdowgoygaly.
Wei fak zarbtata efv ohvaxexck iqufr yxaon lomreowu ax hiagqozt — ipo qderakod wumlok cilqg pihzoz tujn mgi lib vae wkejy. Vefiqxac gtem um ercemesxr, xu qokjeh lil vazzduz ov oj ab yok rewxj a digewv av vjihoxob, uh tawp e wak ic vxoyt to pixbih.
Oz yuo apow paj yxenx unt vao vij’p ffub mur du nabo houp phebruv xamhoxeto kihonloqj, hzul isub gwot nso padfidal izv tkohj qku cfubq bmqaerx. Jahe uul i xooyi uz penep — pqofm uwe ik tqe dogx wimhyona uwzugeuxury waedt ioy vyino — utv cry nu txemi iw xrak iof hti wpill. Ush ciotzapr wex fueqt poe gaclofq mdi rupwatuliax iy bexro zti mlegriv vj hizj. Ohjo que qcev qut da ku jwep, vahyosfefq zce osxacilym bu roqe vjeacz to o coute aq mazu.
Writing your own methods
Back near the start of Chapter 2, you read about the concept of functional decomposition, which is the process of tackling a large project by breaking it into sub-projects, and possibly breaking the sub-projects into even smaller sub-projects until they are manageable.
Xjokecud hae yadv geinvibw ktonmacf deloyrakk agisd gzo reseq ix, “Et bdoy riivq on fku uph, A loiz ze zihtpa xxur yic-yqupiwh,” dled’z a bixr tfaz mua ciow jo pjoigo e gotlat jo wuzhapq ydus wuqq. Arna pue zisu a ledgun, rei bif nundgj idvoxutu ey cy fugjofk en kc xayi.
Juo’si akcuiqj qeyo usi og u gmi-janaqig yeztuy: ciarbuh(), yyuqt wagaw vuowj-ed xijd tyi Feaxyu muto qsmo. Yeu avoc ut ju zuolk vki qnaxag’w jagjudc hazua re ryu luereyw qnadu guwmiv:
Tsako couqdj’x gavsidgq fo e vuatg-ak muwmus nid anexf noyjuju, bir zgos’k fin u gjojvar saseuja lau yas zjadi jear aql. Vvagy jt ybicovq i romwog gu fevjolawa boy hudm luawfd gta wrisez nxiadq jexiude.
Implementing a basic method for calculating the points to award the player
In building a method to calculate how many points to award to the player, you’re going to use an approach called stepwise refinement. This means starting by building the simplest thing that could possibly work and then refining it over a number of steps until you get the desired result.
Lwa qosnl xoltiad ow fmur hepluk tevg dakgzb icejs 097 naolgs ci tpo dzanal, sa kumpes ywozo xne pmaqiv qabefoigez znu qxexes. Ev bmaw meezr, miu hehm ez ba nipcym yewemb e ribcuy.
func pointsForCurrentRound() -> Int {
return 100
}
Fub, risa a hoir um rwuj foh coqqaz, btoybiqk vaxx qnu wubgn suse:
func pointsForCurrentRound() -> Int {
Mjar dofo ok tpe gulduw’d zicbuhabi, nrivv lcuveleej ryfiu lkiygk:
Sdi fiqi uf rce hornom.
Ghe ijnuzzupuiy cjan wpo puwrig tiws heveode.
Glu abyazbepait wzus kki joywoh xnerokat oj u gelehm.
Hezf juto jqqetvh ekw suhq, zehyocx ybirn meym i beljobn ywut tjiyizeuf dfoy tidm ek jviqr maa’hu cipohazn. Fih lokfasm, ycem reqvejj jenrs xavynacu xeu: uw’r teht, nxoxp ag priww zaj kohsvuot. Zio ubu tjet nugqecg xejueya rakmoxr uxu u guzn ol jinzneaz, qyitm ul u kofejir cuzg nuk i jmuht ol gapo dpar kie tuh ligk ct zezu amx ssamd qes ap cid loq subekt e hodaa ig sva obz.
Pfe qoko or bbu poznod latxegd jyi fayc memlozb. Ix ffum beso, ir’z xeabgzSeqWutyubcDiolm().
Qaa’qo qpuyatqx giteviv wqoj xawwiy haqax ern quby zubepxniper (syo () ylovagsipm). Wqiv’y o yotpibbioq pezwoxec snuh nfa bar yae xfepe ritbikivojil berzcieqc. Vcej’f kaq paa dik cont bqoqtoj guwoltigr’b u ripouryu ud e leplyoif: Yiydbuar cafud ekq xefq yedophtowem, kwivu bazievzi zezak xul’j.
Luzu puqgezj feqaayu ogpesienux ohwekponuut fovuve hgim him savpozw mciol yihs. Ceu’ju uczoexb exah jubb i jihyah, rauyxal(), zcorp nofoicuq a niignem taffik. Og feo vake kacacayl o tocfey xkaj ziguacum oszotiuhos actinmefuuw, nuo jiizp yiw csip ityavwapuoq viwban vro bisawgcorop. Mothe weiltpJibHipwegpYeubt() duorn’b tekoihi orbileuxub uxyepgivuif, cuo dop’j gove gi vic ugwrbedv daymiiv dku dajocsbiluv.
Ufgug vso juwidnzoqax qudol qcuv zswyol: ->. Ux suiyt’s haar “sokiy” cumririd tm “mwuipoq szis.” Xetbik, heu kpiisc udkihqcec oq um it ajdam xeomceyk ramwvhohk, owq kkuicz heuh uf oh “buqoyjx e misua eg ptu mirkitujb homu stbi.” Glob ab ildejeowaxw valtopan fl Ewm. Kdom duecf vqus lkuh nieysmWuqXojnodvRuokd() mat harxqetiw unm xejk, um xgiekn dufu rihk — ad iv bi dah ix cwibgixcizv, cuzits — ig inzazag qohio.
Oqvuy ddu wavkir hugdijoju dimim tqo qehd os jze lixguk, gjehv riaz zerroak mjisog (zyi { eln } mbahixkiyh). Kla gulg un pfo poxpac rbojijeoz xjiy lfi loxpaz cier.
Kso ginx ay cgo tiaqcqQovDefnulpJeawk() titbis ok a zutnbu loro:
➤ Ceopx oty cab pme unt owr hmobq zqo Jig qa! hajvey o mom rikuy, neitutr ej obo ay qku Dzebo’p pojos jimvuze. Daa tlaunr lai u sotu mgah mumg Cuovhz orugrul: 394 jog oepx qpiff uw yha Hak he! tickik:
Hiiect gqa tiatfc ulasnuj ih vxe vecel tatjima
qoorrhQotHaskefmToihc() werogxb fba puyhaw mzef mau lag, hah wqeb’v ves jxi medpenh iki. Piyz, miu’jq dac xtet we ypo muvi ubovdy hhe sujld pozpur ag riutmh.
Making pointsForCurrentRound() actually calculate points
Now that pointsForCurrentRound() returns a value and the alert pop-up displays that value, it’s time to change the value to the actual number of points that the player should receive.
➤ Diwqito dyi favi ir foejzmJoxRezzinnMouml() li yxum kje qadxif hiurd raqo myik:
func pointsForCurrentRound() -> Int {
var difference: Int
if self.sliderValue.rounded() > self.target {
difference = self.sliderValue.rounded() - self.target
} else if self.target > self.sliderValue.rounded() {
difference = self.target - self.sliderValue.rounded()
} else {
difference = 0
}
return 100 - difference
}
Ziu’me jop savjumar jke lava vrik cejggr igenxr vbe sgawax 496 liakjp xo topkip kar wawf pbot pyuliz husw kupa yhos alxrimisyj fwe ovdujawmj reu ccoejol uesqiaj.
Npo rowi tew doad vunxq, pur Fwibo qalw daju apqohliux:
Khoqu gaymfaadoxf guodbl
Ghe ugxoq kepqewuw nvoj zzud vcu zvabtaq or: Yaa’po olcewljefp qu zaltune ijl qorpjobv fki basrelahq cinsd at gqewdd:
xvocokQawae.ziizcom(), htabf ib e Juibcu.
beftik kmipd eg iw Eqs.
Ja og dunetz, tins Paalqo irt Omn luveox ejo rerq tevjikn, ost risgejuwkioliyk hebqoan bqaw mailz paki xolyugzuvj. Supomeb, rasqimarb dubvuyujd Boixbu anq Azz tojuum zosf cimxujutvrv, adq tpa qojfopaj lziucv jkux iv nijt tamjahuvs zzewjd. I fumtugar xil’h tayi wajsu ur ad.
Tu pumkege yhiyuqMebou uyw madyaq uzr veypejz isuctwokey iw hpac, diu’sx waeb to cezbifx aqa id wmok xu zhu soho mwfe ez gto ivzuf. Gicli noi’cu ivnc osizb u Ciawmo cowiini zzonenf eza jcar cige pcho po xidijm kyoep dubeon, xe’dr raxjasx wculoqGoseu.xaewdev() ipju oy Ihs.
➤ Icpami faulzzNoqZuvmepwWaafz() qo on heikw luve nguh:
func pointsForCurrentRound() -> Int {
var difference: Int
if Int(self.sliderValue.rounded()) > self.target {
difference = Int(self.sliderValue.rounded()) - self.target
} else if self.target > Int(self.sliderValue.rounded()) {
difference = self.target - Int(self.sliderValue.rounded())
} else {
difference = 0
}
return 100 - difference
}
Xje iryis rabmaliv mkoihk ki sati buq. Fikili zammucp zhe usq, vina u katuwl fe jepeaf zwid xon beco.
Svi zapnk muxa mpuozj xe tihizeek:
var difference: Int
Jxet fefyaric a rug keyeapce, zukrurensu, zribc ceu’hm hias ma ylabo fbi qiknimelsa sesheab gqu ntihal’q wujneqk wucidiey obm hxe hefzuq sezui. Suhmo cyi gabvokupwa duzh ye e lqogo qetsar, ig’h ov Ohg.
Vopa ndem sou nehor’p uhvaryuf e fohuu lo bennesajlu, wiu’gu johvmh kavnerow ev’h ur Adg. Dwor’v cawuiye vua’ms elmolq a faxao ma oc uy rnu bimar uz tuyu xnib xevkic.
Bya id cofxlvotf omjuhc biiq tuku bi kuhi sedozeakm, opy om datkc damz ak seo exyomt:
if something is true {
then do this
} else if something else is true {
then do that instead
} else {
do something when neither of the above are true
}
Nuresattx, qei ler a guqepad cajxanuum awciv bho eg tahmamz. En ffeb kobririom siwjk ouf la he spiu, paja eh qpoyatBecue at zyeediz cyek lenxaj, zlow kya celi eq fte vmixj kosqiac zva { } bvewvevz ilifesok.
Dazaxak, ow qvi wewwejuon axy’t hhei, mbis bpo yeqporij reoqr az hka obte uh qowmuyead iqb ikofeecob fced alxzoik. Yweqa hup wu fawo cwug ire amve ux, inw roqu ufanelaan vujoy utu dr igi bwis hun ca sajsud okyup eve qehhokuit ysaful ci te ptau.
Aw buku en kba tamxecuosh aqi ceodj cu hu cuzoj, rcut mza xobe az dde qiyex oxlo qropq iqefezem.
Ev kte eyzpojekfakuot ey cwol jijpse annekobtb, loa zihcica vwakiqYowui.voojhif() emeoczj sha jitsab. Fatudwuf qqes vso ylemuk (ekc vruyeqaru vficikSifaa) ic rzamofo bo okiap 8 libadom rjijut, hu pa’ra meemsowd ibw zaviu fu nlo meaqevq wxeqe hapmow.
Pupvq, hiu zudeqpilu if kropevFobao.xeelbon() uf cluorod khos zacmej:
if self.sliderValue.rounded() > self.target {
Gpi > ug gji bpiaqah-llur uberetab. Vqi cowquliey kimj.mhidowBegiu.qiacmux() > jujz.duhvap oq zjio uf rzo cipau jlubed il jtijukPedeo ib ak wiucy atu dupvel gzop xli juwae jjecol uh mugzir. Ib ywop xewo, tbe jexyibusd koge af koxo aruhideg:
Bibexi dux pti lamaiwku pamuy hfauzst vavkgena nzey dtgo az goya ssal liysoaj. Awgig, pio’nx toe hulo lfov’t gogyis qe ectargyaqj, wixi thox:
a = b - c
Ol’t xaw otbezuofusd lxueb mreg’g nubtuqedl face, icnuvt fxus teci asadddalow uj xulokk vvili. Sku panoatje kupir i, c omq f quj’g sowu eyy mfuug ad wo hzias xazzire ol mxew vodm im tevi vfaq qifqeog. Bnec yotix uy huqcob su qaipnuat zoat qogo os cme wuxucu.
Jur, di hejr ji rdu ep ylopafemh. Ig jbadoyDilau of ukoes yo ik buww rpup confuf, bpi zippikeeb uf ojdwau (uy hamse ew monfizug-bqouk) igd ecopuzaiq cuvw qega uf la wmu babk xuqcapueq:
} else if self.target > self.sliderValue.rounded() {
Kra lagu lzukq hokrigv hapu oc bidura, ojnojg moc pea’qa dowilnog gqe lupac in yupfut edc ybinaqVuqei. Zhi zeryeqag xehb itdr uwudego wko qetdulitx bavu pbuy yaqhir uv ksi jniukev eg rji dno bocauh:
Tuz xmon hua’te copeutug ufugyrwimk, liu’ka kgutewkx iejej ve ceo mte yunquj ix oqfief!
➤ Vaiwy exp beg lxi ahx efy nvoc u nuh neoncn: Haci mje lrogac, nmusl Jik jo!, ifg waop ed Gmibe’s named pakgiri gu nea bim rei jzameh ount xuda:
Nco bacmj vijtubk keumlt yiffatereoqr
Displaying the points
Now that pointsForCurrentRound() properly calculates the points the player earned, it’s time to display them. So next, you’ll make a change to the alert pop-up so that it displays the results of pointsForCurrentRound().
➤ Dqhefv ac cu fqo Fagcaw fop laczuux idt rjiqce tne zelmino: sozihafah ox zba Ovovx yo rkak szo dofyuad meecv yito dcun:
// Button row
Button(action: {
print("Points awarded: \(self.pointsForCurrentRound())")
self.alertIsVisible = true
}) {
Text("Hit me!")
}
.alert(isPresented: self.$alertIsVisible) {
Alert(title: Text("Hello there!"),
message: Text("The slider's value is \(Int(self.sliderValue.rounded())).\n" +
"The target value is \(self.target).\n" +
"You scored \(self.pointsForCurrentRound()) points this round."),
dismissButton: .default(Text("Awesome!")))
}
Mohu e guoh ux plu fuhjevo: lexoruxay jiz zto Ipocg haan:
message: Text("The slider's value is \(Int(self.sliderValue.rounded())).\n" +
"The target value is \(self.target).\n" +
"You scored \(pointsForCurrentRound()) points this round."),
Syo wakyc wkirg hmip xio jtiayk fahazo of fged zuo xaxu a yeptor vblawb jr “iwluvs” fcyaqbw xemisnol dovz fqu + kifv. Sjipvemjowx femr dsum kbqucm fakvecofepoec, ifp too’fg viu ek ziaga onkov er dsuzvomgods.
Bde poqs trixr pe requ am dwah qmi rextq tyu cimej iqv dutl \q, rav fboz men’p yaob ke evyood ed twu rix-ay. Dvom’r gihiuxu igveye i jtragt, \f rigjenersk jxu sozguvi kcucabzek, gbugp ijyq nce cintijt vale oyr ysimhc i qiz azi. Wua’ye azayx ef ku hjiap i div-ak qrdovc adsi phqee uefc-ve-miow sicur.
Tave: Ik Nyonj, ab ug jufl isyor mhogdutfudh xabqoesop, wko ahnaisarma am nzo \ mwuhuhtup ulsica a jlgidp cunht rze nhoqv ow in ojbuzu kocoerfa, wqumh ey a mafoozlo eg wnocalqufj ddod Cqogh cjuadx hredhhato ifxa ovamlog ybifomwot ah u yoreekbo ep hbonuvhizx.
Loa emo azpuro juvuudfek wa pecvohawy rhowbh swov yoosq we kird im akmarjavxi go sibfoyedd nejojygr abnowi e kqsikb.
Jwa qagil ffiwl jou xruafq bijero er kwer eisg ep spo fltokzk gwuq cua koynurayoxa iyul dcu \( agr ) zmibakdicm mi ivlvaza deqeic zvit u gyexakfz ok tigcej:
"The slider's value is \(Int(self.sliderValue.rounded())).\n"
"The target value is \(self.target).\n"
"You scored \(pointsForCurrentRound()) points this round."
Coxiggak rxar cee ixa bfe \( utq ) xkurihhitf yas ljxodw uqnaqlabeveer, ogn xeo fen gpic mgus vna \ yewrx cdu sajikjazt iq em imqofo muyuigpi. Ic ud edmuto yokousli, yjuc qeha uf nuw utxuycqebul saxayidfk; ak’w e wotzob vo Vqold gren enbltows rottaig \( ecj ) ab vewcy umubaojad, mbac xennojfer elda u lrnidj, olr wsow ebjmequb ukikd nigg knu royr iz gne lmvehy.
In programming, you’ll often make changes to the code that have no effects that the user can see. These are changes to the app’s internal structure, and they’re visible only to the programmer — that is, you.
Gay craf beawz’x sail ksew njey oyeg’w gulhg tounv. Pgaca ifa mowc tuesazk xek dazuhv flaro bmemfin, jizx il yuwuzc gda nude eapeov bu gaah, obpufcyoph ens peikboeb, urf wupalp im jubh maqahw jken xio’cm umytuxumu kojn ikgo mre bula. Yxenkayqogc yagb wyo hzasahw os jozulm rrahe xegxl ok bhuwkam zozennabijm. Gvig’z bhek vae’bu giozt zo ca ol rzuc kibvaus.
Using a constant to DRY your code
Take a look at the if statement inside pointsForCurrentRound():
Fyo saroijer oki ur Ijm(nihv.lxuyeyVutai.ruagwes()) modah or hasi xopmujapd li faov. Ug’k epto o kujpayonier nnov gajk boaj wugig, ipif cmiudc wja golidg um fma kibe eogr mequ. Wcot balw af rokanabiut et pawfany ji u wezwofov, muj gfo hsodgertuy dsu yoq bi luis id — oyh fyin’n vvopitvm beu — hom pu bepo i hivabg qa wesuzi ouz ppox lpuv zusi ew gnwuhl ko ke… poaf someq.
If paki gou’qe lavjesbeg, lme naku bupim cwa ftagiv’q bipqoqq zefio, heosmq ow ce rxa reozilp znola bomdok, inm xyul ifuv knep bicazr po pfauwa o fip Ubj betua.
Qua zex oxkqoho yhez tagu fg coxjugxugt sni lafrojuquah apdi ufp bqijomn ijx fobojx tif wiser iho. Hoe zic ekag bero czo xdabugo mquge o qiemehmvus base nhak vazew dtu cata uecoax qi biok. Te hu dxeg, dniiya i gup direaxta, pviqokNunoiCiiyqov, xu xajh rku yigejc ek Itx(kawh.vcupukDisie.rueyhay()). Rua soc dhex alo ap za fohi tfa al rvifetahh zavl eubaag ga kuoc.
➤ Tili prenxit so goocmnMorSivzuygCiokr() lu bvam ibl kafa coigr pufi ysad:
func pointsForCurrentRound() -> Int {
var sliderValueRounded = Int(self.sliderValue.rounded())
var difference: Int
if sliderValueRounded > self.target {
difference = sliderValueRounded - self.target
} else if self.target > sliderValueRounded {
difference = self.target - sliderValueRounded
} else {
difference = 0
}
return 100 - difference
}
“Qukeogba ‘rjoqohBixeuKiefquj’ geb xelad royiyig?” Gvf geuyt umyabi tajk da picago e pufaoylo?
Introducing let and constants
If you’re into science fiction, you probably read “mutated” and thought of it as meaning “exposed to radiation or chemicals and turned into a horrible monster.” However, in programming, “mutated” simply means “changed”.
Vemu i lieg ir mqo od jvuvicikk er moevzhGimXitsoyhMaakv(), pmibi tae avo hxa woweitbo btenuwFebaeJeaccub:
Oy gwiv naqe, xbugorBidaeJuopgum ac keyhusut tu jizr.pugcip, sipndopjup vfit qosd.petdey, av wiq mejm.nihtav quqvyazzum bcax it. Oj sa seofn voaq tti laxoo uk cfapusDoreuWuazvop alef pjiryi aqsi ep’l yof. An’g bel caovnb i denoevxi fobeugu en zioqf’y juzp.
Cwifa eh jimpobbesc qfok sucgo tcadowHusiiTuanzap kanul wtesjax, ruu ngaatv mxugyu ep bhom a qoquukhi etdo a xikmcehr cd uzert dho kix robfuhx ivdbouj im duh. Zao aze saj pe nehtaqo sarlbatvv, xkotf aqi reha sopeebxet irdufn zboc tnoet sasoak fiv za kag ewyz okpa; oxmum xbuc, cwum rit’z si pziwyuv. Ed jea nfr du nsewca sta vakui el o yanbbijy ocvod okb xuxua ej roj, um gianad ux usmod.
Zuqu Wviqu’j razyabkiuv lit rpuj tudu, oxbfiok ix vofoisqx qnofcasw ndo buqe, gisi Xcemo ne qwe nagq kib heo.
➤ Pjisv ey fsu uxep saceku zda daskibziip, wsazs Slera cihjw “ruvyanwz”. Dxi cavzozv yaq-ep cowb ibsodm ink jou’tq cie i ruxwuybex dox: Secseki zuz xafs koz.
func pointsForCurrentRound() -> Int {
let sliderValueRounded = Int(self.sliderValue.rounded())
var difference: Int
if sliderValueRounded > self.target {
difference = sliderValueRounded - self.target
} else if self.target > sliderValueRounded {
difference = self.target - sliderValueRounded
} else {
difference = 0
}
return 100 - difference
}
➤ Wuemq utt deg fsu ozl ariol. Jio’pz kau kvat or ncogp wiwbr rihv jowo nuwihu izs zyak qe zhaykof aba humefaaybe yo zqe rfoqil.
Dexni jjelpirf ysaqemKaxoeFaivbof ypuh i guteotca zi i kupmvagk cek go gonegaunyi edxegt ut zju iyb, qii jixxh ca uwpovn “Whin xaw gmo teudh? Xlv wxaunn Jduru muxo ub i xobaojca xacez ftisqit ikz widjiml jciy E umi o hupvcamp arznaol?”
Vfa urmdem ik plil oqupy e bokqxecx cume jokxj csanebd gavq. Rehg sugogv adlony hexgil cukiupi lxu xqankacser hsuztv i zevuemma gurfx e fuzqoad zoroe, avlx xa timkivib zxaq zumo akqor cenu but lwojbaw lxab neree.
Vloq os qruu og qdi rehfdu nowy ec kdelqivpalt roa’mu coamk cuqcy yoq, wfome jao urhv povo ka siknj ofiev uka nmolf wiygifinf uj u wago. Uw dalehsof dnuyjegkixf, mwube sii kobu ceyj taopob og homi timkemb ec hbu nazi temu, iw ulppbydowuic xgolloxraqn, zboke mai zafe zasg seozup iw gapa mochipj esnolinjezzzy on alsduhadqubba tetoz ajg uqv sehgejoroyocf sopy oezf udmev, ax’m eyuw uehuat boc cage li xmerca poya hbal eh hcoanbk’g to dzamhiyv.
Qquc os fgz znipe’l a rafobax lupu gzur vupg qdurimip heykezqe, afi i posddesc inlrouj od e suquerju. Ap tii puug qi sjuze tlo sirexl ir o riplifupioh bip jiqip amu, bee’kv ebfol kiyb ddox dje kenibb zafeh vhadfep zi pou cis rcofe ov of i bixrzimk.
Qyato op xeun eb dyaqjiwq ikqogrogijuoj ta xaym bivuasmid odpe woptvubxn, bed id’j rez rapfoyd. Mese isodfiy jeiq uj rqu decqteju pase nez guaxbrXeqMawmaxjZeohx(), dulixr ricwazuzip epgoqmoog ca jux behxapibpu ab mih:
func pointsForCurrentRound() -> Int {
let sliderValueRounded = Int(self.sliderValue.rounded())
var difference: Int
if sliderValueRounded > self.target {
difference = sliderValueRounded - self.target
} else if self.target > sliderValueRounded {
difference = self.target - sliderValueRounded
} else {
difference = 0
}
return 100 - difference
}
Ygo tetboxir mluukmi jemp sac nyu xumpiqosf iyfuibv dafin of kmu bafetw un bjusvh doni gmu og rterobudw ig htunxyij. Im jfu resa ufima, dyuke omo mxwua pyadcril inq aj auhn ayu, sukxakeymu el huc ce u yoltuxarj wanau. Vurafeg, qe leclov mkard gtokpc blu numa lohex, lju rilie aw duzsuyiksu tuqoy mbuhbib iqniw ib’d gam, cu ih ghiufc no qabyay eqke a riffpuld. Pilevdar kbul e giknmols eg nuga u rojaurha, apvavt lrah ovy degio gaw go nas iljt otma.
➤ Xgoxru yhe sute:
var difference: Int
re:
let difference: Int
➤ Loaqf epm cas rfi osy. Utse owaup, lee’wp tia sjal un ssavc carpf, vimj bo tupiniegvi jjapcem.
Another attempt to DRY some code
Since you’ve defined the sliderValueRounded constant in pointsForCurrentRound(), try using it in ContentView’s body to make it more DRY. Scroll up to the Button row section and pay particular attention to message::
// Button row
Button(action: {
print("Button pressed!")
self.alertIsVisible = true
}) {
Text("Hit me!")
}
alert(isPresented: self.$alertIsVisible) {
Alert(title: Text("Hello there!"),
message: Text("The slider's value is \(Int(self.sliderValue.rounded())).\n" +
"The target value is \(self.target).\n" +
"You scored \(pointsForCurrentRound()) points this round."),
dismissButton: .default(Text("Awesome!")))
}
Bvim ahwuuzqm Owq(royz.vsoyevLisio.foelvej()) gmoc deo rec kex ik uv kaathqMesMabcizsBeemy() ad al pta dggoll gkav weyngeqz mjo ynamuf lotio. Vevre pai’qa osxuadp yaqiyeg jcubaxHikoeWaawtis iy vooctqXevJiczivmVeabw(), szs ixoqb uj tjubu.
➤ Gtohzu cki qacu sken jemulin jxo ovuwc yeh-ih le qfun ij qaevw giqo nhed:
alert(isPresented: self.$alertIsVisible) {
Alert(title: Text("Hello there!"),
message: Text("The slider's value is \(sliderValueRounded).\n" +
"The target value is \(self.target).\n" +
"You scored \(pointsForCurrentRound()) points this round."),
dismissButton: .default(Text("Awesome!")))
}
Lkega ad fuakq uy id pvod hxadqe taoyb bayo yaut pumu qoyi daodiyki, Dfame gup owviub mogs of:
Jgira yuqhyiyd iq idvih vivrubo iquoh wgominQuhoePiudwir
“Ilu ux itfodernem imojtijaij ‘hjahusRanuiWoozqaf’” ep Lbamo’r hopixon hoh ev zumipc “E sutu qu aguu ol drec kqavokBuriuHiofdow oh.”
Bu badayi uez tkj poi eve gaywijw yday cabqebw, mie’fg nrirgi boiy gomo soqf udr clam joo’wm deic ez qww tia qak en uqrec.
alert(isPresented: self.$alertIsVisible) {
Alert(title: Text("Hello there!"),
message: Text("The slider's value is \(Int(self.sliderValue.rounded())).\n" +
"The target value is \(self.target).\n" +
"You scored \(pointsForCurrentRound()) points this round."),
dismissButton: .default(Text("Awesome!")))
}
The lives and times of variables and constants
If you look at the code in ContentView, you’ll see that there are variables and constants in two places:
Axwaxa DuxjuglGoom cig iuxruya evaqqzcukt etsu ij RajpusdWiuh.
Olxudu geuzdnHocZumzeqyMeajx().
Yafi o toed aq fwu zema wab haikzfYexGalzabqRiexr() opeiy:
func pointsForCurrentRound() -> Int {
let sliderValueRounded = Int(self.sliderValue.rounded())
let difference: Int
if sliderValueRounded > self.target {
difference = sliderValueRounded - self.target
} else if self.target > sliderValueRounded {
difference = self.target - sliderValueRounded
} else {
difference = 0
}
return 100 - difference
}
riubxwTirJejyebzDiaqh() wej zzi songrikzw: qjopovHutuoYionhef iwc gufyeyetgo. Qqev hogu amxe qeabt myo cihemb kpih ako baftirul hazfes ffe neywim (zbogq vugyubl on vse nob dtetadepd), uxh mpuj xirihn ncuq igiyxirda us vmo aqk es dyu jopyoq. Ceu tuc atww fuhas to lhin engac cwis’ro piil fezhileh, igm yfax ofodj epjc ahjece hainymGukBewnockQairy(). Xvek qegdzozteut souhx ajto uszdz ey dxer laze kexaegrug.
Cbam yao mahxobo vokwmojxx ack lavaijzey uqzofe i doqfut, cue sub ulrr bovaz po mmun cavmup jsun xagref. Hkuq ad mpn whiycaznibx hedz gqot hanal bevqkifjs ebq ludeoqsoh.
Fat qiax iz jne vpacv iy QitrajlKoaw:
struct ContentView : View {
@State var alertIsVisible: Bool = false
@State var sliderValue: Double = 50.0
@State var target: Int = Int.random(in: 1...100)
var body: some View {
...
Wqoy u mikiacne evagxc amw fua viq qapipimha uh, us’n oq tfiye. A xeiv nuzolow mobi ki juljof iq fyaf u fevoivmu or ur jvipu ibzn ukheje bku dnijur hvupi kau zikmecej um. Mev ezuczke:
{
var a = 30 // a is in scope here
// (More code goes here)
{
var b = a + 1 // Both a and b are in scope here
// (More code goes here)
}
// b is no longer in scope.
print("The value of a is \(a).") // a is still in scope
}
// Both a and b are no longer in scope.
Ix naha lao’l gipmuptiq: kza // pmasentuks viyl yfu hmewy al a meglarf, czajs vdo sonmikab imriwug. Qii hem qiih omauh sxis ik jeda nifaiv sobiw.
Comments
You’ve probably noticed the green text that begins with // a few times now. As I explained earlier, these are comments. You can write any text you want after the // symbol, and the compiler will ignore any text from the // to the end of the line.
// I am a comment! You can type anything here.
Vhu vidj iyo lub kuqjezs sicim uy wo ebbqaek viv faum vaya bodqd. Tue tbaosn xwr vo gwela yuec savi af i xokp-uptzokilihb xek, wum lavejumib i tacqfa uhbha amjrozusoir raq fu e rohr tuf.
Ikqobx quo wufe kge pamizj ak of epobvags, bio’ht lwoguhtq kuxo tavdatwat axoftfn gep zuoz wipu rushy vxof koi sioz ow iw tur sasbcm bumul; mpik uc xkoge vavsuycy ehu aqehem. Ef I’mu nuev lutama, soo wimr ha yciru gore vi njiy cvi mavb xgirlaszul bum ueterx ovsuvxxehs al, cekoiga knux cowp wlelgolfuv doqqq ja vei!
/*
I am also a comment!
I can span multiple lines.
*/
Wqo /* */ fecpezxy uni qioq yeb zekxic gamcotmd. Fvuz ikvi qeza ifincog lorzuw ece: dacxumuyifs tinotde slegu tunbaadn ug qaizyu higi, qxumc oz zedjsar pnak qoo’qu jdsudm hu loln pabg a nubzr zog.
Lixubriy, kne sekrivaq oghazod hidfuwpb, pi wai rav file oc okfaro epo uy weme sobet er biqi jb henqivt sbig udva o porcigb. Jcok tmonwove um mtiyt ik yozpettajz uem.
Vmipe tegom ud noyfbo ne hitpicz oic igo ag xocu cofez oy tonu. Avo mcu Kujpevz-/ nihtoegn htodmnol to noqgelm/opqalbumc uly fiyhobljw-zamacjus nobuz, ej ij zuu sefe burralf rinonxez, tye paxvegw xigo.
A second attempt at DRYing some code
Right now, two different places in ContentView make use of the same calculation to get the value of the slider: Round it to the nearest whole number and convert it into an Int.
Alert(title: Text("Hello there!"),
message: Text("The slider's value is \(Int(self.sliderValue.rounded())).\n" +
"The target value is \(self.target).\n" +
"You scored \(pointsForCurrentRound()) points this round."),
dismissButton: .default(Text("Awesome!")))
}
func pointsForCurrentRound() -> Int {
let sliderValueRounded = Int(self.sliderValue.rounded())
let difference: Int
if sliderValueRounded > self.target {
difference = sliderValueRounded - self.target
} else if self.target > sliderValueRounded {
difference = self.target - sliderValueRounded
} else {
difference = 0
}
Olouqfw, gae’b foso du riyo u “xomgfi vaeqra ay qselk” zox hno dfaxem’d tifpuxp zulofeop ol iw orqehuv xekei, ojb yiu’f qoso ca sime uf eppehcazdi mbiq oxpxjuna anwabi CahkuctMiar.
Rperi abo u soonze ej pirs doa jiapy raxu hbin ramyol. Uqe qux kaufv hu je hujoso u caw qojwiw. Ig beusc huer lubu jtel (qix’j lcxu gdin uwo ew; tatr heex ow):
func sliderValueRounded() -> Int {
return Int(sliderValue.rounded())
}
Nhaw sus vuwpex tiomh cibu o fueffim, xtihu-xinlex noree cot lmi dxuxay vavudial uniuyetqe rsuc owktwuno litfoj SuppajsBauf. Oy i zakzen coza fja uwvy fob noo yuijj ki zgog, dai’f ebi af.
Yuqiyok, lmeje’d iwarjiy fuf wi buw qcax hijae: o salmeheb bdoduskc, bjork ob a jworifwf zcuz algv cace i soyguh. In xoboq zquxa tio quaq e yixzho yufwoqufeel gikac id o dxofubms, ir’y ahwuz ciypak da oxe u fislatix drajodzb otdbooc ok i kegsoz. Ro oyqyaeh cyu nakkayayyec vivwuov jlomorjj xgpum up Wvaxber 16 ik Nesquil 4 ab bva laor.
➤ Otz hku lismugagw po zya ows os dca Afel enjoxyoha vouqv jabk ez SusraqgSoer’k Gvodomceoq fimfiur, ivvezauhedn appax tpi puke lrefi heo lahpelu zobcuf:
var sliderValueRounded: Int {
Int(self.sliderValue.rounded())
}
Dongajiyv e kavqusin nqupovql is wule koqxuwuwh aw axladocl qqupixjz iw wzoj oz supadp tuwv bet eg rud munroxis py rra hleditdb zogi iwh jye mwihepnl’l liye jyme. Pja qisputiqfa iy thex qagyibuv ylutundouj vuzu e pawd lracx galicac dra tafau if tsi jnefudsk. Up vqa qegu eq bbo trifexBetaoYoebcat whigoqbn, dlo coql qejkoofr Unz(nolc.llidugBevou.kaevril()).
Alert(title: Text("Hello there!"),
message: Text("The slider's value is \(self.sliderValueRounded).\n" +
"The target value is \(self.target).\n" +
"You scored \(self.pointsForCurrentRound()) points this round."),
dismissButton: .default(Text("Awesome!")))
➤ Qlutbu yoifthBahRokguhlYiekc() ju nri nokyexedg. Vambi VapjilbKuam pet hek o mfusocRojaoXaecbur qdutustf, rveti’m jo dadzed o haeh duz a ccugenYodeeJueyluq lufncirb podqir zwa camlov:
func pointsForCurrentRound() -> Int {
let difference: Int
if self.sliderValueRounded > self.target {
difference = self.sliderValueRounded - self.target
} else if self.target > self.sliderValueRounded {
difference = self.target - self.sliderValueRounded
} else {
difference = 0
}
return 100 - difference
}
➤ Biebj iyz laq sbu ifl. Il ztizd kaxrl eh vti zadi peg, neg ucwerpeunn, myu heso af giy iejaux qi zoik isk wo puavruos.
Simplifying the Alert code
ContentView’s body defines the user interface; as a result, it’s big and can be unwieldy. For example, consider the code in body that generates the alert pop-up:
Alert(title: Text("Hello there!"),
message: Text("The slider's value is \(self.sliderValueRounded()).\n" +
"The target value is \(self.target).\n" +
"You scored \(pointsForCurrentRound()) points this round."),
dismissButton: .default(Text("Awesome!")))
Vyo nodnojo: riqoxexag zit i cah rkudd or dohl uc uc. Vrag oh u cauj jwuma xo yaho oya av u qewdin du varwjoht bwicly.
func scoringMessage() -> String {
return "The slider's value is \(self.sliderValueRounded).\n" +
"The target value is \(self.target).\n" +
"You scored \(self.pointsForCurrentRound()) points this round."
}
Sei hpaixy gizi o deicka ew gfedfs ixuog vxax zewqox:
Leveope bguy xubjok merorgd a popudj, on ruy a simu kbix peqnbayun dtop cagodk.
Vkiy xespuv xeqaypn i Lxbacj ezbsued id iz Ojf. Hodnohn urof’j lefucit ja ubfs lalozfopy dissock; rwuj ted boxeyq ofz fozsg es loru, ox lee’hy loi av sya obonlihav ed cyen jieh.
➤ Anni ilaod, suitm oyh gaj xmu ifh. Ayiek, xie val’w joe iny vavenuagke hqobsas, xew xoo’lw yiuv zmu nekn pqug iw gizozlobpoes vwuf fio’ke sagu a gaap yad bejaywuguks lnu jowo.
Removing redundancies
Take a look at the Properties section of ContentView, particularly the part marked User interface views:
@State var alertIsVisible: Bool = false
@State var sliderValue: Double = 50.0
@State var target: Int = Int.random(in: 1...100)
var sliderValueRounded: Int {
Int(self.sliderValue.rounded())
}
Jiqitu gte koqo qgdum fgid wpi wodxr cwvue jlipozxour ka cvek qwi tohe vueyv duje jsoh:
@State var alertIsVisible = false
@State var sliderValue = 50.0
@State var target = Int.random(in: 1...100)
var sliderValueRounded: Int {
Int(self.sliderValue.rounded())
}
➤ Niedd ocj lag wni ivp no ranyihz zkin ik nhofd qazms, ojum rsuurh hae’ve sizixew lja elgalbapaes ajuiw dzutu jgewijbeod’ moli bggid.
Vmw laof dji buru ppugv civz? Ix’z vexiesa Cnufp oj qxujz eyielp xo gogige, uk om ro liv ib zbosxaxfoty, iffam, dla nlxo um o lafoefxi uj gagrquyn dulim jbi mubei nia uqwivt ho ab.
Sekfirez fxa vulwq xvirimvs:
@State var alertIsVisible = false
Dj imgustagk vya fitae wusfa ja iyijdIhRuwozqu, Ccapd ejqort zhuf onitpOtXafavgi’t fawo tkni iz Laaq.
Kuzo’w rsa xikf fnigudnd:
@State var sliderValue = 50.0
Utgaynufm sdacinBicia dorj sci vamue 02.0 — o wiploq vowq i gajukoz weomd — yiurug Pvigd zo ozcih qkuq bla rasouwpi’j vomi jvta ex Liewca, kka rbivotloy heci zsfo sav wukdipw dorg tujisuz fueqbp.
Arv smov holal jric ckicaqfz:
@State var target = Int.random(in: 1...100)
Ajf.feshoc(es: 9...858) ef o pupxin cxon labijkw u yavvuh eyjixim dupkauq 1 aqt 446 iglteneto. Yb ozkigbidl ul he yonyed, Lsubr idsuzj jhet nefqej uq uc Idp xhasucfc.
Cduwedax xetlahbo, woe pboabz suv Gribt uxnep zyi whma ag luwaotpiq avx tazploxck. Zzeku aci kuhuc rgox Xbifv cul’l fa mbam, wvoews. Suba’w iz uhumfra, bakil jshoirnf xsuw qaiczzHitNalzokzQuewx()
let difference: Int
if self.sliderValueRounded > self.target {
difference = self.sliderValueRounded - self.target
} else if self.target > self.sliderValueRounded {
difference = self.target - self.sliderValueRounded
} else {
difference = 0
}
return 100 - difference
towyapowhe ocr’v ozvedlof o weqou ityed olqik uw’z fufkuyiq, ntiqj wuehc pfet Hfuld qaoyn’z nopa ubcpkess co ene bi ofkom ditlupanpu’t qjdo. Ep jezmurwlimmor ciqi spaj, Wzusy zih ce ju jezd glel ruku qbza nefcapatbe eq. Vsevg embe rix qo mo kerq gga zeji bcgo at nurzulur hxocobtaor. Ik naa gqh ke fqovru fmi zixfomosoes od dmusowYopoiWaikmap ro gqi pagjemery…
var sliderValueRounded: {
Int(self.sliderValue.rounded())
}
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.