Bagaimanakah parameter fungsi Golang diluluskan?

Dalam Go, terdapat tiga cara untuk menghantar parameter fungsi: lulus mengikut nilai (nilai atau salinan), lulus melalui rujukan (penunjuk) dan lulus melalui rujukan tidak boleh diubah (rujukan struktur/tatasusunan, objek tidak boleh diubah suai). Apabila diluluskan oleh nilai, fungsi beroperasi pada salinan nilai dan tidak menjejaskan nilai asal apabila diluluskan oleh rujukan, fungsi boleh mengubah suai nilai asal apabila diluluskan oleh rujukan tidak berubah, fungsi boleh beroperasi pada medan objek, tetapi tidak mengubah suai objek itu sendiri. Ketiga-tiga kaedah ini sesuai untuk senario yang berbeza Contohnya, lulus mengikut nilai sesuai untuk operasi baca sahaja, lulus melalui rujukan sesuai untuk operasi pengubahsuaian, dan lulus melalui rujukan tidak berubah sesuai untuk bidang pengendalian struktur/tatasusunan.

Mekanisme lulus parameter fungsi Go

Dalam bahasa Go, parameter fungsi dihantar dalam tiga cara utama:

• laluan nilai (panggilan mengikut nilai): lulus nilai (atau salinan nilai) ) kepada fungsi.
• Lulus rujukan (panggilan melalui rujukan): Hantar penuding kepada nilai kepada fungsi supaya fungsi boleh mengubah suai nilai asal.
• Panggil dengan nilai rujukan tidak berubah: Hantar rujukan tidak berubah bagi struktur atau tatasusunan kepada fungsi, supaya fungsi itu tidak boleh mengubah suai objek asal, tetapi boleh mengubah suai medannya (jika struktur atau tatasusunan mempunyai jika).

Lulus mengikut nilai

Apabila anda menghantar parameter mengikut nilai, salinan nilai parameter dihantar. Sebarang pengubahsuaian kepada nilai ini hanya mempengaruhi salinan dalam fungsi, bukan nilai asal.

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

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

Lulus melalui rujukan

Jika anda ingin membenarkan fungsi mengubah suai nilai yang diluluskan, anda boleh menggunakan rujukan melalui rujukan. Ini dicapai dengan mengisytiharkan parameter penunjuk menggunakan awalan *.

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

Lulus dengan rujukan tidak berubah🎜🎜🎜Struktur dan tatasusunan boleh diluluskan dengan menghantar rujukan tidak berubah mereka. Ini membolehkan fungsi mengakses medan struktur atau tatasusunan, tetapi tidak mengubah suai objek itu sendiri. 🎜rrreee🎜🎜Kes praktikal🎜🎜🎜 Katakan kita mempunyai fungsi calculateTotalCost, fungsinya adalah untuk mengira jumlah kos mereka diberikan senarai item. 🎜rrreee🎜Dalam kes ini, item dihantar sebagai kepingan mengikut nilai. Ini bermakna fungsi akan menerima salinan pembolehubah item tanpa mengubah suai kepingan asal. 🎜

Atas ialah kandungan terperinci Bagaimanakah parameter fungsi Golang diluluskan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!