Je eerste Swift-programma

./images/user/0000005-0000001-060567800.png

Dit artikel is afkomstig uit het eBook Apps bouwen met Swift. Met dit eBook van bijna 300 pagina's leer je in korte tijd hoe je met Swift zelf complete iOS-apps kunt maken.

De beste manier om kennis te maken met Swift is 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. Hiervoor maken we gebruik van zogenaamde variabelen en constanten. Ook maken we kennis met een handige Swift-functie: println().

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 een variabele waarvan de inhoud niet 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.

De vier stappen van ons programma

Het enige dat we nu nog hoeven te doen, is deze stappen te vertalen in een werkend Swift-programma. Maak je Playground leeg (of maak een nieuwe!) en zet de volgende regels in je Playground:

// Playground - noun: a place where people can play

// Stap 1:
let a = 5           // Het eerste getal

// Stap 2:
let b = 3           // Het tweede getal

// Stap 3:
let c = a + b       // Het resultaat

// stap 4:
println("De som van \(a) en \(b) is \(c)”)

Het resultaat van deze Playground zie je hieronder: 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 Timeline getoond.

Het resultaat van onze Playground

Zie je geen Timeline? Open dan de Assistant Editor door View Assistant Editor Show Assistant Editor 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.

let a = 5

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.

let b = 3

Deze regel heeft een soortgelijke samenstelling als de vorige:

“Declareer een contante 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.

let c = a + b

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.

println("De som van \(a) en \(b) is \(c)")

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

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

  • \(a)
    Deze code betekent letterlijk: “vervang deze code door de inhoud van de variabele of constante die tussen de haakjes staat”. Op de Resultaatbalk 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 Resultaatbalk 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 zogenaamde 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 Het resultaat van deze vervangingen is dus een nieuwe string: “De som van 5 en 3 is 8”.

  • println()
    Dit is een functie die datgene wat tussen haakjes staat, uitvoert naar de console of naar de Timeline. In ons geval is dat dus de tekst hierboven: “De som van 5 en 3 is 8” (zie Afbeelding 9).
    De println()-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 Timeline getoond.

Het verschil tussen variabelen en constanten

Zoals in het begin van dit artikel al werd opgemerkt: 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 op regel 15 de volgende tekst:

a = 7

Dit levert problemen op, zoals je in de volgende afbeelding kunt zien: vóór de regel verschijnt een rood uitroepteken.

Dit gebeurt er als je probeert om een constante te veranderen

Bovendien zie je in de Timeline (zie hieronder) dat er iets mis is: Xcode meldt “cannot assign to 'let' value ‘a' a = 7”. 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.

De foutmelding in de Timeline

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:

let a = 5           // Het eerste getal

in:

var a = 5           // Het eerste getal

Je ziet nu dat het rode uitroepteken op regel 15 verdwijnt en dat de waarschuwing uit de Timeline is verdwenen:

De fout is verbeterd

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:

// Playground - noun: a place where people can play

// Stap 1:
var a = 5           // Het eerste getal

// Stap 2:
var b = 3           // Het tweede getal

// Stap 3:
var c = a + b       // Het resultaat

// stap 4:
println("De som van \(a) en \(b) is \(c)")

a = 7
b = 12
c = a * b

println("\(a) keer \(b) is \(c)")

De inhoud van de Timeline verandert nu, zoals je in hieronder kunt zien. 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.

Twee variabelen vermenigvuldigen

Expressies en de println()-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:

println("\(a) keer \(b) is \(a * b)")

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

println("5 keer 15 is \(5 * 15)”)

Dit levert het volgende resultaat op (op de Resultaatbalk en in de Timeline te zien):

“5 keer 15 is 75"

Experimenteer zelf!

Ik raad je aan om, voordat je verder leest, wat verder te experimenteren met deze Playground. Declareer bijvoorbeeld eens een paar nieuwe variabelen met wat langere namen, zoals getal1, getal2 en resultaat, en probeer ook eens te delen (met het teken ). Kijk bijvoorbeeld 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 kan niets kapot en van foutmeldingen leer je!

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.

Dit artikel is afkomstig uit het eBook Apps bouwen met Swift. Met dit eBook van bijna 300 pagina's leer je in korte tijd hoe je met Swift zelf complete iOS-apps kunt maken. Klik hier voor meer informatie over dit eBook