go 匿名函数和闭包

匿名函数

1. 函数也是一种类型,因此可以定义作为一个函数类型的变量

package main

import "fmt"

// 函数作为参数

func add(a, b int) int {
    return a + b
}

func testfunc(a, b int, fun func(int, int) int) int {
    sum := fun(a, b)
    return sum
}

func main() {
    sum := testfunc(2, 3, add)
    fmt.Println(sum)
}

2. 匿名函数即没有名字的函数

注意defer 和匿名函数的使用

package main

import "fmt"

func add(a, b int) int {
    return a + b

}

// 函数名也可以赋值给变量
func test1() {
    ff := add
    fmt.Printf("ff的类型是%T\n", ff)
    sum := ff(4, 5)
    fmt.Printf("sum is %d \n", sum)
}

/*
ff的类型是func(int, int) int
sum is 9
*/

// 匿名函数
func test2() {
    f1 := func(a, b int) int {
        return a + b
    }
    fmt.Printf("f1的类型是%T\n", f1)
    sum := f1(4, 5)
    fmt.Printf("sum is %d \n", sum)
}

/*
f1的类型是func(int, int) int
sum is 9
*/

// defer
func test3() int {
    i := 10
    defer fmt.Printf("defer i is %d\n", i)
    i = 100
    fmt.Printf("i is %d\n", i)
    return i
}

/*
i is 100
defer i is 10
return i is 100
*/

// defer 和匿名函数
func test4 () int {
    i:= 10
    defer func() {
        fmt.Printf("defer i is %d \n", i)
    }()

    i= 100
    fmt.Printf("i is %d\n", i)

    return i
}

/*
i is 100
defer i is 100
return i is 100
*/
-.

func main() {
    // test1()

    // test2()

    // i := test3()
    // fmt.Printf("return i is %d", i)

    i := test4()
    fmt.Printf("return i is %d", i)
}

闭包

一个函数和与其相关的引用环境组合组成的实体

个人认为go中的闭包和python中的闭包概念一样 都是 一个外层函数 嵌套 一个内层函数  内层函数包含对外层函数变量的引用 外层 函数返回值为内层函数的函数名

闭包 举例

package main

import (
    "fmt"
    "strings"
    "time"
)

func test1() func(int) int {
    index := 10
    return func(d int) int {
        index += d
        return index
    }

}

func test2(base int) func(int) int {
    return func(a int) int {
        base += a
        return base
    }
}

func test3(suffix string) func(name string) string {
    return func(name string) string {
        if !strings.HasSuffix(name, suffix) {
            // return name+suffix
            return fmt.Sprintf("%s%s", name, suffix)
        }
        return name
    }
}

func test4(a int) (func(int) int, func(int) int) {

    add := func(b int) int {
        a += b
        return a
    }

    sub := func(c int) int {
        a -= c
        return a
    }

    return add, sub
}

func test5(){
    for i:=0; i<=5;i++{
        go func(){
            fmt.Println()
        }()
    }
    time.Sleep(time.Second)
}

func test6(){
    for i:=0; i<=5;i++{
        go func(a int){
            fmt.Println(a)
        }(i)
    }
    time.Sleep(time.Second)
}

func main() {
    // f := test1()
    // fmt.Printf("f(1) return is %d\n", f(1))  // 11
    // fmt.Printf("f(2) return is %d\n", f(2))  //13
    // fu := test1()
    // fmt.Printf("fu(1) return is %d\n", fu(5))  // 15
    // fmt.Printf("fu(2) return is %d\n", fu(6))  //21

    // f := test2(5)
    // fmt.Printf("f(1) return is %d\n", f(1)) // 6
    // fmt.Printf("f(2) return is %d\n", f(2)) //8
    // fu := test2(10)
    // fmt.Printf("fu(1) return is %d\n", fu(5)) // 15
    // fmt.Printf("fu(2) return is %d\n", fu(6)) //21

    // f3 := test3(".jpg")
    // fmt.Printf("f3(‘ctz‘) return is %s\n", f3("ctz")) // f3(‘ctz‘) return is ctz.jpg
    // fmt.Printf("f3(‘yunnan.jpg‘) return is %s\n", f3("yunnan.jpg")) //f3(‘yunnan.jpg‘) return is yunnan.jpg

    // add, sub := test4(10)

    // fmt.Println(add(5), sub(6)) //15 9
    // fmt.Println(add(3), sub(4)) // 12 8

    test5()

}

原文地址:https://www.cnblogs.com/ctztake/p/10279568.html

时间: 2024-11-07 21:15:29

go 匿名函数和闭包的相关文章

14.匿名函数和闭包

