Go是否具有lambda表达式或类似内容?

Go是否支持lambda表达式或类似的东西?</ p>

我要移植 一个使用lambda表达式(Ruby)的其他语言编写的库。</ p>
</ div>

展开原文

原文

Does Go support lambda expressions or anything similar?

I want to port a library from another language that uses lambda expressions (Ruby).

7个回答



此处是一个示例,请仔细复制并粘贴:</ p>


 包main 

import fmt “ fmt”

type Stringy func()字符串

func foo()字符串{
返回“ Stringy函数”
}

func takeAFunction(foo Stringy){
fmt.Printf(“ takesAFunction: %v
“,foo())
}

func returnAFunction()Stringy {
return func()string {
fmt.Printf(” Inner stringy function
“);
返回” bar “ //必须返回一个字符串为字符串
}
}

func main(){
takeAFunction(foo);
var f Stringy = returnAFunction();
f();
var baz Stringy = func()string {
返回“匿名stringy

};
fmt.Printf(baz());
}
</ code> </ pre>
</ blockquote >
</ div>

展开原文

原文

Here is an example, copied and pasted carefully:

package main

import fmt "fmt"

type Stringy func() string

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

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

func returnsAFunction()Stringy{
  return func()string{
    fmt.Printf("Inner stringy function
");
    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
"
  };
  fmt.Printf(baz());
}

dsfds2353
dsfds2353 不幸的是,此示例令人困惑,因为它对一个函数(foo)使用相同的名称,而对另一个函数使用参数(foo Stringy)。 我不应该被如此仔细地抄袭:)
大约一年之前 回复
dongshuo1257
dongshuo1257 fmt import语句中的“ fmt”是多余的。
2 年多之前 回复
dongqiao1158
dongqiao1158 这里有一个很好的例子是一个lambda函数的示例,该函数接受一个参数,并在与声明的表达式相同的位置进行调用。
2 年多之前 回复
dousi0144
dousi0144 Kissaki基本上是将函数传递给其他函数,并从函数返回函数,代码是自描述性的,并且名称很聪明,takesaFunction接收函数而不是返回字符串,returnsAFunction返回函数而不是返回字符串....... 是的...完美地支持lambdas:D ....
7 年多之前 回复
douci1541
douci1541 除了复制代码,我希望看到更多关于您的问题的信息。 首先,您可以添加“是” /“否” /“部分”等。然后是一些描述,代码的实际作用。
大约 8 年之前 回复
doumei2023
doumei2023 因为我复制了代码,并想弄清楚:)
大约 8 年之前 回复
doupin1073
doupin1073 你为什么这样说? 仔细复制并粘贴? :)
大约 8 年之前 回复



Lambda表达式也称为函数文字。 Go完全支持它们。</ p>

请参阅语言规范:
http: //golang.org/ref/spec#Function_literals </ p>

查看代码步,并提供示例和说明:
http://golang.org/doc/codewalk/functions/ </ p>
</ div>

展开原文

原文

Lambda expressions are also called function literals. Go supports them completely.

See the language spec: http://golang.org/ref/spec#Function_literals

See a code-walk, with examples and a description: http://golang.org/doc/codewalk/functions/

The golang does not seem to make lambda expressions, but you can use a literal anonymous function, I wrote some examples when I was studying comparing the equivalent in JS, I hope it helps !!

no args return string:

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

with string args and return string

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

no arguments and no returns (void)

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

with Arguments and no returns (void)

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




是</ strong> </ p>
</ blockquote>

< p>在计算机编程中,匿名函数或lambda抽象</ strong>(函数文字)是未绑定到标识符的函数定义,并且 Go支持匿名函数</ strong>,该函数可以 表单关闭。 当您要内联定义函数而不必命名时,匿名函数很有用。</ p>

 包main 
import“ fmt”

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

func main(){
nextInt:= intSeq()

fmt.Println(nextInt())
fmt.Println(nextInt())
fmt.Println(nextInt())
newInts:= intSeq()
fmt.Println(newInts())
}
</ code> </ pre>

函数intSeq返回另一个函数,我们在intSeq主体中匿名定义。 返回的函数将对变量i进行闭合以形成闭包</ strong>。</ p>

  Output 
$去运行闭包.go
1
2
3 \ n1
</ code> </ pre>
</ div>

展开原文

原文

Yes

In computer programming, an anonymous function or lambda abstraction (function literal) is a function definition that is not bound to an identifier, and Go supports anonymous functions, which can form closures. Anonymous functions are useful when you want to define a function inline without having to name it.

    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())
    }

function intSeq returns another function, which we define anonymously in the body of intSeq. The returned function closes over the variable i to form a closure.

Output
$ go run closures.go
1
2
3
1



我一直在寻找的一个尚未提供的示例是从匿名函数直接将值赋给变量,例如 </ p>

  test1,test2:= func()(字符串,字符串){
x:= [] string {“ hello”,“ world”}
返回x [0 ],x [1]
}()
</ code> </ pre>

注意:您需要在函数末尾使用方括号()</ code>来执行 它并返回值,否则仅返回该函数并产生赋值不匹配:2个变量但1个值</ code>错误。</ p>
</ div>

展开原文

原文

An example that hasn't been provided yet that I was looking for is to assign values directly to variable/s from an anonymous function e.g.

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

Note: you require brackets () at the end of the function to execute it and return the values otherwise only the function is returned and produces an assignment mismatch: 2 variable but 1 values error.



是的,但是它是lambda表达式,具有最完整的形式,闭包和所有形式。 但是,您不会获得带有函数文字的类型推断!
这就是Go很烂的原因!</ p>
</ div>

展开原文

原文

Yes, but it is a lambda expression in its fullest form, closures and all. You don't get type inference with function literals however! That's what makes Go sucks!

douyun3022
douyun3022 我不知道为什么会遗漏。 您在决策背后的背景中找到了什么吗?
一年多之前 回复

Yes, since it is a fully functional language, but has no fat arrow (=>) or thin arrow (->) as the usual lambda sign, and uses the func keyword for the sake of clarity and simplicity.

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
立即提问