Golang - 4 Golang 函数

目录

• 4 Golang 函数
  • 函数
    • （1）语法规则
    • （2） 匿名函数
    • （3）闭包函数
    • （4）可变长参数
    • （5）defer延迟调用
    • （6）类型命名

4 Golang 函数

函数

函数 是将一个或者一类问题包装为一个代码块，可以被多次调用，提高代码重用性。

函数也是一种类型，参数和返回值都是类型的一部分，并且返回值可以是一个函数

（1）语法规则

func 函数名(参数1 类型, 参数2 类型, ...) (返回值1类型, 返回值2类型, ...) {
 
		逻辑...
    return 返回值1, 返回值2, ...
}	

• 普通函数

// 普通函数，有参数 有返回值
func sayHello(name,sentence string) string {
   fmt.Printf("%s说了：%s",name,sentence)
   return sentence
}
 
// 调用
sayHello("duoduo","hello world!")

（2） 匿名函数

匿名函数赋值给一个变量

var a string = "duoduo"
 
func test(b int) {
   var f func() int = func() int {
      fmt.Printf(a)
      return b
   }
   f()
}

（3）闭包函数

定义在函数内部，对外部作用域有引用

func test1() func() {
   t := 10
   ff := func() {
      fmt.Println(t)
   }
   return ff
}

（4）可变长参数

可以传任意长度的int类型参数，用变量 ...类型来接收，但是只能接收同一种类型的参数

比如：

• int 就是切片类型[]int

• string 就是切片类型[]string

 
// 如果是int类型，就是
func test1(a ...int) {
	fmt.Printf("%T", a)  // []int
}
 
 
func test2(a ...string) {
	fmt.Printf("%T", a) // []string
}

（5）defer延迟调用

延迟调用，当前函数所有代码都执行完了，再执行

• defer先注册后调用

var a int = 10
 
defer func(i int) {
   fmt.Println(i)
   defer fmt.Println("延迟调用")
   defer fmt.Println("1",i)
   fmt.Println("a1",a)
   i = 99
   a=99
   fmt.Println("a2",a)
   defer fmt.Println("2",i)
}(a)
------------------------------------------
a1 10
a2 99
2 99
1 10
延迟调用
 
===========================================
defer func() {
		fmt.Println("b1",a) // 99
		a=99
		fmt.Println("b2",a) // 99
	}()
-------------------------------------------
b1 99
b2 99

（6）类型命名

当传入的类型比较复杂的时候，可以使用type进行 类型命名，简化书写

func test2 (func()) func(int, int) int {
   return func(a, b int) int {
      return a + b
   }
}
f := test2(func() {})
res :=f(10,12)
fmt.Println(res)
==================简化===============
type  MyFunc = func(int, int) int
func test2 (func()) MyFunc {
	return func(a, b int) int {
		return a + b
	}
}
 

• 注意：类型命名后，与原类型就不是同一种类型了

type NewInt = int
var aa int8 = 10
var bb NewInt = 10
fmt.Println(aa+bb)