Explication détaillée du paramètre de longueur variable passant dans la fonction Golang

Golang est un langage de programmation qui a reçu une grande attention ces dernières années. Il a bien fonctionné à bien des égards. Parmi eux, le passage de paramètres de longueur variable aux fonctions est une fonctionnalité relativement spéciale, qui a un effet très pratique sur la synthèse des fonctions et la réduction de la redondance du code. Ensuite, explorons en détail le passage de paramètres de longueur variable des fonctions dans Golang.

1. Le concept de base du passage de paramètres de longueur variable

Dans Golang, comme dans certains autres langages de programmation, les fonctions peuvent accepter zéro ou plusieurs paramètres d'entrée. Le passage de paramètres de longueur variable est une syntaxe spéciale qui permet de transmettre n'importe quel nombre de paramètres à une fonction. Plus précisément, le passage de paramètres de longueur variable signifie spécifier que les paramètres sont de longueur variable en ajoutant "..." à la liste des paramètres de fonction, afin que n'importe quel nombre de paramètres puisse être accepté.

Ce qui suit est le format de base pour transmettre des paramètres de longueur variable :

func func_name(args ...type) return_type{

// function body

}

Parmi eux, args est le paramètre variable, type est le type de variable et return_type est le type de retour de la fonction.

Il convient de noter que toutes les valeurs des paramètres de longueur variable sont regroupées dans une tranche et transmises aux paramètres variables.

2. Comment utiliser les paramètres de longueur variable

L'utilisation des paramètres de longueur variable est très flexible et diversifiée. Ensuite, nous utiliserons un exemple de programme pour en savoir plus sur la façon d'utiliser cette fonctionnalité.

Supposons que nous devions implémenter une fonction pouvant recevoir trois types de paramètres d'entrée : des entiers, des chaînes et des nombres à virgule flottante, les additionner, les résumer et les imprimer. Une approche plus simple et plus grossière consiste à écrire trois fonctions différentes pour gérer différents types de paramètres d'entrée, mais cela rendra le code redondant et maladroit. En utilisant le passage de paramètres de longueur variable, nous pouvons résoudre ce problème avec élégance.

Le code est le suivant :

package main

import (

"fmt"

)

func Add(nums...interface{}) float64 {

var sum float64
for _, val := range nums {
    switch v := val.(type) {
    case int:
        sum += float64(v)
    case float64:
        sum += v
    case string:
        fmt.Println("Cannot add a string")
        continue
    }
}
return sum

}

func main() {

fmt.Println(Add(1, 2, 3, 4, 5))
fmt.Println(Add(1.0, 2.0, 3.0, 4.0))
fmt.Println(Add("hello", "world", "golang"))

}

us Une fonction Add est définie, qui a un paramètre nums de longueur variable et une valeur de retour de type float64. À l'intérieur de la fonction, nous initialisons d'abord une variable de somme pour stocker la somme de tous les paramètres d'entrée. Utilisez ensuite une boucle for et une plage pour parcourir la liste des paramètres var et effectuez différents traitements en fonction des différents types d'entrée.

Dans cet exemple, nous utilisons le jugement de type switch. Lorsque le paramètre d'entrée est de type int, nous le convertissons en type float64 et l'ajoutons à la somme ; lorsque le paramètre d'entrée est de type float64, il est ajouté directement à la somme lorsque le paramètre d'entrée est de type string, nous imprimons ; un message d'erreur et ignorez ce paramètre.

Dans la fonction principale, nous appelons respectivement la fonction Add et transmettons différents types de paramètres. C'est là toute la puissance des paramètres variadiques : quel que soit le nombre de paramètres de types différents que vous transmettez, ils peuvent tous être gérés par une fonction sans avoir à écrire une fonction pour chaque type.

3. L'essence des paramètres de longueur variable

Les paramètres de longueur variable sont essentiellement des types de tranche, c'est-à-dire qu'au lieu de transmettre chaque paramètre d'entrée à la fonction un par un, ils sont regroupés dans une tranche et transmis au paramètre variable. . Cela rend la transmission d'arguments de longueur variable plus efficace que la transmission d'un grand nombre d'arguments individuels.

Vous pouvez utiliser le verbe de formatage classique %v pour imprimer la valeur d'un paramètre de longueur variable :

func main() {

fmt.Printf("%v

", []string{"a", "b", "c"} )
}

Le résultat est : [a b c]

4. Notes

Il convient de noter que les paramètres variables doivent être placés en dernier dans la liste des paramètres de la fonction, sinon une erreur de compilation se produira. les paramètres variables sont équivalents à une tranche. Si Si vous le définissez avant d'autres paramètres dans la liste des paramètres, le compilateur ne peut pas déterminer sa longueur

De plus, bien que les paramètres variables puissent accepter n'importe quel nombre de paramètres, ils doivent être utilisés en fonction. la situation réelle afin d'éviter une utilisation excessive de la mémoire.

Conclusion

Les paramètres variables sont une fonctionnalité très pratique des fonctions Golang. Ils nous permettent d'utiliser un code plus concis et efficace pour gérer des fonctions avec un grand nombre de paramètres d'entrée lors de la programmation. processus, l'utilisation rationnelle des paramètres variables peut améliorer la fiabilité du code et la stabilité peut également rendre le programme plus facile à maintenir.

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!