Fonctions du langage Go

函数通常是程序中的代码或语句块，使用户能够重复使用相同的代码，从而最终达到节省内存，节省时间，更重要的是，提供了更好的代码可读性。因此，基本上函数是语句的集合，这些语句执行某些特定的任务并将结果返回给调用方。函数也可以执行某些特定任务而无需返回任何内容。

函数声明

函数声明是一种构造函数的方法。

语法：

func　function_name(Parameter_list)(Return_type){
　　　　//　function　body.....
}

该函数的声明包含：

• func：它是Go语言的关键字，用于创建函数。

• function_name：它是函数的名称。

• Parameter_list：Contient le nom et le type des paramètres de la fonction.

• Contient le nom et le type des paramètres de la fonction.Return_type :

C'est optionnel, il contient le type de valeur retournée par la fonction. Si le return_type est utilisé dans la fonction, il est nécessaire d'utiliser la commande return.

Appel de fonction12,10）est appelé dans la fonction principale.

package main
import "fmt"
//area() est utilisé pour trouver la surface du rectangle
//Les deux paramètres de la fonction, à savoir la longueur et la largeur
func area(longueur, largeur int) int {
　　　　Ar := longueur　*　largeur
　　　　return Ar
}
func main() {
　　　　//Affichage de la surface du rectangle
　　　　//Appel par méthode
　　　　fmt.Printf("Surface du rectangle : %d", area(12,　10))
}

Sortie :

Surface du rectangle :　120

Paramètres de la fonction

Dans le langage Go, les paramètres passés à une fonction sont appelés paramètres réels (paramètres), et les paramètres reçus par la fonction sont appelés paramètres formels (paramètres).

Remarque :Par défaut, le langage Go utilise la méthode d'appel par valeur pour passer des paramètres à une fonction.

Le langage Go supporte deux méthodes de passage de paramètres à une fonction :

1. Appel par valeur：Dans cette méthode de passage de paramètres, la valeur du paramètre réel est copiée dans le paramètre formel de la fonction, et les deux types de paramètres sont stockés dans des emplacements de stockage différents. Par conséquent, toute modification apportée à l'intérieur de la fonction ne se reflète pas dans les paramètres réels de l'appelant.

   Exemple

   package main　
   　　　
   import "fmt"
   　　　
   //　Fonction d'échange de valeurs
   func swap(a, b int) int {　
   　　
   　　　　var o int
   　　　　o = a　
   　　　　a = b　
   　　　　b = o　
   　　　　　
   　　　return o　　
   }　
   　　　
   func main() {　
   　var p int =　10　
   　var q int =　20　
   　　fmt.Printf("p = %d et q = %d", p, q)　
   　　　
   　//　Appel par valeurs　
   　swap(p, q)　
   　　　fmt.Printf("\np = %d et q = %d", p, q)　
   }

   Sortie :

   p =　10　et q =　20
   p =　10　et q =　20

2. Appel par référence :Les paramètres réels et les paramètres formels pointent vers la même position, par conséquent, toute modification apportée à l'intérieur de la fonction se reflète réellement dans les paramètres réels de l'appelant.

   Exemple

   package main
   import "fmt"
   //Fonction d'échange de valeurs
   func swap(a, b　*int) int {
   　　　　var o int
   　　　　o =　*a
   　　　　*a =　*b
   　　　　*b = o
   　　　　return o
   }
   func main() {
   　　　　var p int =　10
   　　　　var q int =　20
   　　　　fmt.Printf("p = %d et q = %d", p, q)
   　　　　//Appel par référence
   　　　　swap(&p, &q)
   　　　　fmt.Printf("\np = %d et q = %d", p, q)
   }

   Sortie :

   p =　10　et q =　20
   p =　20 et q =　10