Site Overlay

Je Eerste Programma

Traditioneel wordt het eerste programma dat je schrijft in een programmeertaal een “Hallo Wereld” programma genoemd – een programma dat simpelweg Hello World naar je terminal stuurt. Laten we er een schrijven met Go.

Maak eerst een nieuwe map waarin we ons programma kunnen opslaan. Maak een map met de naam ~/src/golang-book/chapter2. (Waar ~ je thuismap betekent) Vanaf de terminal kun je dit doen door de volgende commando’s in te voeren:

mkdir src/golang-bookmkdir src/golang-book/chapter2

Typ met uw tekstverwerker het volgende in:

package mainimport "fmt"// this is a commentfunc main() { fmt.Println("Hello World")}

Zorg ervoor dat je bestand identiek is aan wat hier wordt getoond en sla het op als main.go in de map die we zojuist hebben aangemaakt. Open een nieuwe terminal en type het volgende in:

cd src/golang-book/chapter2go run main.go

U zou Hello World in uw terminal moeten zien. Het go run commando neemt de volgende bestanden (gescheiden door spaties), compileert ze in een uitvoerbaar bestand dat in een tijdelijke directory wordt opgeslagen en voert dan het programma uit. Als u Hello World niet ziet, hebt u misschien een fout gemaakt bij het intypen van het programma. De Go compiler zal u hints geven over waar de fout zit. Zoals de meeste compilers, is de Go compiler extreem pedant en heeft geen tolerantie voor fouten.

Hoe een Go programma te lezen

Laten we dit programma eens in meer detail bekijken. Go programma’s worden van boven naar beneden, van links naar rechts gelezen. (als een boek) De eerste regel zegt dit:

package main

Dit staat bekend als een “package declaration”. Elk Go programma moet beginnen met een package declaratie. Packages zijn Go’s manier om code te organiseren en te hergebruiken. Er zijn twee soorten Go programma’s: uitvoerbare programma’s en bibliotheken. Uitvoerbare programma’s zijn het soort programma’s dat we direct vanaf de terminal kunnen uitvoeren. (In Windows eindigen ze op .exe) Bibliotheken zijn verzamelingen code die we samen verpakken zodat we ze in andere programma’s kunnen gebruiken. We zullen later meer in detail ingaan op bibliotheken, maar zorg er nu voor dat je deze regel opneemt in elk programma dat je schrijft.

De volgende regel is een lege regel. Computers geven nieuwe regels aan met een speciaal karakter (of meerdere karakters). Nieuwe regels, spaties en tabs staan bekend als witruimte (omdat je ze niet kunt zien). Go geeft meestal niet om witruimte, we gebruiken het om programma’s leesbaarder te maken. (Je zou deze regel kunnen verwijderen en het programma zou zich op precies dezelfde manier gedragen)

Dan zien we dit:

import "fmt"

Het import sleutelwoord is hoe we code van andere pakketten opnemen om te gebruiken met ons programma. Het fmt package (shorthand voor format) implementeert formattering voor input en output. Gegeven wat we zojuist geleerd hebben over packages, wat denk je dat de bestanden van het fmt package bovenaan zouden bevatten?

Merk op dat fmt hierboven omgeven is door dubbele aanhalingstekens. Het gebruik van dubbele aanhalingstekens als deze staat bekend als een “string literal”, wat een type “expressie” is. In Go vertegenwoordigen strings een opeenvolging van tekens (letters, cijfers, symbolen, …) met een bepaalde lengte. Strings worden in meer detail beschreven in het volgende hoofdstuk, maar voor nu is het belangrijk om in gedachten te houden dat een openend " karakter uiteindelijk moet worden gevolgd door een ander " karakter en dat alles tussen de twee wordt opgenomen in de string. (Het " karakter zelf is geen deel van de string)

De regel die begint met // staat bekend als een commentaar. Commentaar wordt genegeerd door de Go compiler en is er voor uw eigen bestwil (of voor degene die de broncode van uw programma ophaalt). Go ondersteunt twee verschillende stijlen van commentaar: // commentaar waarbij alle tekst tussen de // en het einde van de regel deel uitmaakt van het commentaar en /* */ commentaar waarbij alles tussen de *s deel uitmaakt van het commentaar. (En kan meerdere regels bevatten)

Daarna ziet u een functie-declaratie:

func main() { fmt.Println("Hello World")}

Functies zijn de bouwstenen van een Go programma. Ze hebben ingangen, uitgangen en een reeks stappen, statements genaamd, die in volgorde worden uitgevoerd. Alle functies beginnen met het sleutelwoord func gevolgd door de naam van de functie (main in dit geval), een lijst van nul of meer “parameters” omgeven door haakjes, een optioneel terugkeertype en een “body” die wordt omgeven door accolades. Deze functie heeft geen parameters, geeft niets terug en heeft slechts één statement. De naam main is speciaal omdat het de functie is die wordt aangeroepen als je het programma uitvoert.

Het laatste stuk van ons programma is deze regel:

 fmt.Println("Hello World")

Dit statement bestaat uit drie componenten. Eerst openen we een andere functie binnen het fmt pakket genaamd Println (dat is het fmt.Println stuk, Println betekent Print Line). Dan maken we een nieuwe string die Hello World bevat en roepen die functie aan (ook bekend als call of execute) met de string als het eerste en enige argument.

Op dit punt hebben we al veel nieuwe terminologie gezien en je bent misschien een beetje overweldigd. Soms helpt het om je programma opzettelijk hardop te lezen. Een voorlezing van het programma dat we net schreven zou als volgt kunnen gaan:

Maak een nieuw uitvoerbaar programma, dat verwijst naar de fmt bibliotheek en een functie bevat genaamd main. Die functie neemt geen argumenten, geeft niets terug en doet het volgende: Ga naar de Println functie die in het fmt pakket zit en roep die aan met één argument – de string Hello World.

De Println functie doet het echte werk in dit programma. Je kunt er meer over te weten komen door het volgende in je terminal te typen:

godoc fmt Println

Onder andere dingen zou je dit moeten zien:

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

Go is een zeer goed gedocumenteerde programmeertaal, maar deze documentatie kan moeilijk te begrijpen zijn tenzij je al bekend bent met programmeertalen. Niettemin is het godoc commando zeer nuttig en een goede plaats om te beginnen wanneer u een vraag heeft.

Terug naar de functie bij de hand, deze documentatie vertelt u dat de Println functie zal sturen wat je het geeft naar de standaard output – een naam voor de output van de terminal waar u in werkt. Deze functie is wat ervoor zorgt dat Hello World wordt weergegeven.

In het volgende hoofdstuk zullen we onderzoeken hoe Go dingen zoals Hello World opslaat en weergeeft door te leren over types.

Problemen

  • Wat is witruimte?

  • Wat is een commentaar? Wat zijn de twee manieren om een commentaar te schrijven?

  • Ons programma begon met package main. Waarmee zouden de bestanden in het fmt pakket beginnen?

  • We hebben de Println functie gebruikt die is gedefinieerd in het fmt pakket. Als we de functie Exit uit het pakket os willen gebruiken, wat moeten we dan doen?

  • Wijzig het programma dat we schreven zodat het in plaats van Hello World Hello, my name is afdruk, gevolgd door uw naam.

← Vorige Index

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd.