Go
Les fonctions

Introduction

Syntaxe

• func () // type de fonction sans arguments et sans valeur de retour
• func (x int) int // accepte un entier et renvoie un entier
• func (a, b int, z float32) bool // accepte 2 entiers, un flottant et renvoie un booléen
• func (chaîne de préfixe, valeurs ... int) // Fonction "variadic" qui accepte une chaîne et un ou plusieurs nombres entiers
• func () (int, bool) // fonction renvoyant deux valeurs
• func (a, b int, z float64, opt ... interface {}) (succès bool) // accepte 2 entiers, un flottant et un ou plusieurs nombres d'interfaces et renvoie une valeur booléenne nommée (qui est déjà initialisée à l'intérieur de la fonction )

Déclaration de base

Une fonction simple qui n'accepte aucun paramètre et ne renvoie aucune valeur:

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

Paramètres

Une fonction peut éventuellement déclarer un ensemble de paramètres:

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

Notez que le type pour firstName est omis car il est identique à lastName .

Valeurs de retour

Une fonction peut renvoyer une ou plusieurs valeurs à l'appelant:

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

La deuxième valeur de retour peut également être l'erreur 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
}

Deux choses importantes doivent être notées:

• La parenthèse peut être omise pour une seule valeur de retour.
• Chaque déclaration de return doit fournir une valeur pour toutes les valeurs de retour déclarées.

Valeurs de retour nommées

Les valeurs de retour peuvent être affectées à une variable locale. Une déclaration de return vide peut alors être utilisée pour renvoyer leurs valeurs actuelles. Ceci est connu comme "nu" retour. Les instructions de retour naked ne doivent être utilisées que dans des fonctions courtes car elles nuisent à la lisibilité dans les fonctions plus longues:

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

jouer sur le terrain de jeu

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

jouer sur le terrain de jeu

Deux choses importantes doivent être notées:

• La parenthèse autour des valeurs de retour est obligatoire .
• Une déclaration de return vide doit toujours être fournie.

Fonctions littérales et fermetures

Une fonction littérale simple, impression Hello! à stdout:

package main

import "fmt"

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

jouer sur le terrain de jeu

Une fonction littérale, imprimant l'argument str à stdout:

package main

import "fmt"

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

jouer sur le terrain de jeu

Une fonction littérale, fermant la variable str :

package main

import "fmt"

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

jouer sur le terrain de jeu

Il est possible d'affecter une fonction littérale à une variable:

package main

import (
    "fmt"
)

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

jouer sur le terrain de jeu

Fonctions variadiques

Une fonction variadic peut être appelée avec un nombre quelconque d'arguments de fin . Ces éléments sont stockés dans une tranche.

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

jouer sur le terrain de jeu

Vous pouvez également donner une tranche à une fonction variadic, avec ... :

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

     variadic(strs...)
}

jouer sur le terrain de jeu