Swift leren met een Xcode Playground

Wil je Swift leren? In dit artikel maak je kennis met deze nieuwe programmeertaal door meteen ‘in het diepe te duiken’: we schrijven een eenvoudig programma dat twee getallen bij elkaar optelt en het resultaat op het scherm toont. We gaan aan de slag met een Xcode Playground en we gebruiken zogenaamde variabelen en constanten. Ook maken we kennis met een handige Swift-functie: print().

Variabelen en constanten

Swift leren betekent kennis maken met nieuwe concepten. Een van de eerste is het concept variabelen en constanten. Alle programmeertalen, dus ook Swift, gebruiken variabelen en constanten om tijdelijk informatie op te slaan. Een variabele is een ‘vakje’ waarin tijdelijk een waarde kan worden ‘opgeborgen’. Een constante is bijna hetzelfde, maar met één belangrijk verschil: het is een variabele waarvan de inhoud, zodra die is ‘opgeborgen’, niet meer kan worden veranderd.

Stel, we willen een programma schrijven dat twee getallen bij elkaar optelt en het resultaat op het scherm toont. Dit programma kan dan dus de volgende stappen bevatten:

1. Bewaar het eerste getal in een ‘vakje’.
2. Bewaar het tweede getal in een ‘vakje’.
3. Tel de inhoud van het eerste ‘vakje’ op bij de inhoud van het tweede ‘vakje’. Bewaar het resultaat in een derde ‘vakje’.
4. Toon de inhoud van het derde ‘vakje’ op het scherm.

Er bestaan, zoals je zojuist al las, twee soorten ‘vakjes’ in Swift: variabelen en constanten. In beide vakjes kunnen dezelfde dingen worden bewaard, maar er is een belangrijk verschil.

• De inhoud van een variabele kan worden vervangen door iets anders, zo vaak als je wilt.
• De inhoud van een constante kan naderhand niet meer worden veranderd. Je kunt de inhoud van een constante dus niet vervangen door iets anders.

De programmacode

De vier stappen van zojuist zie je nogmaals opgesomd in de volgende tabel.

Het enige dat we nu nog hoeven te doen, is deze stappen te vertalen in een werkend Swift-programma. Maak in Xcode een Playground (File → New → Playground) en zet er de volgende regels in:

links zie je de programmaregels en op de Resultaatbalk (de rechterkolom) zie je het resultaat van elke afzonderlijke regel. Ons programma werkt: de waarden 5 en 3 zijn bij elkaar opgeteld en het resultaat wordt, in een keurige zin, in de Console getoond.

Zie je geen Console? Open de Debug Area dan door View → Debug Area → Activate Console te kiezen.

Zó werkt ons eerste programma

We bespreken de programmacode uit deze Playground regel voor regel. Daarbij laten we de commentaarregels (de groene tekst) achterwege.

We hakken deze regel even in drieën:

• let a
  Het woord let geeft aan dat we met een constante gaan werken: een variabele waarvan de inhoud naderhand niet meer kan worden gewijzigd. Telkens als je in een Swift-programma het woord let tegenkomt, krijg je dus met een constante te maken.
  In ons geval is de naam van de constante a. Er staat hier dus eigenlijk:“Declareer een constante met de naam a.”
• =
  In programmeertalen zoals Swift staat één isgelijkteken voor het woord “wordt”. Met andere woorden: overal waar je in een Swift-programma één isgelijkteken tegenkomt, kun je dat vervangen door het woord “wordt”. We hebben nu dus het volgende:“Declareer een constante met de naam a. Deze constante wordt …”
• 5
  Dit is de waarde die we aan de constante met de naam a gaan toewijzen. Nu hebben we dus:“Declareer een constante met de naam a. Deze constante wordt 5.

Nadat deze regel is uitgevoerd, zal Swift dus overal waar het de constante a tegenkomt, deze vervangen door de inhoud van die constante: in ons geval de waarde 5. Op de Resultaatbalk zie je het resultaat van deze regel: de waarde 5 wordt afgebeeld om aan te geven dat onze constante a vanaf nu de waarde 5 als inhoud heeft.

Deze regel heeft een soortgelijke samenstelling als de vorige:

“Declareer een constante met de naam b. Deze constante wordt 3.”

Vanaf nu weet Swift dus dat de inhoud van de constante b gelijk is aan 3. Op de Resultaatbalk zie je dit nog eens weergegeven.

In deze regel gebeurt het! We hakken hem weer even in stukjes:

• let c =
  dit stukje ken je inmiddels:“Declareer een constante met de naam c. Deze constante wordt …”
• a + b
  Hier vindt de optelling plaats. Swift telt de inhoud van de constanten a (de waarde 5) en b (de waarde 3) bij elkaar op. Het resultaat van deze optelling, de waarde 8, wordt aan de constante c toegekend:“Declareer een constante met de naam c. Deze constante wordt de som van a en b.”

Vanaf dit moment bevat de constante c dus de waarde 8. Ook dat zie je op de Resultaatbalk.

Dit is de meest complexe regel die je tot nu toe hebt gezien. Wat deze regel doet, zie je in de Console: daar staat de tekst “De som van 5 en 3 is 8 .”.

Functies

Het belangrijkste onderdeel van deze regel is een zogenaamde functie, met de naam print. De print()-functie is één van de ‘legoblokjes’ van Swift. Je zult deze functie nog vaak tegenkomen: je gebruikt hem om tekst op de Console te laten tonen.

Tussen de haakjes zie je zeven zogenaamde argumenten staan: de print()-functie stuurt deze argumenten na elkaar naar de Console en zet er telkens een spatie achter. Tekst die tussen aanhalingstekens staat (zoals "De som van", "en", "is" en ".", zogenaamde strings) wordt rechtstreeks doorgestuurd. De overige drie argumenten, a, b en c, zijn de namen van de constanten die we zojuist hebben gebruikt; deze constanten worden ‘uitgepakt’ en de inhoud ervan wordt eveneens naar de Console gestuurd.

Onze print()-functie zorgt er dus voor dat de tekst “De som van 5 en 3 is 8 .” in de Console wordt neergezet. De print()-functie is heel handig als je met Playgrounds werkt; datgene wat je aan de functie ‘doorgeeft’ (ofte wel: wat je tussen de haakjes zet) wordt in de Console getoond.

Samenvattend doet de print()-functie dus het volgende:

• achter de haakjes staan één of meer argumenten, die van elkaar gescheiden zijn door komma’s.
• Een stuk tekst tussen aanhalingstekens, een zogenaamde string, wordt meteen op de Console weergegeven.
• Argumenten die geen string zijn, worden ‘uitgepakt’: de inhoud ervan wordt op de Console weergegeven.
• Na elk argument komt automatisch een spatie.

Separators

Kijk nog even naar de tekst in de console:

Zie je de spatie vóór de punt? Deze is daar door print() automatisch neergezet. Immers, achter elk van de argumenten komt een spatie.

In feite is die laatste spatie overbodig. Sterker nog: hoewel hij er automatisch is neergezet, hoort hij er eigenlijk niet te staan. Dat komt omdat er achter de zeven argumenten die we zojuist aan print() hebben opgegeven, eigenlijk een extra, onzichtbaar argument staat: separator: " ". Met separator: kun je aangeven welke tekens print() na elk van onze zeven argumenten moet tonen.

De complete regel is dus:

Kijk bijvoorbeeld eens wat er gebeurt als je de print()-regel als volgt aanpast:

Na elk argument wordt nu een liggend streepje afgedrukt.

Je kunt print() ook zeggen dat er ‘geen teken’ moet worden gebruikt om de argumenten van elkaar te scheiden:

Dit levert niet helemaal het resultaat op dat we willen. Nu zijn namelijk àlle spaties na de argumenten verdwenen:

De oplossing: we voegen de spaties toe aan de stukjes met letterlijke tekst: “De som van”, “en” en “is”.

Daarmee bereiken we ons doel: op alle plaatsen, behalve vóór de punt aan het eind van de zin, staat nu een spatie.

Een alternatieve methode: interpolatie

Eerlijk is eerlijk: de laatste print()-regel uit de vorige paragraaf is niet echt ongecompliceerd. Het resultaat is weliswaar precies wat we willen, maar acht argumenten om dat te bereiken… Kan dat niet anders?

Dat kan inderdaad anders. Kijk eens naar de volgende versie van onze print()-functie:

Deze regel levert ook het gewenste resultaat op:

Om precies te begrijpen hoe deze regel werkt, halen we hem even uit elkaar.

• \(a)
  Deze programmacode betekent letterlijk: “vervang deze code door de inhoud van de variabele of constante die tussen de haakjes staat”. Op de Console wordt dus in plaats van \(a) het getal 5 getoond (de inhoud van de constante met de naam a).
• \(b)
  Deze code betekent, op dezelfde manier als hierboven: “vervang deze code door de inhoud van b”. Op de Console staat dus niet “\(b)”, maar “3”.
• \(c)
  Waarschijnlijk snap je hem al: dit is een opdracht aan Swift om deze code te vervangen door de inhoud van de constante c: de waarde 8.
• “De som van \(a) en \(b) is \(c).”
  Dit is een string: een reeks tekens, tussen dubbele aanhalingstekens. Zoals je hiervóór hebt gezien, wordt \(a) vervangen door de inhoud van de constante met de naam a, \(b) wordt vervangen door de inhoud van de constante met de naam b enzovoort. Het resultaat van deze vervangingen is dus een nieuwe string: “De som van 5 en 3 is 8.”.
• print()
  Dit is de functie die zorgt voor de uitvoer naar de Console. In ons geval is dat dus de tekst hierboven: “De som van 5 en 3 is 8.”.

Maak je geen zorgen als je niet meteen begrijpt hoe dit werkt. Swift leren is, net als elk leerproces, een kwestie van dingen vaak doen!

Het verschil tussen variabelen en constanten

Zoals in het begin van dit artikel al stond: de waarde die je in een constante opslaat, kun je naderhand niet meer wijzigen. Dat kun je gemakkelijk zelf testen door aan je Playground de volgende regel toe te voegen, waarin we proberen om de variabele a een andere waarde te geven. Zet onderaan in je Playground, op een nieuwe regel, de volgende tekst:

Dit levert problemen op; vóór de regel verschijnt een rode badge.

Bovendien zie je bovenaan in de werkbalk van Xcode dat er iets mis is: rechts bovenaan staat ook een rode badge, die aangeeft dat Xcode een fout heeft ontdekt. Klik op de badge en Xcode meldt “cannot assign to value: ‘a’ is a ‘let’ constant”. Ofte wel: aan de ‘let’-variabele met de naam a (de constante die we in regel 4 hebben gedeclareerd en die de waarde 5 bevat) kan niet de waarde 7 worden toegewezen.

We moeten blijkbaar dus iets anders gebruiken: met de constante a komen we er niet, want we kunnen de inhoud ervan niet meer veranderen. De oplossing is eenvoudig: verander regel 4 van:

in:

Je ziet nu dat de rode badges verdwijnen en dat de Playground weer wordt uitgevoerd.

Wat hebben we nu precies gedaan? Dat is eenvoudig: we declareren niet langer een constante met de naam a, maar een variabele met de naam a. En van een variabele mag de waarde zo vaak worden gewijzigd als je wilt.

Wellicht vraag je je nu af waarom je niet gewoon altijd variabelen zou moeten gebruiken in plaats van constanten. Het antwoord op deze vraag: om redenen van veiligheid. Door constanten te gebruiken voor variabelen waarvan de waarde nooit meer mag veranderen, voorkom je bugs (fouten in je programma). Swift kan je dan namelijk helpen als je per ongeluk toch probeert om de waarde van zo’n constante te veranderen.

Stel dat we in onze voorbeeldcode de variabelen a, b en c nogmaals zouden willen gebruiken, voor bijvoorbeeld een tweede berekening. In dat geval gebruiken we dus geen let, maar var:

De inhoud van de Console verandert nu:

Door de asterisk (*) te gebruiken, kun je twee getallen met elkaar vermenigvuldigen. De regel c = a * b zorgt er dus voor dat de inhoud van de variabelen a en b met elkaar wordt vermenigvuldigd en dat het resultaat wordt opgeslagen in de variabele c.

Expressies en de print()-functie

Datgene wat tussen de haakjes staat in \(a), \(b) en \(c) wordt een expressie genoemd. Een andere expressie uit ons voorbeeldprogramma is a * b. Omdat tussen de haakjes elke willekeurige expressie mag staan, is de volgende regel dus ook correct:

Eigenlijk hebben we de variabele c dus niet nodig. Sterker nog, ook het volgende is toegestaan:

Dit levert het volgende resultaat op:

“5 keer 15 is 75.”

Grijze en zwarte tekst in de Resultaatbalk

Misschien is je al opgevallen dat de kleur van de tekst in de Resultaatbalk wisselt tussen zwart en grijs. Zodra de tekst grijs wordt, is Xcode aan het werk en worden de programmaregels verwerkt. Als dat eenmaal is gebeurd, wordt de tekst in de Resultaatbalk zwart.

Als de tekst grijs blijft, bevatten je programmaregels één of meer fouten waardoor Xcode de Resultaatbalk niet kan bijwerken.

Experimenteer zelf!

Swift leren is, zoals je in dit artikel hebt gezien, niet moeilijk. Experimenteer zelf verder met deze Playground. Declareer bijvoorbeeld eens een paar variabelen met wat langere namen, zoals getal1, getal2 en resultaat, en probeer ook eens te delen (met het teken /). Kijk eens wat er gebeurt als je probeert om een variabele door nul te delen. Maak je geen zorgen als er foutmeldingen en dergelijke verschijnen; er gaat niets kapot en van foutmeldingen leer je!

Swift leren: het eBook

Heeft dit artikel je enthousiast gemaakt en wil je meer over Swift leren? Dit artikel is afkomstig uit het eBook iOS Apps bouwen met Swift – Programmeren met Swift: ruim 400 pagina’s met alles wat je moet weten om zelf apps te kunnen bouwen – ook als je nog nooit eerder hebt geprogrammeerd.

Klik hier voor meer informatie over het eBook iOS Apps bouwen met Swift – Programmeren met Swift.