Go
functies

Invoering

Syntaxis

• func () // functietype zonder argumenten en geen retourwaarde
• func (x int) int // accepteert een geheel getal en retourneert een geheel getal
• func (a, b int, z float32) bool // accepteert 2 gehele getallen, één float en retourneert een boolean
• func (voorvoegsel string, waarden ... int) // "variadic" -functie die een string en een of meer gehele getallen accepteert
• func () (int, bool) // functie retourneert twee waarden
• func (a, b int, z float64, opt ... interface {}) (succes bool) // accepteert 2 gehele getallen, een float en een of meer aantal interfaces en retourneert de naam booleaanse waarde (die al binnen de functie is geïnitialiseerd) )

Basisverklaring

Een eenvoudige functie die geen parameters accepteert en geen waarden retourneert:

func SayHello() {
    fmt.Println("Hello!")
}

parameters

Een functie kan optioneel een set parameters declareren:

func SayHelloToMe(firstName, lastName string, age int) {
    fmt.Printf("Hello, %s %s!\n", firstName, lastName)
    fmt.Printf("You are %d", age)
}

Merk op dat het type voor firstName wordt weggelaten omdat het identiek is aan lastName .

Retourwaarden

Een functie kan een of meer waarden aan de beller retourneren:

func AddAndMultiply(a, b int) (int, int) {
    return a+b, a*b
}

De tweede retourwaarde kan ook de error var zijn:

import errors

func Divide(dividend, divisor int) (int, error) {
    if divisor == 0 {
        return 0, errors.New("Division by zero forbidden")
    }
    return dividend / divisor, nil
}

Twee belangrijke dingen moeten worden opgemerkt:

• De haakjes kunnen worden weggelaten voor een enkele retourwaarde.
• Elke return verklaring moet een waarde voor alle aangegeven waarden terug te bieden.

Genoemde retourwaarden

Retourwaarden kunnen worden toegewezen aan een lokale variabele. Een lege return statement kan vervolgens worden gebruikt om hun huidige waarden retourneren. Dit staat bekend als "naakte" terugkeer. Naakte retourzendingen mogen alleen in korte functies worden gebruikt, omdat ze de leesbaarheid in langere functies schaden:

func Inverse(v float32) (reciprocal float32) {
    if v == 0 {
        return
    }
    reciprocal = 1 / v
    return
}

speel het op speelplaats

//A function can also return multiple values
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

speel het op speelplaats

Twee belangrijke dingen moeten worden opgemerkt:

• Het haakje rond de retourwaarden is verplicht .
• Er moet altijd een leeg return worden verstrekt.

Letterlijke functies en sluitingen

Een eenvoudige letterlijke functie, afdrukken Hello! naar stdout:

package main

import "fmt"

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

speel het op speelplaats

Een letterlijke functie, het str argument afdrukken naar stdout:

package main

import "fmt"

func main() {
    func(str string) {
        fmt.Println(str)
    }("Hello!")
}

speel het op speelplaats

Een letterlijke functie die de variabele str sluit:

package main

import "fmt"

func main() {
    str := "Hello!"
    func() {
        fmt.Println(str)
    }()
}

speel het op speelplaats

Het is mogelijk om een letterlijke functie toe te wijzen aan een variabele:

package main

import (
    "fmt"
)

func main() {
    str := "Hello!"
    anon := func() {
        fmt.Println(str)
    }
    anon()
}

speel het op speelplaats

Variadic functies

Een variadische functie kan worden opgeroepen met een willekeurig aantal volgargumenten . Die elementen worden opgeslagen in een segment.

package main

import "fmt"

func variadic(strs ...string) {
     // strs is a slice of string
     for i, str := range strs {
         fmt.Printf("%d: %s\n", i, str)
     }
}

func main() {
     variadic("Hello", "Goodbye")
     variadic("Str1", "Str2", "Str3")
}

speel het op speelplaats

Je kunt ook een segment geven aan een variadische functie, met ... :

func main() {
     strs := []string {"Str1", "Str2", "Str3"}

     variadic(strs...)
}

speel het op speelplaats