Funktionen in Golang

Einführung

Mit zunehmender Komplexität von Projekten ist es üblich, den Code in mehrere Funktionen aufzuteilen. Dieser Ansatz verbessert die Lesbarkeit des Codes, erleichtert die Zusammenarbeit und ermöglicht es Ihnen, Logik schnell wiederzuverwenden, ohne den Code zu duplizieren. In diesem Lab werden Sie die Grundlagen der Erstellung und Verwendung von Funktionen in Go lernen. Sie werden sehen, wie Sie Ihre eigenen Funktionen definieren, verstehen, wie Go Parameter und Rückgabewerte behandelt, und über init-Funktionen und variable Parameter erfahren.

Wichtige Themen:

• Verständnis, was Funktionen sind und wie sie funktionieren
• Deklarieren von Funktionen in Go
• Übergeben von Parametern per Wert und per Referenz
• Rückgabe mehrerer Werte aus einer Funktion
• Verwenden der init-Funktion zur Einrichtung Ihrer Umgebung
• Arbeiten mit variablen Parametern für eine flexible Eingabebehandlung

Erstellen und Ausführen eines einfachen Programms

Zunächst navigieren Sie in Ihr Projektverzeichnis und erstellen eine Go-Datei:

cd ~/project
touch func.go

Öffnen Sie die Datei func.go mit einem Texteditor und fügen Sie folgenden Code hinzu:

package main

import "fmt"

func main() {
    a1, b1 := 12, 4
    a2, b2 := 12, 0

    // For the first pair
    if b1 == 0 {
        fmt.Println("The divisor cannot be 0")
    } else {
        fmt.Println(a1 / b1)
    }

    // For the second pair
    if b2 == 0 {
        fmt.Println("The divisor cannot be 0")
    } else {
        fmt.Println(a2 / b2)
    }
}

Dieser Code versucht zwei Divisionsoperationen durchzuführen und prüft vor der Division, ob der Divisor null ist. Wenn der Divisor null ist, wird eine Fehlermeldung ausgegeben.

Führen Sie das Programm aus:

go run func.go

Sie sollten folgende Ausgabe sehen:

3
The divisor cannot be 0

Funktionsdeklaration

In den vorherigen Labs haben wir, unabhängig davon, ob das Programm einfach oder komplex war, nur die main-Funktion für Operationen verwendet.

Ein Programm kann nur eine main-Funktion haben, die der Einstiegspunkt des Programms ist. Wenn wir das Programm ausführen, werden andere Funktionen direkt oder indirekt innerhalb der main-Funktion aufgerufen und ausgeführt.

Schauen wir uns nun die Syntax von Funktionen an:

func functionName(parameters...)(returnValues...){
    code block
}

Hier wird der Funktionsname verwendet, um die Funktion zu identifizieren. Für den Funktionsnamen gelten folgende Regeln:

• Er kann aus Buchstaben, Zahlen und Unterstrichen bestehen. Allerdings darf der erste Buchstabe des Funktionsnamens keine Zahl sein. Beispielsweise ist func 3ab(){} ungültig.
• Wenn der erste Buchstabe groß geschrieben ist, kann die Funktion von Code in externen Paketen referenziert werden. Wenn der erste Buchstabe klein geschrieben ist, kann sie nur innerhalb des Pakets verwendet werden. Dies ähnelt öffentlichen und privaten Funktionen.

Die Parameterliste deklariert die Anzahl und den Typ der in die Funktion übergebenen Parameter:

• Die Parameterliste kann leer sein oder mehrere Parameter enthalten.

• Jeder Parameter besteht aus einem Parameternamen und einem Parametertyp. Beispielsweise deklarieren wir in der folgenden Parameterliste zwei Variablen vom Typ int.

  func test(a, b int) (res int){}

Die Rückgabelisten werden verwendet, um die benötigten Werte nach der Ausführung der Funktion zurückzugeben:

• Die Rückgabeliste ähnelt der Parameterliste. Die Anzahl der Parameter kann beliebig sein.

• Im Allgemeinen besteht die Rückgabeliste aus Variablennamen und Variablentypen, wobei der Variablenname optional ist.

• Wenn nur eine Variable zurückgegeben wird und nur der Variablentyp deklariert wird, können die Klammern weggelassen werden. Beispielsweise:

  func test(a int, b string) int{}

Wenn die Parametertypen gleich sind, können wir die Kurzschreibweise verwenden. Die folgenden beiden Funktionen haben die gleiche Funktionalität:

func test(a, b int, c, d string)(res1, res2 int, res3 string){}

