paramètres indéfinis de la fonction golang

Au cours du processus de développement, nous rencontrons souvent des situations où nous devons transmettre un nombre indéfini de paramètres. Par exemple, calculer la somme de deux nombres ou plus ou imprimer une chaîne. À l’heure actuelle, nous pouvons utiliser les caractéristiques des paramètres indéfinis des fonctions du langage Go pour résoudre le problème.

Le langage Go utilise la forme de... pour représenter les paramètres variables d'une fonction. Les types de paramètres variables peuvent être identiques ou différents. Lors de l'utilisation de paramètres indéfinis, la fonction peut recevoir n'importe quel nombre de paramètres, qui peuvent être un ensemble vide ou un ensemble contenant plusieurs éléments.

1. Syntaxe de base de la fonction à paramètres indéfinis

Ce qui suit est un exemple simple qui définit une fonction qui utilise... pour représenter des paramètres indéfinis, puis parcourt le tableau de paramètres et l'imprime :

func Sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

Le rôle de ce qui précède fonction Calcule la somme d'un ensemble d'entiers. Ensuite, nous appelons cette fonction :

Sum(1, 2, 3, 4)
Sum(1, 2, 3)

Les résultats d'exécution sont les suivants :

[1 2 3 4] 10
[1 2 3] 6

On peut voir que nous avons appelé la fonction Somme deux fois à la fois, en passant quatre paramètres la première fois et trois paramètres la deuxième fois. la somme correspondante est calculée avec succès.

2. Utiliser des tranches pour des fonctions à paramètres indéfinis

Nous pouvons utiliser le découpage pour gérer des fonctions à paramètres indéfinis. Lorsque vous utilisez des paramètres variables dans des tranches, nous pouvons d'abord charger tous les paramètres dans la tranche, puis utiliser la tranche pour les opérations ultérieures.

Dans l'exemple suivant, nous utilisons d'abord la méthode make() pour initialiser la tranche contenant tous les paramètres, puis parcourons la tranche et calculons la somme :

func Sum(nums ...int) {
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

Nous appelons à nouveau la fonction Sum(), en passant les mêmes paramètres qu'avant :

nums := []int{1, 2, 3, 4}
Sum(nums...)

Le résultat d'exécution de cette fonction est le même qu'avant, le résultat est :

10

3. Utilisé en combinaison avec des paramètres ordinaires

Les fonctions de paramètres indéfinis peuvent être très utiles en combinaison avec des paramètres ordinaires. Par exemple, nous pouvons utiliser une fonction d'argument variable avec un paramètre de chaîne qui représente les informations à imprimer. Par exemple :

func PrintStrings(separator string, strs ...string) {
    fmt.Println(strings.Join(strs, separator))
}

La fonction de cette fonction est de connecter certaines chaînes via le séparateur spécifié, puis de les imprimer. Nous appelons d'abord cette fonction et transmettons les trois chaînes à connecter et le symbole de connexion :

PrintStrings(", ", "a", "b", "c")

Les résultats d'exécution sont les suivants :

a, b, c

4. Détails de l'utilisation de la fonction de paramètre variable

Lors de l'utilisation de la fonction de paramètre variable, nous il faut faire attention à quelques détails. Voici quelques détails à noter :

• Le paramètre variable doit être le dernier paramètre de la fonction.
• La priorité entre les fonctions à paramètres variables et les fonctions ordinaires doit être notée.
• Divers paramètres peuvent être transmis en tant que paramètres de fonctions, et les valeurs de ces paramètres peuvent être modifiées à l'aide d'opérations de pointeur.

5. Résumé

L'utilisation de fonctions à paramètres indéfinis peut facilement gérer un nombre dynamique de paramètres, ce qui rend l'écriture de code plus facile et plus flexible. Il convient de noter que lors de l’appel d’une fonction à paramètre variable, nous devons transmettre les paramètres de la manière prescrite.

Grâce à cet article, nous avons appris la syntaxe des paramètres de fonction en langage Go et comment utiliser les fonctions à paramètres variables pour gérer un nombre dynamique de paramètres. En développement, l'utilisation rationnelle des fonctions à paramètres variables améliorera considérablement la qualité et l'efficacité du code.

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!