====== Fonctions ======

<Code:go>
func plus(a int, b int) int {
    return a + b
}
</Code>

  * 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

<Code:go>
x := plus(4, 7)
</Code>

===== Fonctions à retours multiples =====

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

<Code:go>
func exemple(a int) (int, int){
    carre := a*a
    cube := a*a*a
    return carre, cube
}
</Code>

Et l'exécution prendrait la forme

<Code:go>
x, y := exemple(3)
</Code>

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 [[nsi:langages:lua:fonctions#fausses variables|lua]], il est possible de ne laisser de côté un des retours en utilisant ''_''

<Code:go>
_, y := exemple(3)
</Code>

''%%'_'%%'' 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 un tableau =====

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.//

<Code:go>
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
}
</Code>

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.

<Code go>
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
}
</Code>

===== Modifier un argument =====

Comme en [[nsi:langages:c:fonctions#Modifier un argument|C]], on peut vouloir que la fonction modifie un argument. En Go, on ne pourra passer que par l'usage de [[.:pointeurs|pointeurs]].

<Code:go linenums=1>
package main

import "fmt"

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

func change(a *int){
    *a = *a + 1
}
</Code>

  * 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 [[.:pointeurs|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%%''.