Méthode d'application des paramètres de tableau de la fonction Golang

Méthode d'application des paramètres du tableau de fonctions Golang

Golang est un langage de programmation open source facile à apprendre, efficace et sûr, et doté de fonctionnalités de récupération de place. Les tableaux sont un type de données très basique dans Golang. Les tableaux sont également un moyen courant d'écrire des programmes en tant que paramètres de fonction. Cet article présentera la méthode d'application des tableaux comme paramètres de fonction dans Golang, dans l'espoir d'inspirer les lecteurs dans l'application des fonctions Golang.

1. Passer des tableaux en tant que paramètres par valeur

Lorsque vous transmettez des tableaux comme valeur d'une fonction, les paramètres formels de la fonction obtiendront une copie égale à la valeur réelle du paramètre, et les modifications apportées aux paramètres formels dans la fonction seront n'affecte pas les paramètres réels. Cette méthode convient aux situations où vous devez effectuer des opérations simples sur le tableau dans une fonction.

Par exemple, le code suivant :

package main

import "fmt"

func modifyArr(arr [3]int) {
    for i := 0; i < len(arr); i++ {
        arr[i] += i
    }
}

func main() {
    var arr [3]int = [3]int{1, 2, 3}
    fmt.Printf("Before modified, arr = %v
", arr)
    modifyArr(arr)
    fmt.Printf("After modified, arr = %v
", arr)
}

Le résultat de sortie est le suivant :

Before modified, arr = [1 2 3]
After modified, arr = [1 2 3]

On constate que même si le tableau est modifié dans la fonction modifierArr, la valeur du tableau ne change pas lorsque la valeur de le tableau est imprimé dans la fonction principale.

2. Passer des paramètres en utilisant des tableaux comme pointeurs

Lors du passage de paramètres en utilisant des tableaux comme pointeurs vers des fonctions, la fonction peut modifier directement le groupe de paramètres réel. Cette méthode convient aux situations où des opérations plus complexes doivent être effectuées dans la fonction.

Ce qui suit est un exemple de code :

package main

import "fmt"

func modifyArrByPointer(arr *[3]int) {
    for i := 0; i < len(arr); i++ {
        arr[i] += i
    }
}

func main() {
    var arr [3]int = [3]int{1, 2, 3}
    fmt.Printf("Before modified, arr = %v
", arr)
    modifyArrByPointer(&arr)
    fmt.Printf("After modified, arr = %v
", arr)
}

Le résultat de sortie est le suivant :

Before modified, arr = [1 2 3]
After modified, arr = [1 3 5]

Comme vous pouvez le voir, dans la fonction modifierArrByPointer, nous modifions le tableau via des opérations de pointeur.

3. Passer des paramètres de tableau en tant que tranches

Lors du passage de tableaux en tant que paramètres de tranche d'une fonction, toutes les opérations de découpage du tableau peuvent être utilisées à l'intérieur de la fonction. L'avantage de cette méthode est que le tableau entier n'est pas copié, mais uniquement. la référence est passée. Cette méthode convient aux scénarios dans lesquels le découpage est nécessaire pour fonctionner sur des tableaux.

Par exemple, le code suivant :

package main

import "fmt"

func modifyArrBySlice(arr []int) {
    for i := 0; i < len(arr); i++ {
        arr[i] += i
    }
}

func main() {
    var arr [3]int = [3]int{1, 2, 3}
    fmt.Printf("Before modified, arr = %v
", arr)
    modifyArrBySlice(arr[:])
    fmt.Printf("After modified, arr = %v
", arr)
}

Le résultat de sortie est le suivant :

Before modified, arr = [1 2 3]
After modified, arr = [1 3 5]

Comme vous pouvez le voir, dans les paramètres de la fonction modifierArrBySlice, nous utilisons arr[:] pour passer la tranche du tableau In. de cette façon, le tableau peut être modifié par l'opération de découpage.

4. Champs de tableau dans les structures en tant que paramètres

Dans Golang, les structures peuvent également contenir des champs de type tableau. Lors du passage d'une structure dans une fonction, vous pouvez choisir de transmettre une référence ou une valeur de la structure pour opérer sur le tableau.

Par exemple, le code suivant :

package main

import "fmt"

type ArrStruct struct {
    arr [3]int
}

func modifyArrByStruct(s ArrStruct) {
    for i := 0; i < len(s.arr); i++ {
        s.arr[i] += i
    }
}

func modifyArrByStructPointer(s *ArrStruct) {
    for i := 0; i < len(s.arr); i++ {
        s.arr[i] += i
    }
}

func main() {
    var s ArrStruct = ArrStruct{[3]int{1, 2, 3}}
    fmt.Printf("Before modified, arr = %v
", s.arr)
    modifyArrByStruct(s)
    fmt.Printf("After modified by value, arr = %v
", s.arr)
    modifyArrByStructPointer(&s)
    fmt.Printf("After modified by pointer, arr = %v
", s.arr)
}

Le résultat de sortie est le suivant :

Before modified, arr = [1 2 3]
After modified by value, arr = [1 2 3]
After modified by pointer, arr = [1 3 5]

Vous pouvez voir que lorsque nous passons la structure comme valeur de la fonction, la fonction ne peut pas modifier la valeur de sa variable membre, mais la structure est utilisée comme fonction Lors du passage de paramètres via un pointeur, ses variables membres peuvent être modifiées.

Résumé :

Dans Golang, il existe trois façons d'utiliser des tableaux comme paramètres de fonctions : le passage de valeur, le passage de pointeur et le passage de tranche. Le passage de valeurs convient aux scénarios d'opérations simples, le passage de pointeurs convient aux scénarios nécessitant des opérations complexes à l'intérieur de fonctions et le passage de tranches convient aux scénarios nécessitant des opérations de découpage sur des tableaux. De plus, dans la structure, si le tableau est une variable membre de la structure, vous pouvez choisir d'utiliser le pointeur de la structure pour transmettre les paramètres à modifier. Dans les applications réelles, les développeurs doivent choisir la méthode de transfert de paramètres appropriée en fonction des besoins spécifiques.

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!