Hat Go Lambda-Ausdrücke oder ähnliches?

Unterstützt Go Lambda-Ausdrücke oder ähnliches?

Ich möchte eine Bibliothek aus einer anderen Sprache portieren, die Lambda-Ausdrücke verwendet (Ruby).

Hier ist ein Beispiel , das sorgfältig kopiert und eingefügt wurde:

package main

import fmt "fmt"

type Stringy func() string

func foo() string{
  return "Stringy function"
}

func takesAFunction(foo Stringy){
  fmt.Printf("takesAFunction: %v\n", foo())
}

func returnsAFunction()Stringy{
  return func()string{
    fmt.Printf("Inner stringy function\n");
    return "bar" // have to return a string to be stringy
  }
}

func main(){
  takesAFunction(foo);
  var f Stringy = returnsAFunction();
  f();
  var baz Stringy = func()string{
    return "anonymous stringy\n"
  };
  fmt.Printf(baz());
}

Lambda-Ausdrücke werden auch Funktionsliterale genannt. Go unterstützt sie vollständig.

Siehe die Sprachspezifikation: http://golang.org/ref/spec#Function_literals

Sehen Sie sich einen Code-Walk mit Beispielen und einer Beschreibung an: http://golang.org/doc/codewalk/functions/

Ja

In der Computerprogrammierung ist eine anonyme Funktion oder Lambda-Abstraktion (Funktionsliteral) eine Funktionsdefinition, die nicht an einen Bezeichner gebunden ist, und Go unterstützt anonyme Funktionen , die Abschlüsse bilden können. Anonyme Funktionen sind nützlich, wenn Sie eine Funktion inline definieren möchten, ohne sie benennen zu müssen.

    package main
    import "fmt"

    func intSeq() func() int {
        i := 0
        return func() int {
            i += 1
            return i
        }
    }


    func main() {
       nextInt := intSeq()
       fmt.Println(nextInt())
       fmt.Println(nextInt())
       fmt.Println(nextInt())
       newInts := intSeq()
       fmt.Println(newInts())
    }

Die Funktion intSeq gibt eine weitere Funktion zurück, die wir anonym im Hauptteil von intSeq definieren. Die zurückgegebene Funktion wird über der Variablen i geschlossen, um einen Abschluss zu bilden .

Output
$ go run closures.go
1
2
3
1

Der Golang scheint keine Lambda-Ausdrücke zu machen, aber Sie können eine wörtlich anonyme Funktion verwenden. Ich habe einige Beispiele geschrieben, als ich das Vergleichen des Äquivalents in JS studierte. Ich hoffe, es hilft!

no args return string:

func() string {
    return "some String Value"
}
//Js similar: () => 'some String Value'

mit string args und return string

func(arg string) string {
    return "some String" + arg
}
//Js similar: (arg) => "some String Value" + arg

Keine Argumente und keine Rückgabe (nichtig)

func() {
   fmt.Println("Some String Value")
} 
//Js similar: () => {console.log("Some String Value")}

mit Argumenten und ohne Rückgabe (nichtig)

func(arg string) {
    fmt.Println("Some String " + arg)
}
//Js: (arg) => {console.log("Some String Value" + arg)}

Ein Beispiel, nach dem ich noch nicht gesucht habe, ist das direkte Zuweisen von Werten zu Variablen von einer anonymen Funktion, z

test1, test2 := func() (string, string) {
    x := []string{"hello", "world"}
    return x[0], x[1]
}()

Hinweis: Sie benötigen Klammern ()am Ende der Funktion, um sie auszuführen und die Werte zurückzugeben. Andernfalls wird nur die Funktion zurückgegeben und es wird ein assignment mismatch: 2 variable but 1 valuesFehler ausgegeben.

Ja, da es sich um eine voll funktionsfähige Sprache handelt, die jedoch keinen fetten Pfeil (=>) oder dünnen Pfeil (->) als übliches Lambda-Zeichen enthält und aus Gründen der Klarheit und Einfachheit das Schlüsselwort func verwendet .