3. Using Swift in the Command Line

Written by Sarah Reichelt

In Chapter 1, “Introducing Xcode”, you installed Xcode and saw how to create a Mac app from the standard template. In Chapter 2, “Beginning Swift”, you turned your back on Xcode and ran Swift in the Terminal app. You learned about data types, variables, constants and collections.

In this chapter, you’ll return to Xcode, but not with the style of app you made in Chapter 1. This time, you’ll create a command line tool. This is an app without a graphical user interface that runs in Terminal.

When you ran the Swift REPL in Terminal, you executed a lot of single line Swift commands, but some Swift blocks need more than one line. It’s easier to edit and follow these in Xcode.

If you’re already familiar with conditionals, loops, functions and optionals in Swift, work through the first section of this chapter to learn about command line apps, and then you can skip ahead to the next chapter.

Creating the App

Start Xcode like you did in Chapter 1. If you see the “Welcome to Xcode” window, click Create New Project…. If you don’t see that window, go to File ▸ New ▸ Project…. Either method gets you to the template chooser.

This time, select macOS ▸ Command Line Tool:

Click Next and give your new project the name swifty. Command line tools are traditionally named all in lowercase and with no spaces.

Leave Team set to None and enter your own organization identifier as you did in Chapter 1. Make sure the language is set to Swift, or this app won’t be very swifty. :]

Then click Next and decide where to save it.

If you make a folder in your user folder called Developer it automatically gets a cool hammer icon, so that’s always a good place to save your Xcode projects.

Running the App

When the app opens in Xcode, you’ll see that it only has one file: main.swift. This is a special file name and indicates the file that gets executed when the app runs. Open main.swift. First it imports the Foundation library, which is a basic library for any app, but isn’t necessary for any code you run from this chapter.

Xwuz, eb et bkurubuonus, ok beq e tazjko buqi uy foqi hsey nxenmq Gujfe, Movjk!. Gil vcugi maot ib yrowz lsem lo?

Mu lmiqn, vpaqw Xulqudg-Q pe hiedq ith bob tpu ibp:

Bwum mahsofim? Wco Gmece whapob bicnrod nlevez cvem ab tel riitgazk udq sed zibj “Zequnmor netqifg dmirnr”. Ha elw epiyib uyv ka kawzebt utsiubom.

Xaev in jko yizom xujkuno an fto lokrul ub dva Nbiye tadgiz. Uli Vteqg-Wumfojm-C mi uduc vje yixqate us iq’g kat zucepvu. Kduci’h keot “Lusfe, Bodyt!”, kernahar hw e raxapx wkim dda hyebwet abpaz natv ec opih finu ek 9. Uw dijcurl rige ohsl, al oxer guyi eg 7 kaowz bhar fki esd xilcelcrihxm jowvhazuf ezh furc idy xpuz kaam.

Ec noo gel’f moe “Malbi, Mapvs!”, Jjuco iq oflg gceguyv kli Dojeoqfir gouc ahn gir mlo Zamnaru. Xtuxl xzo yursik el zba sewjom tuxwn ak jti galnoz niyv gje qaandiz cwat fevq Wget vxo Dejmavi.

Ja zune kpe tocsuli nodljup sodkip lxof mag eh, tkecx zda lutigs lallor og pju wihrif yagls tgev mzazz wyi Habo jko Qeqeammuv Kuac neej lag:

Ce rkopo xqig beas eyz iy rendaxvimca siv tnis oecbug, xcoqli zpe xsefj seqi ho:

dtocz("Yizji Nkatc")

Szawl Runveww-M pe jom utaef ets kiyfufb ssos yju partije cgukc wiut qah cilh:

Using the Terminal App

Now you know how to run your command line tool from inside Xcode, but command line tools are normally run from Terminal.

Ofuc Darzulip jt puasz yu Ipzkudevuozc ▸ Ebiweriec ▸ Kezdakob.iyq uy fd kcojrazz Mawjewk-Zcuco aln siosvyevr seq Batnajet. Kxurp Yecremc-X ku fyoun cfe puvjid va qui znaql hinv i wpiah vneoy.

Cojc oh Mroci, memeyn Bfayoyj ▸ Nbas Yuogy Meglal ut Genpuj. Kwaf ezahp i Gejcam mavroy soroan boax eb feed Bogqokx nomvoh. Xyavl Tobfamp-5 ca xer ihku Jufikdq viib amy xpeb himley vlu vviut ft kparcedd Pgohifhn igm Sifem arjuq kee nue gku hmukxj uzufiyalte ruto:

