Array-Parameter-Anwendungsmethode der Golang-Funktion

Golang-Funktionsarray-Parameter-Anwendungsmethode

Golang ist eine Open-Source-Programmiersprache, die leicht zu erlernen, effizient und sicher ist und über Garbage-Collection-Funktionen verfügt. Arrays sind ein sehr grundlegender Datentyp in Golang. Arrays sind auch eine gängige Methode zum Schreiben von Programmen als Funktionsparameter. In diesem Artikel wird die Anwendungsmethode von Arrays als Funktionsparameter in Golang vorgestellt, in der Hoffnung, die Leser für die Anwendung von Golang-Funktionen zu inspirieren.

1. Arrays als Parameter nach Wert übergeben

Wenn Sie Arrays als Wert einer Funktion übergeben, erhalten die formalen Parameter der Funktion eine Kopie, die dem tatsächlichen Parameterwert entspricht, und Änderungen an den formalen Parametern innerhalb der Funktion erhalten eine Kopie keinen Einfluss auf die tatsächlichen Parameter. Diese Methode eignet sich für Situationen, in denen Sie einige einfache Operationen an Arrays in einer Funktion ausführen müssen.

Zum Beispiel der folgende Code:

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

Das Ausgabeergebnis lautet wie folgt:

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

Es kann festgestellt werden, dass sich der Wert des Arrays selbst dann nicht ändert, wenn der Wert von geändert wird, selbst wenn das Array in der Funktion „modifyArr“ geändert wird Das Array wird in der Hauptfunktion gedruckt.

2. Übergabe von Parametern mithilfe von Arrays als Zeiger

Bei der Übergabe von Parametern mithilfe von Arrays als Zeiger an Funktionen kann die Funktion die tatsächliche Parametergruppe direkt ändern. Diese Methode eignet sich für Situationen, in denen komplexere Operationen in der Funktion ausgeführt werden müssen.

Das Folgende ist ein Codebeispiel:

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

Das Ausgabeergebnis lautet wie folgt:

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

Wie Sie sehen können, ändern wir in der Funktion „modifyArrByPointer“ das Array durch Zeigeroperationen.

3. Array-Parameter als Slices übergeben

Bei der Übergabe von Arrays als Slice-Parameter einer Funktion können alle Slicing-Operationen des Arrays innerhalb der Funktion verwendet werden. Der Vorteil dieser Methode besteht darin, dass nicht das gesamte Array kopiert wird, sondern nur die Referenz wird übergeben. Diese Methode eignet sich für Szenarien, in denen Slicing erforderlich ist, um Arrays zu bearbeiten.

Zum Beispiel der folgende Code:

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

Das Ausgabeergebnis lautet wie folgt:

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

Wie Sie sehen können, verwenden wir in den Parametern der Funktion „modifyArrBySlice“ arr[:], um den Slice des Arrays zu übergeben Auf diese Weise kann das Array durch den Slicing-Vorgang geändert werden.

4. Array-Felder in Strukturen als Parameter

In Golang können Strukturen auch Felder vom Typ Array enthalten. Wenn Sie eine Struktur in einer Funktion übergeben, können Sie wählen, ob Sie eine Referenz oder einen Wert der Struktur übergeben möchten, um das Array zu bearbeiten.

Zum Beispiel der folgende Code:

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

Das Ausgabeergebnis lautet wie folgt:

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

Sie können sehen, dass die Funktion den Wert ihrer Mitgliedsvariablen nicht ändern kann, wenn wir die Struktur als Wert der Funktion übergeben Die Struktur wird als Funktion verwendet. Bei der Übergabe von Parametern über einen Zeiger können deren Mitgliedsvariablen geändert werden.

Zusammenfassung:

In Golang gibt es drei Möglichkeiten, Arrays als Parameter von Funktionen zu verwenden: Wertübergabe, Zeigerübergabe und Slice-Übergabe. Die Wertübergabe eignet sich für einfache Operationsszenarien, die Zeigerübergabe eignet sich für Szenarien, die komplexe Operationen innerhalb von Funktionen erfordern, und die Slice-Übergabe eignet sich für Szenarien, die Slicing-Operationen für Arrays erfordern. Wenn das Array in der Struktur außerdem eine Mitgliedsvariable der Struktur ist, können Sie den Zeiger der Struktur verwenden, um Parameter zur Änderung zu übergeben. In tatsächlichen Anwendungen sollten Entwickler die geeignete Methode zur Parameterübergabe entsprechend den spezifischen Anforderungen auswählen.

Das obige ist der detaillierte Inhalt vonArray-Parameter-Anwendungsmethode der Golang-Funktion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!