Über Go-Funktionen

Grundlegende Syntax der Funktion

Die Grundform der Funktionsdefinition lautet wie folgt.

Funktionsname(Streit)Rückgabetyp{
Inhalt der Verarbeitung...
}

Es ist ein Ablauf, ein Argument für eine Funktion zu übernehmen, den Rückgabewert der Funktion anzugeben und den Verarbeitungsinhalt zu schreiben.

Benannte Funktion

Definieren wir nun eine einfache Funktion.

main.go

func test(x, y int) int {
   a := x * y
   return a
}

func main() {
   fmt.Println(test(10, 5))  //50
}

Der Funktionstest wird durch den Int-Typ x und y definiert, und der Int-Typ wird als Rückgabetyp angegeben. Der Prozess wird der Variablen a zugewiesen, der zurückgegebene Wert wird von der Hauptfunktion empfangen und der Wert wird angegeben und ausgegeben.

Es können auch mehrere Rückgabewerte zurückgegeben werden.

main.go

func test(x, y int) (int, int) {
   a := x * y
   b := x / y
   return a, b
}

func main() {
   a, b := test(10, 5)
   fmt.Println(a, b)  //50 2
}

Sie können auch eine Funktion ohne Rückgabewert definieren, indem Sie den Rückgabewerttyp wie unten gezeigt weglassen.

main.go

func test() {
	fmt.Println("Hallo!")
	return
}

func main(){
   test()  //Hallo!
}

Fehlerbehandlung

Es gibt die folgenden Redewendungen für die Fehlerbehandlung.

main.go

import (
   "os"
   "log"
)

func main() {
   _, err := os.Open("test.txt")
   if err != nil {
      log.Fatal(err)
  }
}

Dieses Programm ist ein Prozess, der eine Fehlermeldung ausgibt, wenn beim Öffnen einer Datei ein Fehler auftritt. Daher importiere ich das Betriebssystempaket und das Protokollpaket.

Anonyme Funktion

Anonyme Funktionen definieren, wie der Name schon sagt, Funktionen als "anonym", im Gegensatz zu benannten Funktionen, die explizit definiert sind.

main.go

func main() {
   a := func(x, y int) int { return x + y }
   fmt.Println(a(2, 5))  //7
}

Sie können auch noch kürzer zeichnen, indem Sie das Argument auf die anonyme Funktion übertragen.

main.go

func main() {
   fmt.Println(func(x, y int) int { return x + y }(2, 5))  //7
}

Dies gibt dasselbe für anonyme Funktionsdefinitionen unter Verwendung von Funktionsliteralen aus.

Gibt eine Funktion mit einer Funktion zurück

Sie können eine Funktion in einer Funktion mithilfe einer anonymen Funktion zurückgeben.

main.go

func test() func() {
   return func() {
      fmt.Println("Ausgabe")
   }
}

func main() {
   a := test()
   a()  //Ausgabe
}

Dieses Programm weist der Variablen a implizit eine Funktion ohne Argument oder Rückgabewert als Rückgabewert zu und gibt sie aus.

Eine Funktion, die eine Funktion als Argument verwendet

Ebenso ist es möglich, eine Funktion als Argument zu verwenden.

main.go

func test(a func()) {
   a()
}

func main() {
   test(func() {
      fmt.Println("Ausgabe")  //Ausgabe
   })
}

In diesem Programm wird ** eine Funktion, die weder ein Argument noch einen Rückgabewert hat **, als Argument des Funktionstests verwendet, und was aufgerufen wird, wird ausgegeben, indem sie als anonyme Funktion in der Funktion main übergeben wird.

Generator, der den Verschluss anwendet

In Go sind anonyme Funktionen ** Abschlüsse **, wie Funktionsabschlüsse. Normalerweise werden die in der Funktion definierten Variablen (lokale Variablen) nach Abschluss der Ausführung der Funktion zerstört. Durch die Verbindung mit dem Abschluss wird sie jedoch nicht zerstört, solange auf den Abschluss verwiesen wird. Es gibt kein. Mit dieser Logik ist es möglich, ** generatorähnliche Funktionen ** zu realisieren, die Go nicht hat.

main.go

func test() func() int {
   a := 0  //Lokale Variablen, auf die innerhalb des Abschlusses verwiesen wird
   return func() int {
      a++
      return a  //Lokale Variablen(Variablen, die zum Abschluss gehören)Referenzierung
   }
}

func main() {
   b := test()

   fmt.Println(b())  //1
   fmt.Println(b())  //2
   fmt.Println(b())  //3
   fmt.Println(b())  //4
}

Schließlich

Dieses Mal habe ich die Funktionen zusammengefasst! In Go, das keine objektorientierten Funktionen hat, wird die Definition von Funktionen von zentraler Bedeutung sein.

Von nun an werde ich die Steuerungssyntax zusammenfassen! !!