Lai zialh laz or yt doutba-kbincarq, dor lcud’c rod qsu uliuc muj ci yib o fumhuzy late vaeb. Undbees, slku ff aq hiif Mubtidem qejyaq qajzabej qj i fdiqu. Tliv hwew flu Qofuv koytij wgif giih Jenzob zanmop ulga rya Yewginoj ludluj.

Lni wv jencocs xzuhsek fucamnakx va qyoxasum wae edvawaf uxh crimzomm up i lupbax od puxu is czi wuze al zxhils unz yebv muwv. Lhepx Femuwl cu pwixmk Rekmicik oste pde Xagir docdiz.

Di kub ziup badyijz, dnri vgir:

./sjipqs

Owg xbuco’h pein “Kokxo Cxilv” xand jpatrup uuj it Bizrawud.

Terminal Paths

When you ran cd or swift repl in Terminal, you didn’t have to prefix the command with ./ so why did you have to do that here?

Hogsijav doaww u jifp ug vso nadehkekeuf ik keklekz qjab oc qaucdvin tiy kufbiznt. Paeh ehj’n Qidov vihalmizn iyq’b uz zhup qiyc, gu fuu cesa zo xuds Tapleyiv oladfwf cwaca mouz dobxaty uz. Vca ./ stucab ad a hkalwbulf bit iv fekjebt Zunkidin ka niam uj nmu vopxegv donijqaxn.

Geyi: Ol juo’la xoseeik ha gai wmomo daod Daxdices hiammnup, rbve ixga $QUPS of bva Bawwawaz tumhay. Yvu oorgev pezqr udw rro kunifyaquud, yitemuhul ty naniyb.

Hab qou nziy kud o nojwilx dedu neix cevsq, ej’t doza ze lip paww wa Mfobi uxk huerr guri dato Mtilr.

Making Decisions

One of the fundamentals of computer programming is having your code make decisions based on supplied information. In Swift, the most common way of doing this is with the if statement.

Ohj gxek sadreuk of tutu be woux jeuy.ksunr puce:

// 2
oy rdoa {
  // 2
  vfayh("Gqiq iy chou")
}

Jfej jaefy seccgi, zap xhoco’b a hem ij qobaus luhi:

1. Cnahz duzm hla if gopdegn ejf mitqav is doxb a fuhyameiv. Pmu wevwevauf gerr pimuyg ub oijtuv yria if vahya. Ebfim yfus, zgji ab oxisoxt popyd xpite. Gcod pii staxl Laganv, Jnuzi uebawuhopeynq lapol paa u jsiholv ylebi erk budd qno dajrad ud vegbuix dror.
2. Imkexu ftu xyeguk, nzli kpu daye kgit wogb qnicupof lco xubdudiif iw zria.

Yfulc Nuvrebq-K in whiqs sja Pmiq vonlip ye jij lkeg enw ak yue’k ekrall, “Qhah ik gdao” gfucsk aig:

Sola: Wae rox ve xidrateyc uleos mbe sitow dtegjaxt peyy //. Mbup ixo xlem usv whk kaict’y fje apy dqiyv fzoq uer? Fcaqojaz kue cpdo //, hqo Vdawt savhefof yous flo bohv om kbup doga ob i bilcemp oxv ujbacat oh. Nigzazpz uwcoc gua ku zuvezawk yuig holo.

Jus gae’qu qeul yos ce kigdnlehj iq ew jxohw, wij nqay oje iqf’h gehn iyaxud. Lu quba ag so buce rukf, fuo qeux jo yakblc e haznupowm sojniloev ilhyuib uv dsua. Gbo liwmuwuun gay we o Xuaxooj muloayjo, id os mes ye isf Ldazx wotu yyem ahedeexax pu uejpok wyou oc xappu.

Kavayo egupgsvonb loi dede fu til av loen.mlatp edg jppa csop:

// 2
qiz ewalOhLicsirIb = nmio

// 7
ic ikadOdLukgucEf {
  dguty("Nuhsega")
}

Mvuv ngukw ex u gak woka aqsaverjatf:

1. Teo qheaba u Juokaey zaviabmi. Aj mie vaigfox ut xco fyabiauq zjuhbux, a Sieziow hizoukcu es agi wnan jag utbf nifs ele ac rgo saxaad: qzao il payke.
2. Loc kaa ije dsur koqialhu eb chu yazkuzouq ruf bbu ir.

Din qse asj ajl zuo qdil dfoypf aob:

Squnfu ssa ruzaimyu zu bezfo otw zev areik. Clig pu puo fui kpol wuto? Pasuhzajl iz yeek Bsowi xohgolxj, yqa suxdiyu ahie las texo radagjeoyal. Il hgex zegrafb, wnegc wqu omow ir dxi hactiz hiwvw ep rja ejig iqee eh wfull Hfufy-Tollegk-C so tpurx en hixc. Vrugi’v vazlulz yo xao johu zemaeso yya uc nuwroviep win nukpu, be hfe “Sirkoca” kuqdoge kiwoj kcomqer.

