Go
funzioni

introduzione

Sintassi

• func () // tipo di funzione senza argomenti e senza valore di ritorno
• func (x int) int // accetta intero e restituisce un intero
• func (a, b int, z float32) bool // accetta 2 interi, uno mobile e restituisce un valore booleano
• func (prefisso stringa, valori ... int) // funzione "variadic" che accetta una stringa e uno o più numeri di interi
• func () (int, bool) // funzione che restituisce due valori
• func (a, b int, z float64, opt ... interface {}) (successo bool) // accetta 2 interi, un float e uno o più numeri di interfacce e restituisce il valore booleano denominato (che è già inizializzato all'interno della funzione )

Dichiarazione di base

Una semplice funzione che non accetta parametri e non restituisce alcun valore:

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

parametri

Una funzione può facoltativamente dichiarare una serie di parametri:

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

Si noti che il tipo per firstName è omesso perché è identico a lastName .

Valori di ritorno

Una funzione può restituire uno o più valori al chiamante:

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

Il secondo valore di ritorno può anche essere l'errore var:

import errors

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

Devono essere annotate due cose importanti:

• La parentesi può essere omessa per un singolo valore di ritorno.
• Ogni return istruzione deve fornire un valore per tutti i valori di ritorno dichiarati.

Valori di ritorno nominati

I valori di ritorno possono essere assegnati a una variabile locale. Un vuoto return dichiarazione può quindi essere utilizzata per restituire i loro valori correnti. Questo è noto come ritorno "nudo" . Le dichiarazioni di reso nude devono essere utilizzate solo in brevi funzioni poiché danneggiano la leggibilità in funzioni più lunghe:

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

giocarci sul campo da gioco

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

giocarci sul campo da gioco

Devono essere annotate due cose importanti:

• La parentesi attorno ai valori di ritorno è obbligatoria .
• Un vuoto return deve essere sempre fornita dichiarazione.

Funzioni e chiusure letterali

Una semplice funzione letterale, stampa Hello! allo stdout:

package main

import "fmt"

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

giocarci sul campo da gioco

Una funzione letterale, che stampa il str su stdout:

package main

import "fmt"

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

giocarci sul campo da gioco

Una funzione letterale, che si chiude sulla variabile str :

package main

import "fmt"

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

giocarci sul campo da gioco

È possibile assegnare una funzione letterale a una variabile:

package main

import (
    "fmt"
)

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

giocarci sul campo da gioco

Funzioni variabili

Una funzione variadica può essere chiamata con qualsiasi numero di argomenti finali . Questi elementi sono memorizzati in una sezione.

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")
}

giocarci sul campo da gioco

Puoi anche assegnare una sezione a una funzione variadica, con ... :

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

     variadic(strs...)
}

giocarci sul campo da gioco