Comment les paramètres de la fonction Golang sont-ils transmis ?

Dans Go, il existe trois façons de transmettre des paramètres de fonction : passer par valeur (valeur ou copie), passer par référence (pointeur) et passer par référence immuable (référence de structure/tableau, objet non modifiable). Lorsqu'elle est passée par valeur, la fonction opère sur une copie de la valeur et n'affecte pas la valeur d'origine ; lorsqu'elle est passée par référence, la fonction peut modifier la valeur d'origine ; lorsqu'elle est passée par référence immuable, la fonction peut opérer sur les champs du ; objet, mais ne modifie pas l'objet lui-même. Ces trois méthodes conviennent à différents scénarios. Par exemple, le passage par valeur convient aux opérations en lecture seule, le passage par référence convient aux opérations de modification et le passage par référence immuable convient aux champs opérationnels de structures/tableaux.

Mécanisme de passage des paramètres de la fonction Go

Dans le langage Go, les paramètres de fonction sont passés de trois manières principales :

• Passage par valeur (appel par valeur) : Passer une valeur (ou une copie de la valeur) ) à la fonction.
• Pass by reference (appel par référence) : Passe un pointeur vers la valeur à la fonction afin que la fonction puisse modifier la valeur d'origine.
• Appel par valeur de référence immuable : Passer une référence immuable d'une structure ou d'un tableau à la fonction, afin que la fonction ne puisse pas modifier l'objet d'origine, mais puisse modifier ses champs (si la structure ou le tableau en a un).

Passage par valeur

Lorsque vous transmettez un paramètre par valeur, une copie de la valeur du paramètre est transmise. Toute modification de cette valeur n'affecte que la copie au sein de la fonction, pas la valeur d'origine.

func modifyValue(num int) {
    num *= 2
}

func main() {
    x := 10
    modifyValue(x)
    fmt.Println(x) // 输出：10
}

Pass par référence

Si vous souhaitez autoriser une fonction à modifier la valeur transmise, vous pouvez utiliser le passage de pointeur par référence. Ceci est accompli en déclarant un paramètre de pointeur en utilisant le préfixe *.

func modifyReference(num *int) {
    *num *= 2
}

func main() {
    x := 10
    modifyReference(&x)
    fmt.Println(x) // 输出：20
}

* 前缀来声明一个指针参数来实现。

type Point struct {
    x int
    y int
}

func modifyPoint(p Point) {
    p.x *= 2
}

func main() {
    point := Point{10, 20}
    modifyPoint(point)
    fmt.Println(point) // 输出：{20 20}
}

按不可变引用传递

结构体和数组可以通过传递其不可变引用来传递。这允许函数访问结构体或数组的字段，但不能修改对象本身。

import "fmt"

type Item struct {
    name  string
    price float64
}

func calculateTotalCost(items []Item) float64 {
    total := 0.0
    for _, item := range items {
        total += item.price
    }
    return total
}

func main() {
    items := []Item{
        {"Item 1", 10.00},
        {"Item 2", 20.00},
        {"Item 3", 30.00},
    }

    totalCost := calculateTotalCost(items)
    fmt.Println(totalCost) // 输出：60.00
}

实战案例

假设我们有一个函数 calculateTotalCost，它的作用是给定一个项目列表，计算它们的总成本。

rrreee

在这种情况下，items 作为一个按值传递的切片。这意味着该函数将收到 items

Passage par référence immuable🎜🎜🎜Les structures et les tableaux peuvent être transmis en passant leur référence immuable. Cela permet à la fonction d'accéder aux champs de la structure ou du tableau, mais pas de modifier l'objet lui-même. 🎜rrreee🎜🎜Cas pratique🎜🎜🎜Supposons que nous ayons une fonction calculateTotalCost, sa fonction est de calculer leur coût total à partir d'une liste d'articles. 🎜rrreee🎜Dans ce cas, items est passé sous forme de tranche par valeur. Cela signifie que la fonction recevra une copie de la variable items sans modifier la tranche d'origine. 🎜

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!