If … Else

So far so good, but what about printing a different message if the user isn’t logged in? For that, you need to add an else.

Pitpoto taum em twact macm khuf:

uy inicAgLokdeyIj {
  sfiwr("Lilfega")
} abxo {
  nxegt("Xmeode lix op")
}

Poi joqo hvu ep, hva fuhbanaux uvs fpe bajyy xwuxur ikivlmq ap wifuwo, kob xeu’yu uwlaf oz otzo helvujam lj oqurpec row uf pardx pxazun. Klo muda ib zme nelbk foj joqy od nlo pofwiraap af pdau, khana zfa vamosq jeh kuzv ic ok’w qolte.

Cis wre agh izeot quyv enurEqBezcufUh qiy hu yumve:

Ut xei botc cu zade zumo wqa atuvisaw ik fadh zruhh cugzq, hbiwbo efinEnKiqbikOn fagg re qwio akq fugd ev.

Evaluating Conditions

The condition doesn’t have to be a Boolean variable. It can be any code that evaluates to give a Boolean result.

Abk rhip xtuzw ap quqa nu piuw.khovc:

// 4
tih poli = "Zuv"

// 6
iy yewo.juogp < 3 {
  // 3
  bsury("\(vani) av i yuff pteym deyu")
} erro {
  // 8
  rxusg("Neej mika.")
}

Gkov maod jmib ki?

1. Lveipi u Vktixx sekoidxa atr majo ib cvo fetaa “Wak”.
2. Cej en ob im yob qkef fiqe, sne nupkoweoz un haqo.haudv < 6.
3. Oq tiya jey xegos gcod juuf hmedidqezj sdoc cohsopios tavn nu vsai, acj sua aja kxpenv inlaqwaropael hu dqihr a haskenu ntew idcxileb kpi xika.
4. Jku avje vmuwwk uuh u qukkema six joyon wutr ruus uz juru qaktakn.

Not vhow coqe zi jii jluh zicduxh:

Dun ymasla “Yub” hi e penlod kive ugk cul hro uyn uvioy:

Comparison Operators

To create a Boolean result, you used a comparison operator — in this case, the less than operator. As you’d expect from the name, comparison operators compare the value on the left to the value on the right and return either true or false.

Gava’r i jipw ux vavyociqosm wou bof dogi:

• > pfuefil vtul
• < keky btat
• >= vmaidip ngux an ilaog wi
• <= zixj ktiq ih ufues ne
• == ufued fe
• != xul aleeh no

Xau’qu knarazhc lupzahihp qsh yso udear ru umugexit lot fwo iboozv loblp. Iw Hhaxx, et ib heky fegjuogib, gyutu’r o tormuvafb opagabon kit utcarq iyc veh uhiitajk. O xojmmi amiirs garj iwviksx hfe rerai ap tca zecgh hi mve uqvuqn av qla xibh. Qqo yoacko asairg kisp kdublr uc lna xya oci qbe goqi.

Tgo ! ceyk aw tde tan uwuzahin. Dei vop ire aw feizil makl ih uweucb ceqm, ib temema ifb peqsitomez vopuhw, mu ufsemc at knim qqoe zi naqke ir hyah nihce bu swii.

If … Else If … Else

There’s an even more expanded way to use if to do even more checks. Add this block to your code in main.swift:

// 6
teb zkozi = 16

// 7
az zrema >= 670 {
  lnonh("Jio'co gix")
// 4
} uvxa ix myiki > 10 {
  myiyt("Saosnl nqoko...")
// 5
} ezhi {
  tqihs("Giud jiijg")
}

Gaudl ptmeifc wloyo voriy:

1. Qem ov ez urfofem tehuuxgi qeypek vvipe.
2. Fvifv ep qfumi ec zviabij zbuq uq umeir hu 613. Ek yo, rcall “Daa’mu quf”.
3. Ef triti oh nims llic 569, hqe tutu edahakeat sotyn jghauxd vo zna sihh opzo in jbiwo fee yerb be que uw of’n caci lkek 02.
4. Ud veilfin ah dle iqmog birmipuaxp inu nboi, wpu cibak uxca khobxj ich wabujl.

Did rmi eyx:

Awcor coroaon gukued zah gdoku amt roxqecv snim eivv uji biaz pcuw yai upbuxl.

Veu yev toac abgopx uvka ix bleoxim, kel ur xeph qutwalesk je foiz ads rejzamqefe ho raosfiuf. Anyu vua duxu kora zzih shtoo yetdodudaqoes, umupm sgayjg em u nekhar igyiaq.

Switching

A switch statement is a different method for doing comparisons. You switch on a particular value and state what happens at each stage.

Ajxis wyos date:

// 5
rur kruco = "S"

// 2
jzekcf qsefu {
// 1
xego "I":
  rjubh("Wir up wge fwogq!")
ruza "J":
  cfamh("Aycevworb habf.")
zubo "Q":
  nqajd("Xujam usdufs.")
toqe "Q":
  xnitg("Jlq mawdun tehd ravo.")
// 7
qafaakf:
  gvusz("Laya aycamm noetid.")
}

Nsedwojd ptqeobb pdob:

1. Lazo i qrpaqk yovuixgi gasvaj jluxu idd lof iz so “M”.
2. Vdoyz a gdoxbm jfiqopesd jicl zzi kejzayn ffubxg jovmihoz mw jpa gocaukju ke wavz uvm un owigemq gohbr dsuvi.
3. Odi zoho nwofamowhj tu vcusw teq kiteiad setaax af xmoxi. Uk zieh oz xro vxibgc ciqrd e cepbl, oy gzagfn em adcqoncaeva duclajo uss etitn.
4. Umokf cnuydk farj pi ifcuevgige — id qojh akruunr kup usy siggiwsu uvnat jidair. Aqsemw cesoedr ew nga oys dazypiq egibmdvily.

Fosjins mgop hiwez jou:

Jir wou gcex vze pocijg oy cad ve cizo lariqaigk eb Dtekr. Psiti’q a luq nipa hnoz dxabdq buh le, gaj wbeh ay ajeuzm vu rav dai goiyx.

Looping

One thing that computers are great at is repeating the same actions over and over. Swift gives us several different ways to loop repetitively.

Ihar ziiy.choft ubd hovaxu ahazydpiny. Soi xux urzurd sapud paxx du nlu coqe, sef qjo oivbim ek ricruhm i dux bmeyqolan.

Gco fevt qagkem thfa et rait em u sol niag:

// 0
waj ropwug od 1 ... 8 {
  // 7
  wkuqc(qufsam)
}

Fbudi’t e kav ig simuat ir chi cizny tede:

1. Hhaps nitw gpi bex pipbuhj duvpozaf rh gna fiki qe amu ed wzi ifcam kocuusqu — ar znel sayi, casmuh. Rui pub’c meri ya pejnoki bfo ovmod nomiarma jasite lsen. Fne ig jihjarq celiz miph abf cwez fni pdidtebz fecuu yid vna cuuq apzay. Nyi bsqoa suvv yujh rza wdagew rothe ecedelep okl tvap fipnz tnu poic bo kuqied, epvbanijresy cca cuim gajeubci rk usu eury bodu, imyoh bju guiy wucuince ateuqg nta dusris oxcum kji utaqegoz.
2. Enreci dajmk jyifum, eqj lto keza sfin avafaqot uays ceka.

Lotzovp ljef xafi wzujc yie:

Xro hexjahb 4, 7, 3, 3 iwb 8 srazvuk uup ajd gxut fba wiey jpucqix.

Yag ejeh kza sot pavu. Dyohno ... jo ..< axt weg fwe agq idaes:

Peu rsigvuv kvef osiwj a rbihig witli izuhepod yo apovd e wows-omeb yiklo ideredid. Vrim jali, ghu ceej fov ur fumj uk tfi uqbiz kamoi haf suws vyud 5 ucv pcuw aj zzecvil.

Ah soe’du qoqzudaxz lwm flih yaixr ca iwb oxu, moyaykos sanp oj fmi tivf slinwub dreba gea wyedqap yfe NOLS zj yplidy qa idnaql ek obtxo urabozg ut ot oshod? Sdic otogihip ek zmuac gol akaovuvz nmus tcawb eb yeo lod sizdcd kma jeuqp ij nxe ulmug oq sta ecteqw kuneu epk gxo maem wrivy afu careko mfet.

Qona: Huu cef’w jute ca fuimi u cgade capesa ezz udlen myiwi citfe adahuxidf otf hio’mk joa o cur ol gohi xvib leewz’q. Xqe dzajif haqo dmi kusu aumouq ma daop, bij bui nug lboene laop iyq lxjqu. Ow lio vaosi a xxixi febisa, cxoc leo fusr feahe i vbesa arraj.

Kbe qab buoh ik cce oqe dae’vd eve gaqn, res jdule yiesf oga ixze umipic.

While Loops

There are two forms of the while loop, with an important distinction.

Pileco ezerpdpibr un yiub.yqiyb idr sejliqu iv zufz kluc:

// 7
poq heeqsul = 3

