In dit artikel gaan we kijken hoe meerdere waardes teruggestuurd kunnen worden van een enkele functie in Go. Dit is een handig functie in vergelijking met de meeste programmeertalen die slechts één waarde kan terugsturen uit een functie. In de meeste programmeertalen kunnen meerdere waardes teruggestuurd worden door gebruikt te maken van tuples, hash, model of andere soort gelijk alternatieven. Go is één van de weinige programmeertalen die deze functie native ondersteunen. Een goed voorbeeld in Go is de strconv.Atoi() functie die string omzetten naar int.

Zie de volgende voorbeeld:

i := 2 // short declaration (1)
waarde, error := strconv.Atoi(i) // resultaat is een int waarde en foutmelding (indien de conversie mislukt)

In het eerste deel van (1) wordt een short declaration operator gebruikt die een variabel declaratie implementeert.

Functies die meerdere waarden retourneren

Zie het volgende voorbeeld:

func waardeVermenigvuldigen(waarde int) (doorgegevenWaarde int, waardeVermenigVuldigenMet10 int) {
  doorgegevenWaarde = waarde // 1
  waardeVermenigVuldigenMet10 = waarde * 10 // 2
  return
}

In het bovenstaande hierboven zien we hoe twee int-waarden teruggestuurd kunnen worden via een enkele functie. In deze functie wordt een int als parameter doorgegeven en vervolgens wordt de parameter (1) en een andere int-waarde teruggestuurd, de tweede waarde is de resultaat van de parameter vermenigvuldigd met 10 (2).

Retourneer van meer dan 2 waarden

In Go kan een functie meer dan twee waarden retourneren. Zo hoeft je geen speciale structuur te ontwikkelen om meer dan twee waarden te kunnen terugsturen uit één functie. In het volgende voorbeeld wordt vier waarden teruggestuurd, twee int-waarden, een float64 en een string.

func vierWaardenRetourneren() (int, int, float64, string){
  return 1,2,1.0,"string waarde"
}

Praktisch voorbeeld

Voor dit onderwerp, hebben we een eenvoudige Go app ontwikkeld die deze functie dekt. In dit voorbeeld gebruiken we de volgende Go pakketten: fmt, os en strconv.

Fmt pakket

Het fmt pakket implementeert het I/O functie die het mogelijk maakt om teksten op de console af te drukken. Voor een uitgebreide beschrijving lees de Golang fmt-pakket.

Os

Het os pakket heeft een interface die functionaliteiten van het besturingssysteem kan uitvoeren, en is platform onafhankelijk. Dit pakket is gebaseerd op een Unix ontwerp, maar de foutafhandeling is gebaseerd op Go. Lees de os-pakket documentatie voor meer informatie.

Strconv

Het strconv pakket biedt functionaliteiten voor string conversies aan op basis van de Go-types, lees Go basic types voor meer informatie over de Go types. Voor meer informatie over deze Go-pakket, lees de strconv documentatie.

Twee string waarden retourneren

In dit voorbeeld zullen we een eenvoudige functie illustreren die meerdere strings retourneren:

func tweeStringWaardesRetouneren() (waarde1 string, waarde2 string) {
  waarde1 = "waarde 1"
  waarde2 = "waarde 2"
  return
}

In het bovenstaande voorbeeld worden twee strings teruggestuurd, namelijk: waarde1 en waarde2. Waarde1 en waarde2 worden toegewezen in de functie. Het trefwoord return zonder argumenten zoals in dergelijke situatie automatisch signaleert aan de functie, dat de waarden geretourneerd moeten worden in de volgorde waarin ze gedeclareerd zijn. Dergelijke functie in Go staat bekend als Named returned values.

Tip: Het is zeer aanbevolen om zoveel mogelijk gebruikt te maken van deze functie in Go om onverwachte bugs te voorkomen in je applicatie.

Retourneer twee int waarden

In het vorige voorbeeld zagen we hoe twee string waarden geretourneerd kunnen worden in Go. Het volgende voorbeeld illustreert hoe twee int waarden teruggestuurd kunnen worden.

func waardeVermenigvuldigen(waarde int) (parameter int, parameterVermenigVuldigenMet10 int) {
  parameter = waarde
  parameterVermenigVuldigenMet10 = waarde * 10
  return
}

In dit voorbeeld heeft de functie één parameter en deze retourneert de parameter die doorgegeven is en de parameter waarde vermenigvuldigt met 10 parameterVermenigVuldigenMet10.

Waarden van verschillende Go typen retourneren

In het volgende voorbeeld implementeren we een functie die meerdere waarden (meer dan twee) van verschillende Go typen:

func waardesRetounerenVanVerschillendeTypes(waarde int) (int, int, string) {
  return waarde, waarde * 10, "Berekend"
}

Deze functie retourneert twee int en een string waarde. Zoals je kunt zien in de body van de functie, wordt de parameter toegewezen aan de eerste retourwaarde van het type int, de tweede andere retourwaarden is de parameter vermenigvuldig met 10 en de laatste parameter is een string waarde die aangeeft dat die berekening is voltooid.

Go functies uitvoeren

In al de vorige artikelen heb je zeker gemerkt dat iedere Go-app bevat een main functie en dat is de toegangspunt van de applicatie. Om onze voorbeeld Go app uit te kunnen voeren, moeten we deze hoofdfunctie implementeren. Zo’n hoofdfunctie ziet er als volgt eruit:

func main(){

  (1)
  fmt.Println("\n|------------- Twee string waardes terug sturen ------------------|")
  waarde1, waarde2 := tweeStringWaardesRetouneren()(1.1) 
  fmt.Println("Waarde 1: "+waarde1,"\nWaarde 2: "+ waarde2) (1.2) 
  fmt.Println("|-------------------------------------------------------------------|")

  (2)
  argument := os.Args (2.1)
   if len(argument) != 2 { (2.2)
     fmt.Println("Het programma heeft minimaal 1 argument nodig om de berekening uit te voeren")(2.3)
     return(2.4)
   }

  (3)
 argumentWaarde, error := strconv.Atoi(argument[1]) (3.1)
   if error != nil { (3.2)  
     fmt.Println(error) (3.3)
     return (3.4)
   }

(4)
fmt.Println("\n|------------- Twee int waardes retouneren ------------------|")
   doorgegevenWaarde, waardeVermenigVuldigenMet10 := waardeVermenigvuldigen(argumentWaarde)(4.1)

doorgegevenWaardeOmgezetNaarString := strconv.Itoa(doorgegevenWaarde)(4.2)

waardeVermenigVuldigenMet10OmgezetNaarString := strconv.Itoa(waardeVermenigVuldigenMet10)(4.3) 

fmt.Println("Argument waarde (int): "+ doorgegevenWaardeOmgezetNaarString)(4.4)
   
fmt.Println("Vermenigvuldig waarde (int): "+waardeVermenigVuldigenMet10OmgezetNaarString) (4.5)
fmt.Println("|-------------------------------------------------|")

 (5)
   fmt.Println("\n|------------ Waardes retouren van verschillende types --------------------|")
doorgegevenWaardes, doorgegevenWaardeVermenigvuldigMet10, taakResultaat := waardesRetounerenVanVerschillendeTypes(argumentWaarde)(5.1)

doorgegevenWaardesOmgezetNaarString := strconv.Itoa(doorgegevenWaardes) (5.2)

vermenigvuldigWaardeOmgezetNaarToString := strconv.Itoa(doorgegevenWaardeVermenigvuldigMet10)(5.3)

   fmt.Println("Doorgegeven int waarde : "+doorgegevenWaardesOmgezetNaarString)
   fmt.Println("Vermenigvuldigen int waarde : "+vermenigvuldigWaardeOmgezetNaarToString)
   fmt.Println("Taak resultaat string waarde: "+taakResultaat)
   fmt.Println("|------------------------------------------------------------------|")
}

Deel 1

Het eerste gedeelte van de hoofdfunctie is een eenvoudige functie die twee strings retourneert. Dit is de juiste implementatie om twee strings waarden uit een enkele functie terug te sturen in Go. Paragraaf 1.1 retourneert de twee strings waarden en druk vervolgens het resultaat af op de console 1.2.

Deel 2

In deze sectie gaan we de argument waarden ophalen (2.1) met behulp van de os.Args functie die toegang biedt tot de besturingssysteem opdrachtregelargumenten. Voordat we de argument waarden kunnen ophalen, moeten we controleren of het niet gelijk aan nil (2.2) is. Indien het gelijk aan nul is, zal het programma een bericht op de console (2.3) afdrukken. Ten slotte het trefwoord return beëindigt de uitvoering van het programma (2.4).

Deel 3

In de derde deel zullen we het argument int waarde op index 0 (index 1 in os.Args) omzetten naar een string (3.1). Op dezelfde regel controleren we of er een fout is opgetreden tijdens het conversie proces (3.2). De strconv.Atoi functie is een interne Go-functie die meerdere waarden retourneert. Indien er een fout optreedt, wordt deze afgedrukt op de console (3.3). Net als in de vorige voorbeeld return beëindigt het programma indien een fout is opgetreden (3.4).

Deel 4

Dit deel lijkt op het vorige voorbeeld, maar in dit geval hebben we te maken met twee int waarden die geretourneerd worden. We zullen meerdere int waarden terug sturen met behulp van de waardeVermenigvuldigen functie (4.1). In dit geval moeten we de int waarde omzetten naar een string met behulp van de strconv.Itoa functie (4.2). Dat geldt ook voor de vermenigvuldigde waarden (4.3) 4.4 en 4.5 druk het resultaat op de console af.

Deel 5

In het laatste onderdeel worden meerdere waarden teruggestuurd van de waardesRetounerenVanVerschillendeTypes functie. Het resultaat bestaat uit twee int en een string. De eerste int waarde wordt omgezet worden naar een string (5.2). De vermenigvuldigde waarde wordt ook omgezet naar een string (5.3). De rest van de code druk de resultaten op de console af.

Voor het volledig project zie de GoDevTips repository.

Om de repository te klonen en broncodes uitvoeren in macOS/OSX, lees de volgende artikel.

Om de repository te klonen en broncodes uitvoeren in Windows, lees de volgende artikel.

Om de repository te klonen en broncodes uitvoeren in Ubuntu (Linux), lees de volgende artikel.

Samenvatting

Het retourneren van meerdere waarden is een zeer handige feature in Go. Dit biedt zoveel flexibiliteit aan zonder te veel ingewikkelde stappen. Een andere handige functie is de Named returned values die je kan mee helpen om onverwachte bugs te voorkomen. In dit artikel hebben we enkele use-cases behandeld die je in de praktijk kan tegenkomen. Bijvoorbeeld het retourneren van meerdere strings, int en waarden van andere Go typen. Dergelijke functies zijn erg handig als het gaat om het ontwikkelen van webservices in Go. Webservices is een onderwerp die in een later artikel aan de orde komen.

Relevante bronnen:

Volg ons: