Fonctions en Go

En Go, les fonctions sont des blocs de code qui exécutent des tâches spécifiques, qui peuvent être réutilisées dans tout le programme pour économiser de la mémoire, améliorer la lisibilité et gagner du temps. Les fonctions Golang peuvent ou non renvoyer une valeur à l'appelant.

Choses à savoir sur les fonctions de Golang

• Syntaxe des fonctions en Golang
• Déclaration de fonction
• Fonction d'appel
• Arguments de fonction
  • Appel par valeur
  • Appel par référence

Par exemple:

package main
import "fmt"

// multiply() nhân 2 số nguyên và trả về kết quả
func multiply(a, b int) int {
    return a * b
}

func main() {
    result := multiply(5, 10)
    fmt.Printf("multiplication: %d", result)
}

Résultat:

multiplication: 50

Syntaxe des fonctions en Golang

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Déclaration de fonction

En Go, une fonction est déclarée avec le mot-clé func, suivi d'un nom, de paramètres et d'un type de retour facultatif.

Syntaxe

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Exemple de fonction de multiplication

func multiply(a, b int) int {
    return a * b
}

func : Mot clé pour déclarer une fonction.
function_name : le nom de la fonction, par exemple multiplier.
Liste de paramètres : a, b int : les paramètres ainsi que leurs types.
Return_type : int spécifie le type de retour.

Fonction d'appel

Pour utiliser une fonction, appelez simplement la fonction par son nom avec tous les arguments nécessaires. Ici, multiply(5, 10) appelle la fonction avec 5 et 10 comme arguments.

Par exemple

result := multiply(5, 10)
fmt.Printf("Result of multiplication: %d", result)

Arguments de fonction

Go prend en charge deux manières de transmettre des paramètres aux fonctions : l'appel par valeur et l'appel par référence. Par défaut, Go utilise l'appel par valeur, ce qui signifie que les valeurs sont copiées et que les modifications à l'intérieur de la fonction n'affectent pas les variables de l'appelant.

Appel par valeur

Dans l'appel par valeur, les valeurs des arguments sont copiées dans les paramètres de la fonction, de sorte que les modifications de la fonction n'affectent pas les variables d'origine.

Par exemple:

package main
import "fmt"

func multiply(a, b int) int {
    a = a * 2 // chỉnh sửa bên trong hàm này
    return a * b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(x, y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Résultat:

Before: x = 5, y = 10
multiplication: 100
After: x = 5, y = 10

Appel par référence

Dans l'appel par référence, des pointeurs sont utilisés pour que les modifications à l'intérieur de la fonction soient reflétées dans les variables de l'appelant.

Par exemple:

package main
import "fmt"

func multiply(a, b *int) int {
    *a = *a * 2 // chỉnh sửa giá trị của a ở địa chỉ bộ nhớ của nó
    return *a * *b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(&x, &y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Résultat

Before: x = 5, y = 10
multiplication: 100
After: x = 10, y = 10