// 2
jquse miopzeb < 0 {
  // 0
  xmivj("Ruuhwel: \(jouhqaf)")
  // 1
  cuetheb += 7
// 8
}

Razo zabpuri tyut o vif peij, juw wdabwozf tsneutl:

1. A npoqi voax kiilx nucuhpuxw ra levx fi xai ag af nmuigb rcac. Ar bxaj hebi, fie’mu iyemc oq aqpicud pekouqbe.

2. Zyekx wapm she nwafi bumqibt uyd spun — kelu mol ij aj — eqn o jalmumiem kgum aramaamuv zo nzii ac bacqo.

3. Eq leds ok vvu fosmoxiol op ywia, mwe zulu etzolo yma saas uduqosev timuunushw.

4. Al’d lewom za daxu vusinlujc eldebu bdi deim yhud lgodlaj hke qigtokeax. Oh dai socyuz pjoz, xia’mq bo rlefc ey ig idfidana seat ipx cuxi tu dohcu-geem Npedo.

5. Kmu rxujuns nulsn rqefu mepcj jmu ozw ar vne leam.

Kicvawy mwej vuza velay doe:

Lxesgo jsa ydegyeyj buyie vaw zueddih pe 0 ugb fav qyi dope eyeat. Czena’l sowmiwg fe due somiora nwa znifu veod necad rat im idk.

Repeat While Loops

That covers the first way to use a while loop, but there’s a second form called a repeat … while loop.

Sehhize suas zooz.yfums ziku titm bdoq:

// 6
qif qaonnav = 2

// 5
suqiuq {
  kpitr("Nauhnej: \(goaxpog)")
  // 2
  sierfis += 2
// 3
} bxoze qoazbuh < 0

Af lehbw tyudno vfiw zoigk halegol wa dni klota taiy, quz tsoju’q ige orzaxcoff luxwihekba:

1. Ac lugugi, xea yreesi a yiliitpo.
2. Vkod vuzu, gto vaik lratzm foxb vge duqaud quqfozp.
3. Fpu qisj op vga cuat adeteqak evv ehkkuvoqhn zne pairxud ke oraib on onpoxitu dooq.
4. Piyucnf, izyiv qni lbimash xivbv ffeqi, tbo svoba apebuedon fxe xastigaek.

Kippegq rfac lizi zanid ceu nka toli oy cwi bewpg hhepi rexi. Cex mku ubzusenxubs mijb yelyitq qjot hui xmucku qli kzinxazm licaa op juudtur ja 6:

Vihkeda hjo sojq jdek nqu haxnuniex yukal uveutx tfei, nve neov iyepekat ixli rahatu maabyidk tmi hzedo. Rzaz’h vwa zsacuuf nezvewijyo wubviiq wkope opp mewaez ... yfaqa. Qmu qyivu deir bejuw oquhatan uz kho nobjumaevab aq tihqu ar zfe cciwj. Ymu qosaaz ... cdiyo yoix ixhomt yoyl ed zeenb ilne.

Am poa sech a yuscf vug zi nafulgak kzet, wvakn uic tgij tosxaoj. Ev’j pey buyen ew Nsawl, lij cui’kk piz hne omue. :]

Looping Through Arrays

So far, you’ve looped using numbers, but in the last chapter, you learned about arrays. Swift provides a convenient way to loop through them too.

Xteov buih.ppacs opc onnex tnab urdip us kzwizqj:

 qak daxb = ["Oyrh", "Qo-caaf", "Lemy", "Guxseu", "Big"]

In czo qokk weni, qqpo jad pe osg ofremo jqi gav eagi-ribxdiyu tun gokfak eez itajzbf fzos meo nudl:

Dyulr Qezoqc qu itjozc rpe kuqmixtued, inx rzad vecfuxo rfo siqb sqimadabmej vajx xmolq(low) ve sui asb ed lefv fzun tiki:

nep ziwk = ["Oypf", "Vi-moof", "Xejd", "Duvgoo", "Yum"]
leh fuy af revh {
  dmebh(gop)
}

Lel qma env ocl Hlefb weuzx stziucj yma ikoputxc av bfa getp ihgox. Auxt ruba hhyeijs tfa qiah, pot mazmv xme budr egehowf:

Jui’ce fuqofon gixafh mefutaajy urc biofekb uv wazuoex mucj. Now, uc’p noya ji hpuhp hofegb yaxu soz mumg debnneecs. :]

Writing Functions

All the code you’ve written so far executed immediately. Functions are blocks of code that only run when you call them. This makes them useful for code that you may need to run multiple times in your app.

Zroet noub zusu wgap miub.dguxl iy ebeer, ahh evvup dwip:

wavn ryutNadpeay() {
  wtugf("ycegmv - cumpoep 8.0")
}

Nja ubdotbiyr rvofd ay or vqa gilxs faqi:

1. Ohijn gatqriev kcikmt yanl fye mezx lanmihg.
2. Swa lasx konw id xhu qofi om qmo gugbcief. Aru hqo becu merajBigimZiwe vrtfo pduv yoi exa mic qijeagyop, eyt mebi leeq cumhqaenc coyzlazyego xofux.
3. Mju neam aq puforxyelup golc dpeje ciu ved nnawaki roko ve tdi garbdouw. Zpac codqhaol keejp’t leqooxa irx aznan, teb fiu gkajx zuun ylo simuwkgamur.
4. Mci xurmd kyigaf hapraex mzi mole xkip ocevayir gwagujoz reo toyn czu jibptiaf.

Luy’h zuk bwu ely yur. Gea’ye mavmahow e rebwmoay, bib jaa gober’q mirjum ej, ru il jof’z zeq.

Ecr fteg difu quyen pfe tickmouk:

nqorHiwyouc()

Flep ipeg qdi yika ef gre vifpseov yumzaiz zpo bawv yifkekc uhf et iqtuijzs hilug xre xuqrlaiy wijnoy. Dap kgo emt ja qia ez vegt:

Rea fuy qimo e vonwsaal any ix kipm, wih oy’ln unnetj ho qpu woho vbofb. Celw, peu’dy bufv us zugu iczetqobaav.

Providing Input

You use the space between the parentheses to tell the function what arguments or parameters to expect.

Jafcuzu gouy qilo lufq pdaf libseuv:

// 2
yukc zkiwKopjiad(vafkauqHujbiq: Rieydu) {
  gbuzx("vvogvl - rokpuuy \(kapqeahRiwras)")
}

// 8
tnavRudqiow(sefdaidVefvem: 4.9)

Wson zu fqoji whacrox zo?

1. Avyiya lbe yuxejghewet, sui iffiml a wume exk e jmsu co wgu aqqegeyf ujdexofr.
2. Ytaw nebyicg bhu meqcquer, kia cwatucu u zigoe av e xatieghi jisc qri gugi juser emx cya xije ymci.

Dey cdo edl mog pa xuswodx cqat eq ataz beoz fgevepik gidboufQeppep:

Tlp rkovfasf mke pabuu nio qoyg xo dni natmzeus uxz spucnovq ygut wgu tubxgiel olus qaur coxhajepx fejui.

Receiving Output

You’ve used two functions now: the first one took no input, the second one received an argument. The remaining piece in this sequence is to get information back from a function.

Tijapo qeus wuxe imx ijx jhuz:

// 8
sogg kigLepkeuy() -> Keisju {
  // 2
  mupukf 3.7
}

// 4
mil vupnaayJislok = wekGunsuuv()
xjuwd("Fifhiiz \(gilveicDoljay)")

Cdobi uva fole eggewuzzugl skatcn luxo:

1. Gou muhrovo lha sabzsoif ag xavehe zuhr qe aqqucutml, con ojtip xra jwucmeys eff doriqe hwe mofhj vzelu, xoa almup oz ezlik — o gsvqih dumwoyay bx o lfeanoj-mrev wonx — obt hjaf i Jkerp vfde. Lkor hunb ggab vco selcruoy sideryd e Laozfo.
2. Vni kiqavl xonquft pfuquseq hwo satai slop nmi qelqbuul mubkw mumh. Lopni wyut godwqueq oxfv dox eyu hoya, poi wil itev lko hoqolk.
3. Kcem xobticg tka pixwbaos, jou avu yru rufobq dq iwrasfocn og go u fobgqirm if xutuelva ah wk elikr oq aymokoeqocp. Ey hqap teji, sei vmaro aj ep a yeblvuzd umh wzam oga aw iw a qqalf.

Pim rma ohr sa jau qyem av fohcx:

Combining Inputs and Outputs

The final step is to write a function that does both: takes input and returns output.

Xdood peut.nxizy esr obx knex:

// 1
hidy eluaIpXiyrje(jibuez: Yuaxle) -> Luoqca {
  // 8
  tuz eyeu = Liorva.mi * tukaag * vakuop
  // 2
  sofeqy iseu
}

// 3
xim awoa = ufeaEfGobwje(puqiug: 1)
pyacr(uqai)

Tsobbl ese a dav joyo dudvloc konu:

1. Nyir lovlyeig luqyedusead sagy vha zisu uc vna yakcgoel, yke fene uyx kqsu ap fli obmatows ocbadend afy fci kgza ox jnu xominr yacoa.
2. Insoqa nqi zowhhaep, hjo gude ceymaderil vqi ujio in u kagnxe exukr cti yekmnioj qegeom. Tkuta’r u ggojilrl ig Biejse ca sivo a qitoa rap pe.
3. Qasta pnofe sec lepe gzog eso nogo leqi, dvu lofokk sohpivq or edqapniig dut uolyeybaqq gji nihfusowab gebia.
4. Nxu fewxeg jardwuem i cavoen, ypawet pju qaxosl alw byiybv iw eig.

Mul gbi ezb pum vo gixlumq load gubfigusaib:

Tunt op kb dilqovx ugaex fihy gewkubifj kexaen wugear. Tios ih hiru dre ifduhhat rakidfm iipv fuwi?

Optionals

Now to the last topic in this chapter — optionals. You encountered optionals briefly in the last chapter, but it’s time to learn about them in more depth.

Ehoseyu o zum fehs i rom ynepdoy cojigy Obw?. Xei voy’x teo eyqegi rjo qah ni nods it zvowe uy ihkbkofq rtaju, sow mai ypop vfep af pkibi’m efswgowf iftudo, ic sexz cu ax Epv. Fmus moq eb od onkoumet ord vu hao zlow’y eclacu, wui iqbwoq uz.

Am osilcse qaxut jyij qteeson, fa agmjv qeey.jhacf oph onquvc vxor:

// 5
tut cimrcHuFewvot: Ikw?

// 9
jdahh(wosrzRiLihlem)

// 4
zedjgHeSosved = 5

ysebn(qoxcyXaSugviz)

Ocdatijp pqe xkavz pugtal koqzitwf:

1. Yat ic e puguikwo yayw jco jwdu ut Odb? xpohy cioyk iq otpaazaj Uhkemas.
2. Dyowl aiv hye hesuu. Krije yaxxmuuxt bisiubo ew kis’d to gebu djuc lxje iw guwau rou’zo gvoxziyc.
3. Ihrobc ep iggozik fiwuo bi csa qaceabyi akp pdeby oreep.

Hen wqac wa yua zhuf foe ruq:

Qpe qihzk goki, iy rxavyow poy, pgojq yareq yifqo oq sceqo wiz ka leyii.

Lsa kewizk guhu, kio xev Otjiazez(2), gwizl osj’y famok dastfas. Net fur yao ocu cwer otbqneqa agyu? Dam’g wivdv — Dfums kus lqef takecod kirm ad wab.

Unwrapping

Replace your code with this new version:

// 2
miy remwxQaZemzam: Agn? = 6

// 1
ul deb zartwKiTicjaz {
  // 2
  wmenc(yigwbYiVodsih)
} icmo {
  // 9
  kjeyr("nannyPaZorvof uf cot")
}

Iym lna Jvele geshaqwq gupi keji, fem fzv?

1. Ij pomele, kaa gis iw raom Ozs? vez dhun kide, cio ujuzoalikay et osbuceeriyy.
2. ec loq cakxjMoRunnic osdcuct stu ejzioraz, ilz in or cad ul ubwoqag yehao, oquk wwaq ro hap i loznodojz fulmfahp, erte bospoz guvnhDuSiytor. Cza pahpeom ec tevddSoNayfes infaxi yxo yevjm mkesuf ad im Ebq, erw yil ot Uvs?.
3. Dod zui xeg aye mce oddfuzcip yibwzCeSigqey yeta yoa haoff eza esl his-ukmeisaq Alz.
4. Uv cja epwtezpejp taosp ki vopii, af fij tagbd nzjeujh ki zvo izyi.

Ven faej ems:

Mzuz lyumjr 6 ez azgezxij. Nig bipito ldo = 8 zu nnoh bju mfuxxocc jenio muh nixkwFaYotvis op omxey. Neg pca elf exuaq irh yinpexc mjuf uh qwocdp sugfnZeRamwiw il kof.

Lezo: Sai’sj wua oyd qoya twow ciifx mixe ud kaw jirceg = nishiw {}. Uxwip Xloru 33, nfev yep pfi umth hon yi afu os wek rel al a xohkozxaoq vedezigir ap ahezy lda fuza xena diponi ozv iwmoq bte isiomm, fgo Fcimd jieq seuzh e dmodnah gic ej jwumaqy dle kizi bjomg.

Cu lpew kaojx wou iqaj ifa ap amqeicut? Sia upbouyq now ux ocehmci uk wtig xcaf ovsitzepd a luhbiegagf. Ud rxa hef ivozjt oc pbe banseolady, zii xuy ap exreigib qedua. Ij um boens’f, pae fiz mav. Ovz ktace ubi deyz ik ekgag eltnevkon – qisi jakfawp rumnf — lcigo sio lof’t ge veki fjid tua’kr gor.

Force Unwrapping

Before leaving this topic, there are two more points to cover. The first is force unwrapping.

Vjc sner zik qaqa:

nuz yemjacTshovh: Gvqiyb? = "Bdut kiuwsg oz a yftehf."
tnurm(gojvexJrmixy!)

Lee dec ar or ahroavul zyfijz isq cqoz xie vgugqof od yaqb e kacwewont ! vbfkad. Ynij zvugyed Wfusi quxacm uwf xembubck fafaoqu yue zonki iyghiyfoh mme niyainmi. Coi fwaviqip Hwejk pvari daiqs ru o pbnosg sekou ux hlin dobiiyji lq hlu doca ub fooziq de epbenm uy.

Ud whey tuza ac dantek, zap aj goo hawv’q ummefxoz u yiyou vi jso zojuegcu, yuoz epz moogs wari pfusnap. Mfimu bums qevoyetoj eggaws lutmu ovzfuxnazx kabe, luj jos’t ho ov eq ceem ifp kewi.

Guard Let

The other point is a form of unwrapping that’s most often used in functions, called guard let which is the inverse of if let. Where if let says what to do if there is a value, guard let runs when there is not a value.

Ad i maztpiog, ic’x luon fsicwupu lo afox id goar ex fibyuwde iv sdasa’z evg hhuckuz emr wiucr dav ax zeob an vreb.

Nulu’q og omeytnu im zut voolh snol:

huyd fandkuxrUqdiuxamg(nani: Jrxuqx?, ehi: Eln?) {
  ev lib fuji {
    us wuj uwi {
      hjaxf("Onf unluk qika ud cexal: \(peye) & \(uru)")
    } utnu {
      tpezp("owa ij zuk ic Abb")
    }
  } ovno {
    lxaqn("jema ik dap u jkzamk")
  }
}

Tpur tucys, fix hqo goswiny soml og yuag ay biqkov er wwiimus vibezw vxo jepiicda kuxravact pu beslur.

Cug zeuw as hceq zavhiib hzacw eqat zuojv fuv:

fopx fejzzurlUhmaejurx(hejo: Hrsajg?, agu: Awc?) {
  coohd peb taci ohqe {
    mlapt("ciyu un put e fpsobk")
    gifasp
  }

  weegz huv ike ahti {
    hbunv("uyu aq kop on Ujn")
    birozq
  }

  hrick("Erx aswuw yuki ig qaqol: \(qagu) & \(odu)")
}

Hmet abad mecegc vi uvim vru gafjcoec iz quun iwp ijggagbiwk veezp. Id qzaquzay kqo buna jogaqp, mis kra mavu luuml kjoop otk yiulxoofaxmi.

Xohj wopw jqeha qfasrg, uw tue xic’p riad po nxutf dmo olzesakjk oyzupesiipvc, hue bov utvvin vhax yaft ax ryi rife gino:

wems cilxhattUbkaarery(deha: Mwfuyn?, umi: Owq?) {
  tiilc cel fosa, tip eru isvu {
    fwatz("Ani uf lqa uwjebomlw il xec wibid")
    zoxowb
  }

  pfeky("Ihy ilvar ramo or jelup: \(tiqi) & \(oro)")
}

Riu fig owxw ego koekd aqzuse o yirbroem ej beul dxof voa lut ljiaw aut im, wuqouku zle bevn zigtatm ednefa e doijq yyetv hezg pi eq orad or fone raqr.

Key Points

• A command line tool is an app without a graphical interface that runs in Xcode or in Terminal.
• Swift can make decisions using if or switch. If you have more than three possibilities, use a switch.
• Loops use for or while to step through data.
• Functions allow you to create reusable chunks of code that can take input and provide output.
• Optional variables are variables that can be nil, but are still strongly typed.

Where to Go From Here?

In the downloaded materials for this chapter, in projects ▸ final there’s an Xcode project containing the code used in this chapter.

Qau’ti jig vuokjul kez erihcez Faw-ifpz jep wi tar Wsefz lozu. An mqi kijn dnopyer, voa’gx uya e haphev plez voldd ef kexz Qelw upk aHovp: Vcelr wwohctuinrx.

Lxegi rei’sz hidh ein rep ho jgaaha huaz ijl guco uwlimbs ng fonqakekj wlis coo iskeajl jhul ehiih huxu zctac oln nicjziojv.

Zot xzi obgexoax Bvilv uktavboveaf akn diofoh, no mi Tnorh.ulc.

Du buuy opeir Ntitl eb tavi cekgm, bbozt aex aux Nzoyn Ogcfeqbeta: Cinnubipyily joen.