函数

本节学习几种函数

  • 匿名函数
  • 高阶函数
  • 闭包
  • 头等函数的作用

匿名函数

什么是匿名函数?

通俗的讲就是没有函数名的函数

package main

import "fmt"

func main() {
    add := func (x,y int)int{
        return x+y
    }
    fmt.Println(add(1,2))
}

让变量add 等于一个匿名函数 使用这个函数的唯一方法就是 add()

其实匿名函数也可以不用存储给变量的,可以立即执行如下

package main

import "fmt"

func main() {
   result := func (x,y int)int{
        return x+y
    }(1,2)
    fmt.Println(result)
}

func (x,y int)int{ return x+y }(1,2) 这代码前半句,是创建了一个匿名函数后面使用(1,2)是直接执行这个函数

匿名函数就讲到这里,下面我们来玩一个有意思的自定义函数

package main

import "fmt"

type Add func(int,int)int

func main() {
   var add Add = func(i int, i2 int) int {
       return i + i2
   }
    fmt.Println(add(1,2))
}

type Add func(int,int)int 这个就是我们自定义的一个函数类型,给其命名Add

var add Add 我们就可以把变量a 声明为Add 类型,只要后面的定义是这种类型就可以了

下面我们就看一下这个自定义函数的实际使用场景

高阶函数

什么是高级函数?

满足下面任意一个条件的就是高级函数

  • 接收一个或多个函数作为参数
  • 返回值是一个函数

我们先看第一种 接收一个或多个函数作为参数

package main

import (
    "errors"
    "fmt"
)

// 1
type Operator func(int,int)int

// 2
func add(x,y int)int{
    return x + y
}

// 3
func calculate(x,y int,op Operator)(int,error){
    if(op == nil){
        return 0,errors.New("无效的操作符")
    }
    return op(x,y),nil
}

func main() {
  result,ok := calculate(4,2,add)
  // 4
  if(ok == nil){
      fmt.Println(result)
  }
  
}

1.我们自定义了一个两个输入参数都是int类型,返回值是一个int 类型的函数,命名Operator 代表操作符函数

2.我们定义了一个两个整数进行相加运算的算法函数

3.这个就是我们定义的高级函数,接受两个参数和一个操作符,注意一句代码 if(op == nil) 为什么这里我们要进行判断呢? 因为函数都是引用类型,所以可以把一个空地址赋值给引用类型,如nil 所以我们在这里进行判断

这里延伸一下,那些类型是引用类名呢?常见的通道 切片都是引用类型

如下定义是不会报错的

   var ch chan int = nil
   var s []string = nil

但是数组赋值nil 就会报错

var s [3]string = nil 

4.在获取值的使用,最好先检测一下返回值有没有错误,可能你会出自己写的代码难道还会传一个nil吗? 测试可是喜欢用各种异常情况整治你们的,所以你应该让自己的代码,无懈可击才对

第二种 代码中返回函数

package main

import (
    "errors"
    "fmt"
)

// 1
type Operator func(int,int)int

// 2
func GetOperator(command string)(Operator,error){
    add := func(i int, i2 int) int {
        return i + i2
    }
    minus := func(i int, i2 int) int {
        return i - i2
    }

    switch command {
      case "+": return add, nil
      case "-": return minus,nil
      default:
        return nil,errors.New("无效的命令")
    }
}

// 3
func calculate(x,y int,op string)(int,error){
      v,err := GetOperator(op)
         if(err == nil){
         return v(x,y),nil
      }
      return 0,err
}

func main() {
  result,ok := calculate(4,2,"-")
  
  if(ok == nil){
      fmt.Println(result)
  }

}

2 就是我们定义的函数值当做返回值的类型,根据用户传入的命令 返回一个对应的函数作,如果是无效的字符串,我们就返回一个错误类型,提醒用户

result,ok := calculate(4,2,"-") 这就是我们最终使用的方式,这个也就是函数式编程的思想

闭包?

package main

import (  
    "fmt"
)
func main() {  
    a := 5
    func() {
        fmt.Println("a =", a)
    }()
}

什么是闭包?

闭包(Closure)是匿名函数的一个特例。当一个匿名函数所访问的变量定义在函数体的外部时,就称这样的匿名函数为闭包

下面分析一个案例

package main

import (
    "fmt"
)

func appendStr() func(string) string {
    t := "Hello"

    // 1.
    c := func(b string) string {
        t = t + " " + b
        return t
    }
    return c
}

func main() {
    a := appendStr()
    fmt.Println(a("World"))
    fmt.Println(a("my name is xj"))
}

appendStr 函数返回的是一个闭包,c变量引用了一个匿名函数,这个匿名中访问了它外面的一个变量t,所以它就是闭包,这个变量t 就和闭包绑定在了一起

下面看一下执行的过程 a := appendStr()执行完毕之后 返回的 a其实就是一个匿名函数,这个时候调用 a("World"),就完成了匿名函数的执行,此时绑定的变量t的值会变成 Hello world ,下面我们继续调用了 a("my name is xj") 那么,t 有进行的拼接,变成了Hello world my name is xj

image.png


头等函数

支持头等函数(First Class Function)的编程语言,可以把函数赋值给变量,也可以把函数作为其它函数的参数或者返回值。Go 语言支持头等函数的机制

头等函数的作用很广,map函数你

package main

import "fmt"

// 1
func IMap(list []int,f func(int)int)[]int{
    for index,value := range list{
        list[index] = f(value)
    }
    return list
}


func main() {
   list := []int{1,2,3,4,5,6}
   // 2
   IMap(list, func(i int) int {
       return  i * i
   })
   fmt.Println(list)
}

我们定义了一个IMap 函数,对一个数组的元素进行f 操作,然后把值返回出来,由于list 是切片 是一个引用类型,所以我么直接在其上面修改值即可,这样我们的源切片的值,就会被直接改,节省了内存空间,但是这个其实违背了函数式编程的思想,函数式编程要求,不能修改输入的值。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券