TOC

So definieren und rufen Sie Funktionen in Go auf

Einführung

Eine Funktion ist ein Codeabschnitt, der nach seiner Definition wiederverwendet werden kann. Mit Funktionen wird der Code verständlicher, indem er in kleine, verständliche Aufgaben unterteilt wird, die im gesamten Programm mehrmals verwendet werden können.

Go wird mit einer leistungsstarken Standardbibliothek ausgeliefert, die über viele vordefinierte Funktionen verfügt. Diejenigen, die Sie wahrscheinlich bereits aus dem fmt -Paket kennen, sind:

  • + fmt.Println () + druckt Objekte nach Standard aus (höchstwahrscheinlich Ihr Terminal).

  • + fmt.Printf () +, mit dem Sie Ihre Druckausgabe formatieren können.

Funktionsnamen enthalten Klammern und können Parameter enthalten.

In diesem Lernprogramm wird erläutert, wie Sie Ihre eigenen Funktionen definieren, die Sie in Ihren Codierungsprojekten verwenden können.

Eine Funktion definieren

Beginnen wir damit, das klassische https://www.digitalocean.com/community/tutorials/how-to-write-your-first-program-in[ "Hello, World!" - Programm in eine Funktion umzuwandeln.

Wir erstellen eine neue Textdatei in unserem Texteditor Ihrer Wahl und rufen das Programm "+ hello.go +" auf. Dann definieren wir die Funktion.

Eine Funktion wird mit dem Schlüsselwort + func + definiert. Darauf folgen ein Name Ihrer Wahl und eine Reihe von Klammern, die alle Parameter enthalten, die die Funktion annehmen wird (sie können leer sein). Die Funktionscodezeilen sind in geschweiften Klammern + {} + eingeschlossen.

In diesem Fall definieren wir eine Funktion mit dem Namen "+ hallo () +":

hallo.go

func hello() {}

Hiermit wird die erste Anweisung zum Erstellen einer Funktion eingerichtet.

Ab hier fügen wir eine zweite Zeile hinzu, um die Anweisungen für die Funktionsweise der Funktion bereitzustellen. In diesem Fall drucken wir "+ Hello, World! +" Auf die Konsole:

hallo.go

func hello() {
   fmt.Println("Hello, World!")
}

Unsere Funktion ist jetzt vollständig definiert, aber wenn wir das Programm zu diesem Zeitpunkt ausführen, passiert nichts, da wir die Funktion nicht aufgerufen haben.

Rufen wir also innerhalb unseres Funktionsblocks "+ main () " die Funktion mit " hello () +" auf:

hallo.go

package main

import "fmt"

func main() {
   hello()
}

func hello() {
   fmt.Println("Hello, World!")
}

Führen Sie nun das Programm aus:

go run hello.go

Sie erhalten folgende Ausgabe:

OutputHello, World!

Beachten Sie, dass wir auch eine Funktion namens "+ main () " eingeführt haben. Die Funktion ` main () ` ist eine spezielle Funktion, die dem Compiler mitteilt, dass hier das Programm * starten * soll. Für jedes Programm, das ausführbar sein soll (ein Programm, das über die Befehlszeile ausgeführt werden kann), benötigen Sie die Funktion ` main () `. Die Funktion ` main () ` darf nur einmal vorkommen, sich in ` main () +` package befinden und keine Argumente empfangen und zurückgeben. Dies ermöglicht die Ausführung von program in jedem Go-Programm. Nach folgendem Beispiel:

main.go

package main

import "fmt"

func main() {
   fmt.Println("this is the main section of the program")
}

Funktionen können komplizierter sein als die von uns definierte Funktion + hello () +. Wir können https://www.digitalocean.com/community/tutorials/how-to-construct-for-loops-in-go [+ for + loops] verwenden, https://www.digitalocean.com/community/ Tutorials / How-to-Write-Bedingte Anweisungen-in-Go [Bedingte Anweisungen] und mehr in unserem Funktionsblock.