// Short writing mode
func test(a, b int, c, d string)(res1, res2 int, res3 string){}

Ersetzen Sie den Inhalt von func.go durch folgenden Code:

package main

import "fmt"

func check(divisor int) bool {
    if divisor == 0 {
        fmt.Println("The divisor cannot be 0")
        return false
    }
    return true
}

func main() {
    a1, b1 := 12, 4
    a2, b2 := 12, 0

    // Use the check function before division
    if check(b1) {
        fmt.Println(a1 / b1)
    }
    if check(b2) {
        fmt.Println(a2 / b2)
    }
}

Führen Sie das Programm erneut aus:

go run func.go

Sie sollten die gleiche Ausgabe sehen:

3
The divisor cannot be 0

Diesmal ist die Prüfungslogik in der check-Funktion gekapselt, wodurch der Code sauberer und wiederverwendbarer wird.

Verwenden der init-Funktion

Go unterstützt eine init-Funktion, die vor der main-Funktion ausgeführt wird. Diese wird oft verwendet, um Umgebungsbedingungen einzurichten oder Variablen vor der Hauptausführung zu initialisieren.

Ersetzen Sie den Inhalt von func.go durch Folgendes:

package main

import "fmt"

func init() {
    fmt.Println("init statement")
}

func main() {
    fmt.Println("main statement")
}

Führen Sie das Programm aus:

go run func.go

Sie sollten folgende Ausgabe sehen:

init statement
main statement

In Go hat die init-Funktion folgende Eigenschaften:

• Sie hat keine Eingabeparameter und keine Rückgabewerte.
• Sie kann nicht von anderen Funktionen aufgerufen werden.

Es kann mehrere init-Funktionen in derselben Code-Datei oder demselben Paket geben. Die Ausführungsreihenfolge ist wie folgt:

• Die init-Funktion, die in derselben Code-Datei früher erscheint, wird früher ausgeführt.
• Dateien, die in alphabetischer Reihenfolge früher in demselben package stehen, werden früher ausgeführt. Beispielsweise, wenn dasselbe package die folgenden Dateien mit init-Funktionen enthält:

a1.go
a2.go
b1.go

Die Ausführungsreihenfolge wird a1.go, a2.go, b1.go sein, da a < b und 1 < 2.

Rückgabe mehrerer Werte aus einer Funktion

Go ermöglicht es Funktionen, mehrere Werte zurückzugeben. Dies ist nützlich, um mehrere verwandte Berechnungen auf einmal durchzuführen.

Ersetzen Sie den Inhalt von func.go durch Folgendes:

package main

import "fmt"

func cal(a, b int) (int, int, int, int) {
    return a + b, a - b, a * b, a % b
}

func main() {
    add, sub, mul, rem := cal(90, 12)
    fmt.Println(add, sub, mul, rem)
}

Führen Sie das Programm aus:

go run func.go

Sie sollten folgende Ausgabe sehen:

102 78 1080 6

Hier gibt die Funktion cal auf einmal vier Werte zurück, was zeigt, wie die Rückgabe mehrerer Werte bestimmte Aufgaben vereinfachen kann.

Arbeiten mit variablen Parametern (Variadic Parameters)

Variable Parameter (Variadic Parameters) ermöglichen es einer Funktion, eine variable Anzahl von Argumenten zu akzeptieren. Dies kann Szenarien vereinfachen, in denen die Eingabegröße nicht festgelegt ist.

Ersetzen Sie den Inhalt von func.go durch Folgendes:

package main

import "fmt"

func printX(values...string) {
    for _, v := range values {
        fmt.Println(v)
    }
}

func main() {
    printX("labex", "labs", "courses")
}

Führen Sie das Programm aus:

go run func.go

Sie sollten folgende Ausgabe sehen:

labex
labs
courses

Die Funktion printX kann eine beliebige Anzahl von String-Argumenten verarbeiten, was sie flexibel und einfach zu verwenden macht.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Funktionen in Go definieren und verwenden, einschließlich der Rückgabe mehrerer Werte und der Akzeptanz einer variablen Anzahl von Parametern. Sie haben auch gesehen, wie die init-Funktion vor der main-Funktion ausgeführt wird. Indem Sie Ihren Code in Funktionen strukturieren, können Sie Ihre Programme leichter verständlich, wartbar und wiederverwendbar machen.

Diese Fähigkeiten sind grundlegend für das Erstellen modularer und skalierbarer Go-Anwendungen. Mit wachsender Größe Ihrer Projekte wird die Nutzung von Funktionen zur Organisation von Code und Logik immer wichtiger werden.