Passage de tableaux aux fonctions en Go
En Go, les tableaux sont des types valeur, donc lorsqu'un tableau est passé à une fonction, une copie du tableau est effectivement passée.
Si vous souhaitez passer un paramètre de tableau à une fonction, vous devez déclarer le paramètre formel comme un tableau dans la définition de la fonction. Nous pouvons le déclarer de deux façons :
Méthode 1
Spécifier la taille du tableau dans les paramètres formels :
func myFunction(param [10]int) {
....
}
Méthode 2
Ne pas spécifier la taille du tableau dans les paramètres formels :
func myFunction(param []int) {
....
}
Si vous souhaitez modifier le tableau d'origine à l'intérieur d'une fonction, vous pouvez le faire en passant un pointeur vers le tableau.
Exemple
Regardons l'exemple suivant. Dans cet exemple, la fonction reçoit un paramètre de tableau d'entiers, un autre paramètre spécifie le nombre d'éléments dans le tableau, et elle renvoie la valeur moyenne :
Exemple
{
var i int
var avg, sum float32
for i = 0; i < size; ++i {
sum += arr[i]
}
avg = sum / size
return avg;
}
Ensuite, appelons cette fonction :
Exemple
import "fmt"
func main() {
/* La longueur du tableau est 5 */
var balance = [5]int {1000, 2, 3, 17, 50}
var avg float32
/* Le tableau est passé en paramètre à la fonction */
avg = getAverage( balance, 5 ) ;
/* Afficher la moyenne retournée */
fmt.Printf( "Valeur moyenne : %f ", avg );
}
func getAverage(arr [5]int, size int) float32 {
var i,sum int
var avg float32
for i = 0; i < size;i++ {
sum += arr[i]
}
avg = float32(sum) / float32(size)
return avg;
}
Le résultat de sortie de l'exemple ci-dessus est :
平均值为: 214.399994
Dans l'exemple ci-dessus, les paramètres formels que nous avons utilisés ne précisaient pas la taille du tableau.
Les calculs en virgule flottante peuvent présenter une certaine déviation dans la sortie ; vous pouvez également convertir en un type entier pour définir la précision.
Exemple
import (
"fmt"
)
func main() {
a := 1.69
b := 1.7
c := a * b // Le résultat doit être 2.873
fmt.Println(c) // La sortie est 2.8729999999999998
}
Définir une précision fixe :
Exemple
import (
"fmt"
)
func main() {
a := 1690 // Représente 1.69
b := 1700 // Représente 1.70
c := a * b // Le résultat doit être 2873000, représentant 2.873
fmt.Println(c) // Encodage interne
fmt.Println(float64(c) / 1000000) // Affichage
}
Si vous souhaitez modifier le tableau d'origine à l'intérieur d'une fonction, vous pouvez le faire en passant un pointeur vers le tableau.
L'exemple suivant montre comment passer un tableau à une fonction. La fonction accepte un tableau et un pointeur vers le tableau comme paramètres :
Exemple
import "fmt"
// La fonction accepte un tableau comme paramètre.
func modifyArray(arr [5]int) {
for i := 0; i < len(arr); i++ {
arr[i] = arr[i] * 2
}
}
// La fonction accepte un pointeur vers un tableau comme paramètre.
func modifyArrayWithPointer(arr *[5]int) {
for i := 0; i < len(*arr); i++ {
(*arr)[i] = (*arr)[i] * 2
}
}
func main() {
// Créer un tableau d'entiers contenant 5 éléments.
myArray := [5]int{1, 2, 3, 4, 5}
fmt.Println("Tableau d'origine :", myArray)
// Le passage d'un tableau à une fonction ne modifie pas la valeur du tableau d'origine.
modifyArray(myArray)
fmt.Println("Tableau après modifyArray :", myArray)
// Passer un pointeur vers un tableau à une fonction peut modifier la valeur du tableau d'origine.
modifyArrayWithPointer(&myArray)
fmt.Println("Tableau après modifyArrayWithPointer :", myArray)
}
Dans l'exemple ci-dessus, la fonction modifyArray accepte un tableau et tente de modifier les valeurs du tableau, mais après l'avoir appelée dans la fonction main, le tableau d'origine n'a pas été modifié. En revanche, la fonction modifyArrayWithPointer accepte un pointeur vers le tableau et modifie les valeurs du tableau d'origine via le pointeur.
Le résultat de sortie de l'exemple ci-dessus est :
Original Array: [1 2 3 4 5] Array after modifyArray: [1 2 3 4 5] Array after modifyArrayWithPointer: [2 4 6 8 10]autres extensions