Funktionen in Go

In Go sind Funktionen Codeblöcke, die bestimmte Aufgaben ausführen und im gesamten Programm wiederverwendet werden können, um Speicher zu sparen, die Lesbarkeit zu verbessern und Zeit zu sparen. Golang -Funktionen können einen Wert an den Aufrufer zurückgeben, müssen es aber nicht.

Wissenswertes über Funktionen in Golang

• Funktionssyntax in Golang
• Funktionsdeklaration
• Anruffunktion
• Funktionsargumente
  • Aufruf nach Wert
  • Aufruf per Referenz

Zum Beispiel:

package main
import "fmt"

// multiply() nhân 2 số nguyên và trả về kết quả
func multiply(a, b int) int {
    return a * b
}

func main() {
    result := multiply(5, 10)
    fmt.Printf("multiplication: %d", result)
}

Ergebnis:

multiplication: 50

Funktionssyntax in Golang

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Funktionsdeklaration

In Go wird eine Funktion mit dem Schlüsselwort func deklariert, gefolgt von einem Namen, Parametern und einem optionalen Rückgabetyp.

Syntax

func function_name(Parameter-list)(Return_type) {
    // function body...
}

Beispiel für die Multiplikationsfunktion

func multiply(a, b int) int {
    return a * b
}

func: Schlüsselwort zum Deklarieren einer Funktion.
function_name: Name der Funktion, z. B. multiply.
Parameterliste: a, b int – die Parameter und ihre Typen.
Return_type: int gibt den Rückgabetyp an.

Anruffunktion

Um eine Funktion zu verwenden, rufen Sie sie einfach mit ihrem Namen und den erforderlichen Argumenten auf. Hier ruft multiply(5, 10) die Funktion mit den Argumenten 5 und 10 auf.

Zum Beispiel

result := multiply(5, 10)
fmt.Printf("Result of multiplication: %d", result)

Funktionsargumente

Go unterstützt zwei Möglichkeiten, Parameter an eine Funktion zu übergeben: Call by Value und Call by Reference. Standardmäßig verwendet Go Call by Value, was bedeutet, dass Werte kopiert werden und Änderungen innerhalb der Funktion keine Auswirkungen auf die Variablen des Aufrufers haben.

Aufruf nach Wert

Beim Call by Value werden die Werte der Argumente in die Funktionsparameter kopiert, Änderungen in der Funktion wirken sich daher nicht auf die ursprünglichen Variablen aus.

Zum Beispiel:

package main
import "fmt"

func multiply(a, b int) int {
    a = a * 2 // chỉnh sửa bên trong hàm này
    return a * b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(x, y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Ergebnis:

Before: x = 5, y = 10
multiplication: 100
After: x = 5, y = 10

Aufruf per Referenz

Beim Aufruf per Referenz werden Zeiger verwendet, sodass Änderungen innerhalb der Funktion in den Variablen des Anrufers widergespiegelt werden.

Zum Beispiel:

package main
import "fmt"

func multiply(a, b *int) int {
    *a = *a * 2 // chỉnh sửa giá trị của a ở địa chỉ bộ nhớ của nó
    return *a * *b
}

func main() {
    x := 5
    y := 10
    fmt.Printf("Before: x = %d, y = %d\n", x, y)
    result := multiply(&x, &y)
    fmt.Printf("multiplication: %d\n", result)
    fmt.Printf("After: x = %d, y = %d\n", x, y)
}

Ergebnis

Before: x = 5, y = 10
multiplication: 100
After: x = 10, y = 10