Wie werden Golang-Funktionsparameter übergeben?

In Go gibt es drei Möglichkeiten, Funktionsparameter zu übergeben: Übergabe als Wert (Wert oder Kopie), Übergabe als Referenz (Zeiger) und Übergabe als unveränderliche Referenz (Struktur-/Array-Referenz, nicht veränderbares Objekt). Bei der Übergabe als Wert bearbeitet die Funktion eine Kopie des Werts und hat keinen Einfluss auf den ursprünglichen Wert. Bei der Übergabe als unveränderlicher Verweis kann die Funktion den ursprünglichen Wert ändern Objekt, verändert jedoch nicht das Objekt selbst. Diese drei Methoden eignen sich für verschiedene Szenarien. Beispielsweise eignet sich die Wertübergabe für schreibgeschützte Operationen, die Referenzübergabe für Änderungsoperationen und die unveränderliche Referenzübergabe für den Betrieb von Strukturen/Arrays.

Go-Funktionsparameter-Übergabemechanismus

In der Go-Sprache werden Funktionsparameter im Wesentlichen auf drei Arten übergeben:

• Wertübergabe (Aufruf nach Wert): Übergeben Sie einen Wert (oder eine Kopie davon). der Wert) ) zur Funktion.
• Referenzübergabe (Aufruf per Referenz): Übergeben Sie einen Zeiger auf den Wert an die Funktion, damit die Funktion den ursprünglichen Wert ändern kann.
• Aufruf nach Wert einer unveränderlichen Referenz: Übergeben Sie eine unveränderliche Referenz einer Struktur oder eines Arrays an die Funktion, sodass die Funktion das ursprüngliche Objekt nicht ändern kann, aber seine Felder ändern kann (wenn die Struktur oder das Array über „if“ verfügt).

Wertübergabe

Wenn Sie einen Parameter als Wert übergeben, wird eine Kopie des Parameterwerts übergeben. Jede Änderung dieses Werts wirkt sich nur auf die Kopie innerhalb der Funktion aus, nicht auf den Originalwert.

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

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

Übergabe per Referenz

Wenn Sie einer Funktion erlauben möchten, den übergebenen Wert zu ändern, können Sie die Zeigerübergabe per Referenz verwenden. Dies wird erreicht, indem ein Zeigerparameter mit dem Präfix * deklariert wird. * 前缀来声明一个指针参数来实现。

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}
}

实战案例

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

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
}

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

🎜Übergabe durch unveränderliche Referenz🎜🎜🎜Strukturen und Arrays können durch Übergabe ihrer unveränderlichen Referenz übergeben werden. Dadurch kann die Funktion auf die Felder der Struktur oder des Arrays zugreifen, das Objekt selbst jedoch nicht ändern. 🎜rrreee🎜🎜Praktischer Fall🎜🎜🎜Angenommen, wir haben eine Funktion calculateTotalCost, deren Funktion darin besteht, deren Gesamtkosten anhand einer Liste von Artikeln zu berechnen. 🎜rrreee🎜In diesem Fall wird items als Slice nach Wert übergeben. Dies bedeutet, dass die Funktion eine Kopie der Variablen items erhält, ohne den ursprünglichen Slice zu ändern. 🎜

Das obige ist der detaillierte Inhalt vonWie werden Golang-Funktionsparameter übergeben?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!