Die folgende Funktion verwendet beispielsweise eine bedingte Anweisung, um zu überprüfen, ob die Eingabe für die Variable "+ name " einen Vokal enthält, und verwendet dann eine " for " -Schleife, um die Buchstaben in der Zeichenfolge " name +" zu durchlaufen.

names.go

package main

import (
   "fmt"
   "strings"
)

func main() {
   names()
}

func names() {
   fmt.Println("Enter your name:")

   var name string
   fmt.Scanln(&name)
   // Check whether name has a vowel
   for _, v := range strings.ToLower(name) {
       if v == 'a' || v == 'e' || v == 'i' || v == 'o' || v == 'u' {
           fmt.Println("Your name contains a vowel.")
           return
       }
   }
   fmt.Println("Your name does not contain a vowel.")
}

Die hier definierte Funktion "+ names () " erstellt eine Variable " name" mit Eingabe und erstellt dann eine bedingte Anweisung in einer "+ for" -Schleife. Dies zeigt, wie Code innerhalb einer Funktionsdefinition organisiert werden kann. Abhängig davon, was wir mit unserem Programm vorhaben und wie wir unseren Code einrichten möchten, möchten wir die bedingte Anweisung und die "+ für" -Schleife möglicherweise als zwei separate Funktionen definieren.

Das Definieren von Funktionen in einem Programm macht unseren Code modular und wiederverwendbar, sodass wir dieselben Funktionen aufrufen können, ohne sie neu zu schreiben.

Mit Parametern arbeiten

Bisher haben wir uns Funktionen mit leeren Klammern angesehen, die keine Argumente annehmen, aber wir können Parameter in Funktionsdefinitionen in ihren Klammern definieren.

Ein Parameter ist eine benannte Entität in einer Funktionsdefinition, die ein Argument angibt, das die Funktion akzeptieren kann. In Go müssen Sie für jeden Parameter die data type angeben.

Erstellen wir ein Programm, das ein Wort eine bestimmte Anzahl von Malen wiederholt. Es wird ein "+ string " - Parameter mit dem Namen " word " und ein " int " - Parameter mit dem Namen " reps +" benötigt, um das Wort so oft zu wiederholen.

repeat.go

package main

import "fmt"

func main() {
   repeat("Sammy", 5)
}

func repeat(word string, reps int) {
   for i := 0; i < reps; i++ {
       fmt.Print(word)
   }
}

Wir haben den Wert "+ Sammy " für den Parameter " word " und " 5 " für den Parameter " reps " übergeben. Diese Werte entsprechen den einzelnen Parametern in der angegebenen Reihenfolge. Die Funktion " repeat " hat eine " for " -Schleife, die die Anzahl der durch den Parameter " reps " angegebenen Iterationen durchläuft. Bei jeder Iteration wird der Wert des Parameters " word +" ausgegeben.

Hier ist die Ausgabe des Programms:

OutputSammySammySammySammySammy

Wenn Sie eine Reihe von Parametern haben, die alle den gleichen Wert haben, können Sie die Angabe des Typs jedes Mal weglassen. Lassen Sie uns ein kleines Programm erstellen, das die Parameter "+ x ", " y " und " z " enthält, die allesamt " int +" Werte sind. Wir erstellen eine Funktion, die die Parameter in verschiedenen Konfigurationen zusammenfügt. Die Summen davon werden von der Funktion gedruckt. Dann rufen wir die Funktion auf und übergeben Nummern an die Funktion.

add_numbers.go

package main

import "fmt"

func main() {
   addNumbers(1, 2, 3)
}

func addNumbers(x, y, z int) {
   a := x + y
   b := x + z
   c := y + z
   fmt.Println(a, b, c)
}

Als wir die Funktionssignatur für "+ addNumbers +" erstellt haben, mussten wir den Typ nicht jedes Mal angeben, sondern nur am Ende.

Wir haben die Nummer + 1 + in für den Parameter + x +, + 2 + in für den Parameter + y + und + 3 + in für den Parameter + z + übergeben. Diese Werte entsprechen den einzelnen Parametern in der angegebenen Reihenfolge.

Das Programm rechnet auf der Grundlage der Werte, die wir an die Parameter übergeben haben, folgendermaßen:

a = 1 + 2
b = 1 + 3
c = 2 + 3

Die Funktion gibt auch "+ a ", " b " und " c " aus, und basierend auf dieser Mathematik würden wir erwarten, dass " a " gleich " 3 " und " b " " ist 4 + und + c + sind + 5 + `. Führen wir das Programm aus:

go run add_numbers.go
Output3 4 5

Wenn wir "+ 1 ", " 2 " und " 3 " als Parameter an die Funktion " addNumbers () +" übergeben, erhalten wir die erwartete Ausgabe.

Parameter sind Argumente, die normalerweise als Variablen in Funktionsdefinitionen definiert sind. Ihnen können Werte zugewiesen werden, wenn Sie die Methode ausführen und die Argumente an die Funktion übergeben.

Wert zurückgeben

Sie können einen Parameterwert an eine Funktion übergeben, und eine Funktion kann auch einen Wert erzeugen.

Eine Funktion kann mit der Anweisung "+ return +" einen Wert erzeugen, der eine Funktion beendet und optional einen Ausdruck an den Aufrufer zurückgibt. Der Rückgabedatentyp muss ebenfalls angegeben werden.

Bisher haben wir in unseren Funktionen die Anweisung + fmt.Println () + anstelle der Anweisung + return + verwendet. Erstellen wir ein Programm, das anstelle des Druckens eine Variable zurückgibt.

In einer neuen Textdatei mit dem Namen "+ double.go " erstellen wir ein Programm, das den Parameter " x " verdoppelt und die Variable " y " zurückgibt. Wir geben einen Aufruf aus, um die Variable ` result ` zu drucken, die durch Ausführen der Funktion ` double () ` mit der Übergabe von ` 3 +` gebildet wird:

double.go

package main

import "fmt"

func main() {
   result := double(3)
   fmt.Println(result)
}

func double(x int) int {
   y := x * 2
   return y
}

Wir können das Programm ausführen und die Ausgabe sehen:

go run double.go
Output6

Die Ganzzahl "+ 6 " wird als Ausgabe zurückgegeben, was wir erwarten würden, wenn wir " 3 " mit " 2 +" multiplizieren.

Wenn eine Funktion eine Rückgabe angibt, müssen Sie eine Rückgabe als Teil des Codes bereitstellen. Wenn Sie dies nicht tun, erhalten Sie einen Kompilierungsfehler.

Dies können wir demonstrieren, indem wir die Zeile mit der return-Anweisung auskommentieren:

double.go

package main

import "fmt"

func main() {
   result := double(3)
   fmt.Println(result)
}

func double(x int) int {
   y := x * 2
   // return y
}

Führen Sie das Programm jetzt erneut aus:

go run double.go
Output./double.go:13:1: missing return at end of function

Ohne die Verwendung der Anweisung "+ return +" kann das Programm nicht kompilieren.

Funktionen werden sofort beendet, wenn sie eine "+ return +" - Anweisung drücken, auch wenn sie nicht am Ende der Funktion stehen:

return_loop.go

package main

import "fmt"

func main() {
   loopFive()
}

func loopFive() {
   for i := 0; i < 25; i++ {
       fmt.Print(i)
       if i == 5 {
           // Stop function at i == 5
           return
       }
   }
   fmt.Println("This line will not execute.")
}

Hier durchlaufen wir eine "+ für " - Schleife und weisen die Schleife an, " 25 " - Iterationen auszuführen. In der ` for`-Schleife haben wir jedoch eine bedingte` + if`-Anweisung, die prüft, ob der Wert von + i + gleich + 5 + ist. Wenn dies der Fall ist, geben wir eine "+ return " - Anweisung aus. Weil wir uns in der Funktion " loop Five" befinden und "+ return" an einem beliebigen Punkt der Funktion die Funktion verlässt. Infolgedessen gelangen wir nie in die letzte Zeile dieser Funktion, um die Anweisung "+ Diese Zeile wird nicht ausgeführt. +" Auszugeben.

Wenn Sie die Anweisung "+ return" in der Schleife "+ for" verwenden, wird die Funktion beendet, sodass die Zeile außerhalb der Schleife nicht ausgeführt wird. Wenn wir stattdessen eine https://www.digitalocean.com/community/tutorials/how-to-use-break-and-continue-statements-when-working-with-loops-in-go#break- verwendet hätten Anweisung [+ break + Anweisung], nur die Schleife wäre zu diesem Zeitpunkt beendet worden, und die letzte Zeile + fmt.Println () + würde ausgeführt.

Die Anweisung + return + beendet eine Funktion und kann einen Wert zurückgeben, wenn dieser in der Funktionssignatur angegeben ist.

Mehrere Werte zurückgeben

Für eine Funktion kann mehr als ein Rückgabewert angegeben werden. Untersuchen wir das Programm "+ repeat.go " und lassen es zwei Werte zurückgeben. Der erste ist der wiederholte Wert und der zweite ist ein Fehler, wenn der Parameter " reps " nicht größer als " 0 +" ist:

repeat.go

package main

import "fmt"

func main() {
   val, err := repeat("Sammy", -1)
   if err != nil {
       fmt.Println(err)
       return
   }
   fmt.Println(val)
}

func repeat(word string, reps int) (string, error) {
   if reps <= 0 {
       return "", fmt.Errorf("invalid value of %d provided for reps. value must be greater than 0.", reps)
   }
   var value string
   for i := 0; i < reps; i++ {
       value = value + word
   }
   return value, nil
}

Das erste, was die Funktion + repeat + macht, ist zu überprüfen, ob das Argument + reps + ein gültiger Wert ist. Jeder Wert, der nicht größer als "+ 0 " ist, führt zu einem Fehler. Da wir den Wert " -1 " übergeben haben, wird dieser Codezweig ausgeführt. Beachten Sie, dass wir bei der Rückkehr von der Funktion sowohl die Rückgabewerte ` string ` als auch ` error +` angeben müssen. Da die angegebenen Argumente zu einem Fehler führten, geben wir eine leere Zeichenfolge für den ersten Rückgabewert und den Fehler für den zweiten Rückgabewert zurück.

In der Funktion "+ main () " können wir beide Rückgabewerte erhalten, indem wir zwei neue Variablen deklarieren, " value " und " err ". Da es bei der Rückgabe zu einem Fehler kommen kann, möchten wir überprüfen, ob ein Fehler aufgetreten ist, bevor wir mit unserem Programm fortfahren. In diesem Beispiel haben wir einen Fehler erhalten. Wir drucken den Fehler aus und geben " return " aus der " main () +" - Funktion zurück, um das Programm zu verlassen.

Wenn es keinen Fehler gäbe, würden wir den Rückgabewert der Funktion ausdrucken.

Das Ausführen des Programms führt zu folgender Ausgabe:

Outputinvalid value of -1 provided for reps. value must be greater than 0.

In diesem Abschnitt haben wir untersucht, wie wir die Anweisung "+ return +" verwenden können, um mehrere Werte von einer Funktion zurückzugeben.

Fazit

Funktionen sind Codeblöcke von Anweisungen, die Aktionen innerhalb eines Programms ausführen und dazu beitragen, unseren Code wiederverwendbar und modular zu machen.

Um mehr darüber zu erfahren, wie Sie Ihren Code modularer gestalten können, lesen Sie unseren Leitfaden unter How To Write Packages in Go .

Related