匿名函数和闭包 学习要点:1.匿名函数2.闭包 匿名函数就是没有名字的函数,闭包是可以访问一个函数作用域里变量的函数.声明:本节内容需要有面向对象和少量设计模式基础. 一.匿名函数 //普通函数function box(){ //函数名是box return 'Lee'; } //匿名函数function(){ //匿名函数,会报错,单独的匿名函数是无法运行的 return 'Lee';} //通过表达式自我执行(function box(){ //封装成表达式 alert('Lee');})(

匿名函数和闭包

匿名函数和闭包匿名函数就是没有名字的函数,闭包是可访问一个函数作用域里变量的函数.一. 匿名函数//普通函数functionbox() { //函数名是 boxreturn'Lee';}//匿名函数function() { //匿名函数,会报错return'Lee';}//通过表达式自我执行(function box() { //封装成表达式alert('Lee');})(); //()表示执行函数,并且传参//把匿名函数赋值给变量var box = function() { //将匿名函数赋给

javascript匿名函数与闭包

匿名函数是相对于有名字的函数 如function setAge(){}函数名为setAge 而类似于function(){}则就是一个匿名函数 有名字的函数执行时可以写成setAge(),而没有名字的函数则执行要写成(function())(); 另一种方式是把匿名函数赋值给一个变量来使用 var a=function(){ alert("hello,world"); } a(); 匿名函数传参 (function(age){ return age; })(100); 匿名函数产生闭包

匿名函数和闭包规避xdebug限制的函数递归深度限制

PHP版本5.6 先来个简单的用递归求和,代码如下: function add($n){     if($n === 1)return 1;     return add($n - 1); } echo add(256);  运行时报错: Maximum function nesting level of '256' reached, aborting! 这个报错的意思就是函数的递归深度最大是256,不能大于或等于256.在网上查找资料发现,这个是xdebug做的限制,可以通过更改配置文件来修改

php中的匿名函数和闭包(closure)

一:匿名函数 (在php5.3.0 或以上才能使用) php中的匿名函数(Anonymous functions), 也叫闭包函数(closures), 允许指定一个没有名称的函数.最常用的就是回调函数的参数值.(http://php.net/manual/zh/functions.anonymous.php) 匿名函数的定义: $closureFunc = function(){ .... }; eg: 把匿名函数赋值给变量,通过变量来调用 $closureFunc = function($s

从匿名函数(闭包特性)到 PHP 设计模式之容器模式

匿名函数(匿名函数) 匿名函数,也叫闭包函数,它允许临时创建一个没有指定名称的函数,常用作回调函数参数的值,也可以作为变量的值来使用.具体的使用见以下示例代码: /* 示例一:声明一个简单匿名函数,并赋值给一个变量,通过变量名调用这个匿名函数 */ $anonFunc = function($param){ echo $param; }; $anonFunc('这里是一个匿名函数'); // 通过变量名调用匿名函数,和普通函数没什么区别 /* 示例二:通过在函数内部使用匿名函数动态创建函数 */

Golang之匿名函数和闭包

Go语言支持匿名函数,即函数可以像普通变量一样被传递或使用. 使用方法如下: main.go package main import ( "fmt" ) func main() { var v func(a int) int v = func(a int) int { return a * a } fmt.Println(v(6)) //两种写法 v1 := func(i int) int { return i * i } fmt.Println(v1(7)) } GO语言的匿名函数就

GO 之匿名函数、闭包

匿名函数 go语言支持匿名函数,即像普通变量一样被引用或者传递 func main(){ var v func(a int) int v = func(a int) int { return a*a } fmt.Println(v(5)) //另一种写法 s := func(a int) int { return a*a } fmt.Println(s(7)) } GO语言的匿名函数就是闭包,<go语言编程>中对闭包的解释是: 基本概念闭包是:可以包含自由(未绑定到特定对象)变量的代码块,这些

内置函数补充、匿名函数及闭包

内置函数.匿名函数及闭包 匿名函数 def func(x,y): return (x,y) print(func(1,2)) # 结果: (1,2) f = lambda x,y:(x,y) # lambda关键字 print(f(1,2)) # 结果: (1,2) print((lambda x,y:(x,y))(1,2)) # 结果: (1,2) # 一行代码实现匿名函数的定义及调用 print(lambda :1) print((lambda :1)()) # 匿名函数可以不写参数,但必须

JavaScript匿名函数和闭包

概述 在JavaScript前端开发中,函数与对其状态即词法环境(lexical environment)的引用共同构成闭包(closure).也就是说,闭包可以让你从内部函数访问外部函数作用域.在JavaScript,函数在每次创建时生成闭包.匿名函数和闭包可以放在一起学习,可以加深理解.本文主要通过一些简单的小例子,简述匿名函数和闭包的常见用法,仅供学习分享使用,如有不足之处,还请指正. 普通函数 普通函数由fucntion关键字,函数名,() 和一对{} 组成,如下所示: 1 functi