func plus(a int, b int) int {
    return a + b
}

• La fonction reçoit deux arguments a et b qui sont déclarés comme int
• En sortie, la fonction renvoie un int

L'exécution de cette fonction est habituel

x := plus(4, 7)

Une fonction Go peut renvoyer simultanément plusieurs résultats :

func exemple(a int) (int, int){
    carre := a*a
    cube := a*a*a
    return carre, cube
}

Et l'exécution prendrait la forme

x, y := exemple(3)

Ici, x reçoit le premier élément du retour de fonction, c'est à dire le carré, et y reçoit le second, donc le cube.

Comme en lua, il est possible de ne laisser de côté un des retours en utilisant _

_, y := exemple(3)

'_' n'est pas un nom de variable. Cette ligne signifie que la première partie du retour, le carré, n'est pas utilisée. '_' est comme une variable que l'on met aussitôt à la poubelle.

Renvoyer une donnée complexe comme un tableau est beaucoup plus simple qu'en C, on n'a pas de problématique de gestion de mémoire, mais la déclaration n'est pas si évidente. Par exemple, déclarons une fonction qui renvoie un tableau de 6 entiers. Je donne tout le programme pour voir aussi l'utilisation.

package main

import "fmt"

func main() {
    x := buildIntArray()
    fmt.Println("tout le tableau : ", x)
}

func buildIntArray() [6]int{
    a := [6]int{10, 32, 27, 14, 61, 12}
    return a
}

Comme vous pouvez le voir, la taille du tableau doit être connue. Si on a besoin d'un équivalent sans avoir à connaître la taille à la compilation, il faut utiliser un slice.

package main

import "fmt"

func main() {
    x := buildIntSlice(2)
    fmt.Println("tout le slice : ", x)
    x[1] = 13
    x = append(x, 17)
    fmt.Println("tout le slice : ", x)
}

func buildIntSlice(size int) []int{
    s := make([]int, size)
    return s
}

Comme en C, on peut vouloir que la fonction modifie un argument. En Go, on ne pourra passer que par l'usage de pointeurs.

package main

import "fmt"

func main(){
    x := 13;
    fmt.Println(x)
    change(&x)   
    fmt.Println(x)
}

func change(a *int){
    *a = *a + 1
}

• ligne 8 : à la fonction change, au lieu de transmettre x, on transmet son adresse &x.
• ligne 12 : dans la définition de change, on indique bien que l'argument n'est pas un entier mais une adresse d'entier, un pointeur *int donc.
• ligne 13 : c'est le contenu pointé par a qui change, on travaille donc sur *a ce qui désignera ici le contenu de x.