A függvény segítségével kódrészleteket foghatsz össze egy újrahasznosítható egységbe.
A függvény a func kulcsszóból, a függvény nevéből, valamint a kerek zárójelben álló, vesszővel elválasztott listából áll, amely nulla vagy több paramétert és azok típusát tartalmazza.
Függvényparaméterek
Minden paraméter típusát kifejezetten meg kell adni, a paramétereknél nincs típuskövetkeztetés.
A paramétereknek nincs alapértelmezett értékük, ezért minden függvényparaméter kötelező.
import "fmt"
// No parameters
func PrintHello() {
fmt.Println("Hello")
}
// Two parameters
func PrintGreetingName(greeting string, name string) {
fmt.Println(greeting + " " + name)
}
Az azonos típusú paraméterek együtt is megadhatók, ilyenkor egyetlen típusmegadás követi őket.
import "fmt"
func PrintGreetingName(greeting, name string) {
fmt.Println(greeting + " " + name)
}
Paraméterek és argumentumok
Nézzünk meg gyorsan két kifejezést, amelyeket gyakran összekevernek egymással: a parameters és az arguments.
A függvényparaméterek a függvény szignatúrájában megadott nevek, például a greeting és a name a fenti PrintGreetingName függvényben.
A függvényargumentumok azok a konkrét értékek, amelyeket a függvény meghívásakor adunk át a függvény paramétereinek.
Az alábbi példában például a "Hello" és a "Katrina" azok az argumentumok, amelyeket a greeting és a name paraméternek adunk át:
PrintGreetingName("Hello", "Katrina")
Visszatérési értékek
A függvényparamétereket nulla vagy több visszatérési érték követi, amelyek típusát szintén kifejezetten meg kell adni.
Az egyetlen visszatérési értéket zárójel nélkül hagyjuk, a többit zárójelbe tesszük.
A függvények a return kulcsszóval adják vissza az értékeket a hívó kódnak.
Egy függvényben több return utasítás is lehet.
A függvény végrehajtása azonnal véget ér, amint elér egy ilyen return utasítást.
Ha egy függvény több értéket ad vissza, azokat vesszővel választjuk el.
func Hello(name string) string {
return "Hello " + name
}
func HelloAndGoodbye(name string) (string, string) {
return "Hello " + name, "Goodbye " + name
}
Függvények meghívása
Egy függvényt úgy hívunk meg, hogy megadjuk a függvény nevét, és zárójelben átadunk egy argumentumot a függvény minden paraméteréhez.
import "fmt"
// No parameters, no return value
func PrintHello() {
fmt.Println("Hello")
}
// Called like this:
PrintHello()
// One parameter, one return value
func Hello(name string) string {
return "Hello " + name
}
// Called like this:
greeting := Hello("Dave")
// Multiple parameters, multiple return values
func SumAndMultiply(a, b int) (int, int) {
return a+b, a*b
}
// Called like this:
aplusb, atimesb := SumAndMultiply(a, b)
Nevesített visszatérési értékek és csupasz visszatérés
A paraméterekhez hasonlóan a visszatérési értékeket is el lehet nevezni.
Ha nevesített visszatérési értékeket használunk, akkor egy argumentum nélküli return utasítás ezeket az értékeket adja vissza.
Ezt nevezik „csupasz” visszatérésnek.
func SumAndMultiplyThenMinus(a, b, c int) (sum, mult int) {
sum, mult = a+b, a*b
sum -= c
mult -= c
return
}
Érték szerinti és referenciaszerinti átadás
Az is fontos, hogy tisztázzuk az érték szerinti és a referenciaszerinti átadás fogalmát.
Először tisztázzuk az érték szerinti átadást.
Az alábbi példában, amikor a val változót átadjuk a MultiplyByTwo függvénynek, a val egy másolatát adjuk át.
Emiatt a newVal a frissített 4 értéket kapja, az eredeti val változó viszont továbbra is 2.
A színfalak mögött a Go lényegében másolatot készít az eredeti értékről, így a függvény csak ezt a másolatot, azaz v-t módosítja.
val := 2
func MultiplyByTwo(v int) int {
v = v * 2
return v
}
newVal := MultiplyByTwo(val)
// newval is 4, val is still 2 because only a copy of its value was passed into the function
Szigorúan véve a Go-ban minden argumentum érték szerint adódik át, azaz másolat készül a függvénynek átadott értékről vagy adatról.
Ha viszont nem szeretnéd lemásolni a függvénynek átadott adatot, és a függvényen belül szeretnéd módosítani azt,
akkor argumentumként pointers-t kell használnod, ezt nevezik referenciaszerinti átadásnak.
Mutatók
A referenciaszerinti átadást egy pointer használatával érhetjük el.
Ha pointer argumentumokat adunk át egy függvénynek,
akkor a függvénynek átadott mögöttes adatot módosíthatjuk ahelyett, hogy csak az adat egy másolatán dolgoznánk.
Egyelőre elég annyit tudnod, hogy a mutatótípusokat a függvényszignatúrában a típus előtti * jelről ismerheted fel.
func HandlePointers(x, y *int) {
// Some logic to handle integer values referenced by pointers x and y
}
Ha zavarosnak tűnik a pointer fogalma, ne aggódj.
A tantervben később egy külön szakasz segít elsajátítani a mutatókat.
Kivételek
Vedd figyelembe, hogy a slices és a maps kivételt képez a fent említett szabály alól.
Amikor egy slice-ot vagy egy map-et argumentumként adunk át egy függvénynek, azokat a nyelv mutatótípusként kezeli, még akkor is, ha a típusban nincs kifejezett *.
Ez azt jelenti, hogy ha egy slice-ot vagy map-et adunk át egy függvénynek, és módosítjuk a mögöttes adatát,
a változások az eredeti slice-on vagy map-en is megjelennek.
Tanulófeladat
