Go实战--Closures in golang(匿名函数、闭包)

前端之家收集整理的这篇文章主要介绍了Go实战--Closures in golang(匿名函数、闭包)前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

号外!!号外!!

在拉勾网上搜索go的职位(北京):
2017年2月14日搜索结果:119个
2017年6月19日搜索结果:163个
2018年1月31日搜索结果:268个

生命不止,继续 go go go !!!

曾记得,某年某月某日,去快手面试。面试官的第一个问题就是:
面试官:“什么是闭包,说一说对闭包的理解”

答:“lambda表达式,其他的不太清楚”

面试官:“lambda表达式是实现闭包的一种方式。”

面试官:“闭包的概念是从JavaScript中开始的”(正确与否,值得商榷)。

今天就聊聊golang中的闭包。

何为匿名函数

匿名函数的英文表示是:Anonymous functions
Functions with name are named functions!

说白了,匿名函数是指不需要定义函数名的一种函数实现方式,它并不是一个新概念,最早可以回溯到1958年的Lisp语言。

c++中的匿名函数

auto a_lambda_func = [](int x)

js总的匿名函数

function(argument1,argument2){
}

golang中匿名函数

定义匿名函数

func(x,y int) int {
    return x + y
}

匿名函数作为返回值

func getPrintMessage() func(string) {
    // returns an anonymous function
    return func(message string) {
        fmt.Println(message)
    }
}

匿名函数付给变量

f := func() int {
    ...
}

返回多个匿名函数

func calc(x,y int) (func(int),func()) {
    f1 := func(z int) int {
        return (x + y) * z / 2
    }

    f2 := func() int {
        return 2 * (x + y)
    }
    return f1,f2
}

完整代码

package main

import "fmt"

func printMessage(message string) {
    fmt.Println(message)
}

func getPrintMessage() func(string) {
    // returns an anonymous function
    return func(message string) {
        fmt.Println(message)
    }
}

func main() {
    // named function
    printMessage("Hello function!")

    // anonymous function declared and called
    func(message string) {
        fmt.Println(message)
    }("Hello anonymous function!")

    // gets anonymous function and calls it
    printfunc := getPrintMessage()
    printfunc("Hello anonymous function using caller!")

}

输出
Hello function!
Hello anonymous function!
Hello anonymous function using caller!

何为闭包

关于闭包的概念,有些抽象。
WIKI:
In programming languages,closures (also lexical closures or function closures) are techniques for implementing lexically scoped name binding in languages with first-class functions.

A closure is a function value that references variables from outside its body.
个人理解:
闭包就是能够读取其他函数内部变量的函数
只有函数内部的子函数才能读取局部变量,因此可以把闭包简单理解成”定义在一个函数内部的函数”。

golang中使用闭包

package main

import "fmt"

func outer(name string) {
    // variable in outer function
    text := "Modified " + name

    // foo is a inner function and has access to text variable,is a closure
    // closures have access to variables even after exiting this block
    foo := func() {
        fmt.Println(text)
    }

    // calling the closure
    foo()
}

func main() {
    outer("hello")
}

返回闭包

package main

import "fmt"

func outer(name string) func() {
    // variable
    text := "Modified " + name

    // closure. function has access to text even after exiting this block
    foo := func() {
        fmt.Println(text)
    }

    // return the closure
    return foo
}

func main() {
    // foo is a closure
    foo := outer("hello")

    // calling a closure
    foo()
}

Closures and state

package main

import "fmt"

func counter(start int) (func() int,func()) {
    // if the value gets mutated,the same is reflected in closure
    ctr := func() int {
        return start
    }

    incr := func() {
        start++
    }

    // both ctr and incr have same reference to start
    // closures are created,but are not called
    return ctr,incr
}

func main() {
    // ctr,incr and ctr1,incr1 are different
    ctr,incr := counter(100)
    ctr1,incr1 := counter(100)
    fmt.Println("counter - ",ctr())
    fmt.Println("counter1 - ",ctr1())
    // incr by 1
    incr()
    fmt.Println("counter - ",ctr())
    fmt.Println("counter1- ",ctr1())
    // incr1 by 2
    incr1()
    incr1()
    fmt.Println("counter - ",ctr1())
}

陷阱

package main

import "fmt"

func functions() []func() {
    // pitfall of using loop variables
    arr := []int{1, 2, 3, 4}
    result := make([]func(), 0)

    for i := range arr {
        result = append(result,func() { fmt.Printf("index - %d,value - %d\n",i,arr[i]) })
    }

    return result
}

func main() {
    fns := functions()
    for f := range fns {
        fns[f]()
    }
}

输出
index - 3,value - 4
index - 3,value - 4

斐波拉切数列

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
    x,y := 0, 1
    return func() int {
        x,y = y,x+y
        return x
    }
}

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

引用:
http://keshavabharadwaj.com/2016/03/31/closure_golang/

原文链接:https://www.f2er.com/go/187433.html

猜你在找的Go相关文章