Comment sont définies les fonctions en langage Go ?

Le langage Go est un langage de programmation moderne qui est bien accueilli et favorisé par de nombreux développeurs. Sa syntaxe est concise et claire, son efficacité d'exécution est élevée et il prend en charge la programmation simultanée. Il est particulièrement adapté à la création de programmes serveur hautes performances et à haute concurrence. En tant que langage de programmation orienté processus, les fonctions y jouent un rôle essentiel. Ensuite, cet article présentera comment les fonctions du langage Go sont définies.

1. Définition de base de la fonction

Dans le langage Go, le format de définition d'une fonction est le suivant :

func function_name(parameters) (return_type) {
    // 函数体
}

Où, nom_fonction représente le nom de la fonction, paramètres représente la liste des paramètres et type_retour représente le type de valeur de retour. Il convient de noter que les types de paramètres et de valeurs de retour des fonctions du langage Go peuvent être de tout type, y compris les types de base, les tableaux, les structures, les fonctions, etc.

2. Méthodes de transmission de paramètres

Il existe deux façons de transmettre des paramètres dans les fonctions du langage Go : la transmission de valeurs et la transmission de références. Dans la méthode de passage de valeur, la fonction reçoit une copie du paramètre ; dans la méthode de passage de référence, l'adresse du paramètre est transmise directement et les modifications apportées aux paramètres dans la fonction affecteront directement les paramètres eux-mêmes.

2.1. Méthode de transmission de valeur

Dans la méthode de transmission de valeur, les paramètres de la fonction sont basés sur une copie de la valeur plutôt que sur la valeur d'origine. La transmission de paramètres basés sur la valeur garantit que la valeur transmise reste toujours inchangée et ne peut donc pas être modifiée. Cette méthode convient au passage de paramètres de type simple, tels que int, float, string et d'autres types de base de passage de paramètres.

func main() {
    a := 5
    b := 10
    swap(a, b) // a 和 b 传递的是值的副本
    fmt.Println(a, b) // 输出 5 10
}
 
func swap(x, y int) int {
    temp := x
    x = y
    y = temp
    return temp
}

Dans le code ci-dessus, les paramètres reçus par la fonction swap sont des copies des valeurs, donc l'échange de x et y dans swap n'affectera pas les valeurs d'origine a et b transmises dans l'appel.

2.2. Méthode de passage de référence

Dans la méthode de passage de référence, les paramètres de la fonction reçoivent des adresses ou des pointeurs, et les paramètres peuvent être modifiés directement, changeant ainsi la valeur d'origine elle-même. Cette méthode convient au passage de paramètres de types de référence tels que des structures et des tranches.

type person struct {
    name string
    age int
}
 
func main() {
    p := person{name: "Tom", age: 20}
    modifyPerson(&p) // 传递 p 的地址
    fmt.Println(p) // 输出 {Jerry 30}
}
 
func modifyPerson(p *person) {
    p.name = "Jerry"
    p.age = 30
}

Dans le code ci-dessus, la fonction modifierPersonne reçoit un pointeur vers la structure de la personne, et peut directement modifier le contenu de la structure correspondant au paramètre. Par conséquent, une fonction qui modifie la valeur de p affecte la variable p d’origine.

3. Paramètres variables et valeurs de retour multiples des fonctions

Le langage Go prend en charge les fonctions transmettant un nombre variable de paramètres et prend en charge les opérations avec plusieurs valeurs de retour.

3.1. Paramètres variables

Si le nombre de paramètres d'une fonction est variable, vous pouvez utiliser la syntaxe des paramètres variables lors de la définition de la fonction. La syntaxe variadique utilise ... pour indiquer que la fonction accepte un nombre variable d'arguments. La fonction variadique du langage Go peut accepter n'importe quel nombre de paramètres, mais ces paramètres doivent être du même type.

func sum(nums ...int) int {
    res := 0
    for _, num := range nums {
        res += num
    }
    return res
}
 
func main() {
    fmt.Println(sum(1, 2, 3)) // 输出 6
    fmt.Println(sum(4, 5, 6, 7, 8)) // 输出 30
    fmt.Println(sum()) // 输出 0
}

Dans le code ci-dessus, les paramètres de la fonction sum utilisent une syntaxe de paramètre variable, qui peut accepter n'importe quel nombre de paramètres, puis les ajouter et renvoyer le résultat.

3.2. Plusieurs valeurs de retour

La fonction en langage Go peut avoir plusieurs valeurs de retour. Cette approche peut réduire le nombre d'appels de fonctions et améliorer la lisibilité du code.

func getNames() (string, string) {
    return "Tom", "Jerry"
}
 
func main() {
    firstName, lastName := getNames()
    fmt.Println(firstName, lastName) // 输出 Tom Jerry
}

Dans le code ci-dessus, la fonction getNames renvoie deux valeurs de type chaîne, à savoir Tom et Jerry. Vous pouvez utiliser plusieurs variables pour recevoir la valeur de retour de la fonction lorsque vous l'appelez.

4. Fonctions et fermetures anonymes

Le langage Go prend en charge les fonctions et fermetures anonymes. Une fonction anonyme est une fonction sans nom qui peut être directement définie et utilisée en cas de besoin ; une fermeture est une fonction anonyme qui porte un état et peut appeler des variables dans la fonction, mais ces variables ne sont visibles qu'à l'intérieur de la fermeture.

func main() {
    func() {
        fmt.Println("Hello World!")
    }()
 
    add := func(x, y int) int {
        return x + y
    }
    fmt.Println(add(1, 2)) // 输出 3
 
    n := 5
    func() {
        fmt.Println(n+1) // 输出 6
    }()
 
    fmt.Println(n) // 输出 5
}

Dans le code ci-dessus, la première fonction anonyme est définie et appelée directement dans la fonction principale sans nom. La deuxième fonction anonyme est affectée à la variable add et peut ensuite être appelée comme une fonction normale. La troisième fonction anonyme fait référence à la variable externe n afin que n+1 puisse être généré correctement. Étant donné que les fermetures portent un état, la valeur de la variable externe n ne sera pas modifiée une fois la fermeture exécutée.

En bref, les fonctions du langage Go sont des éléments de base très importants. Une bonne utilisation des fonctions nous permet d'écrire des programmes efficaces, faciles à utiliser et lisibles. J'espère que cet article vous a fourni une compréhension préliminaire des fonctions Go. Vous êtes invités à continuer à explorer les caractéristiques des fonctions Go en profondeur dans le développement futur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!