Go 函数和方法：Go 语言中的函数和方法到底有什么不同？

函数初探

---

函数为什么是一等公民呢？和其他主流语言不同，在go里面函数的地位是不一样的。

与其他主要编程语⾔的差异

1. 可以有多个返回值
2. 函数也是一种类型
3. 所有参数都是值传递：slice，map，channel 会有传引⽤的错觉（在传递过去的时候，传入到函数当中，在函数里面修改参数的值，外面也可以感受到，难道这不是传引用吗？其实这是一个错觉，就比如slice，切片背后实际上对应的是数组，切片本身是一个数据结构，数据结构里面包含指向数组到指针，即便是在传值的情况下，结构被复制到函数里面了，通过指向数组到指针去操作具体值到时候，其实操作的是同一块空间，所以就会有一种传引用到错觉，实际上是结构被复制了，包含的指针指向到是同一个后端到数组，所以才有这个错觉）
4. 函数可以作为变量的值
5. 函数可以作为参数和返回值

在前面的，你已经见到了 Go 语言中一个非常重要的函数：main 函数，它是一个 Go 语言程序的入口函数，我在演示代码示例的时候，会一遍遍地使用它。

下面的示例就是一个 main 函数：

func main() {

}

它由以下几部分构成：

1. 任何一个函数的定义，都有一个 func 关键字，用于声明一个函数，就像使用 var 关键字声明一个变量一样

2. 然后紧跟的 main 是函数的名字，命名符合 Go 语言的规范即可，比如不能以数字开头

3. main 函数名字后面的一对括号 () 是不能省略的，括号里可以定义函数使用的参数，这里的 main 函数没有参数，所以是空括号 () 

4. 括号 () 后还可以有函数的返回值，因为 main 函数没有返回值，所以这里没有定义

5. 最后就是大括号 {} 函数体了，你可以在函数体里书写代码，写该函数自己的业务逻辑

函数声明

---

经过上一小节的介绍，相信你已经对 Go 语言函数的构成有一个比较清晰的了解了，现在让我们一起总结出函数的声明格式，如下面的代码所示： 

func funcName(params) result {
    body
}

这就是一个函数的签名定义，它包含以下几个部分：

1. 关键字 func

2. 函数名字 funcName

3. 函数的参数：params形参，用来定义形参的变量名和类型，可以有一个参数，也可以有多个，也可以没有

4. result 是返回的函数值，用于定义返回值的类型，如果没有返回值，省略即可，也可以有多个返回值

5. body 就是函数体，可以在这里写函数的代码逻辑

 现在，我们一起根据上面的函数声明格式，自定义一个函数，如下所示：

func sum(a int,b int) int{

    return a+b

}

这是一个计算两数之和的函数，函数的名字是 sum，它有两个参数 a、b，参数的类型都是 int。sum 函数的返回值也是 int 类型，函数体部分就是把 a 和 b 相加，然后通过 return 关键字返回，如果函数没有返回值，可以不用使用 return 关键字。

终于可以声明自己的函数了，恭喜你迈出了一大步！

函数中形参的定义和我们定义变量是一样的，都是变量名称在前，变量类型在后，只不过在函数里，变量名称叫作参数名称，也就是函数的形参，形参只能在该函数体内使用。函数形参的值由调用者提供，这个值也称为函数的实参，现在我们传递实参给 sum 函数，演示函数的调用，如下面的代码所示：

func main() {
   result:=sum(1,2)
   fmt.Println(result)
}

我们自定义的 sum 函数，在 main 函数中直接调用，调用的时候需要提供真实的参数，也就是实参 1 和 2。

函数的返回值被赋值给变量 result，然后把这个结果打印出来。你可以自己运行一下，能看到结果是 3，这样我们就通过函数 sum 达到了两数相加的目的，如果其他业务逻辑也需要两数相加，那么就可以直接使用这个 sum 函数，不用再定义了。

在以上函数定义中，a 和 b 形参的类型是一样的，这个时候我们可以省略其中一个类型的声明，如下所示：

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

像这样使用逗号分隔变量，后面统一使用 int 类型，这和变量的声明是一样的，多个相同类型的变量都可以这么声明。

	var b,n int
    fmt.Println(b,n)

多值返回

---

同有的编程语言不一样，Go 语言的函数可以返回多个值，也就是多值返回。在 Go 语言的标准库中，你可以看到很多这样的函数：第一个值返回函数的结果，第二个值返回函数出错的信息，这种就是多值返回的经典应用。

对于 sum 函数，假设我们不允许提供的实参是负数，可以这样改造：在实参是负数的时候，通过多值返回，返回函数的错误信息，如下面的代码所示：

func sum(a, b int) (int,error){
    if a<0 || b<0 {
       return 0,errors.New("a或者b不能是负数")
    }
    return a + b,nil
}

这里需要注意的是，如果函数有多个返回值，返回值部分的类型定义需要使用小括号括起来，也就是 (int,error)。这代表函数 sum 有两个返回值，第一个是 int 类型，第二个是 error 类型，我们在函数体中使用 return 返回结果的时候，也要符合这个类型顺序。

在函数体中，可以使用 return 返回多个值，返回的多个值通过逗号分隔即可，返回多个值的类型顺序要和函数声明的返回类型顺序一致，比如下面的例子： 

return 0,errors.New("a或者b不能是负数")

返回的第一个值 0 是 int 类型，第二个值是 error 类型，和函数定义的返回类型完全一致。定义好了多值返回的函数，现在我们用如下代码尝试调用：

func main() {

    result,err := sum(1, 2)

    if err!=nil {
        fmt.Println(err)

    }else {
        fmt.Println(result)
    }

}

函数有多值返回的时候，需要有多个变量接收它的值，示例中使用 result 和 err 变量，使用逗号分开。

如果有的函数的返回值不需要，可以使用下划线 _ 丢弃它，这种方式我在 for range 循环那节课里也使用过，如下所示：

result,_ := sum(1, 2)

这样即可忽略函数 sum 返回的错误信息，也不用再做判断。

提示：这里使用的 error 是 Go 语言内置的一个接口，用于表示程序的错误信息，后续课程我会详细介绍。 

命名返回值

在函数返回值列表中可指定变量名，变量在调用时会根据类型使用零值进行初始化，在函数体中可进行赋值，同时在调用 return 时不需要添加返回值，go 语言自动将变量的最终结果进行返回。

在使用命名返回值时，当声明函数中存在 若多个连续返回值类型相同可只保留最后一个返回

值类型名。

 命名返回值尽量少用，在里面代码逻辑简单可以使用，里面代码复杂不建议使用。

可变参数

---

可变参数的调用和解包（解包针对切片）

可变参数可以是1个元素，可以是多个元素，哪种数据类型是可以有多个元素的，并且是可变的，所以这就是一个切片。

在函数里面是不可以定义多个可变参数的，只能定义一个可变参数，并且可变参数是行参数的最后。

某些情况下函数需要处理形参数量可变，需要运算符…声明可变参数函数或在调用时传递可变参数

a) 定义

可变参数只能定义一个且只能在参数列表末端。在调用函数后，可变参数则被初始化为对应类型的切片(参数初始化切片的长度和容量都是一样大)

func printArgs(a, b int, str ...string) string {
	fmt.Println(len(str), cap(str))
	for i, v := range str {
		fmt.Println(i, v)
	}
	return fmt.Sprintf("%d-%d-%s", a, b, str)
}

func main() {
	fmt.Println(printArgs(1, 2, "a", "b"))
}


2 2
0 a      
1 b      
1-2-[a b]

b) 传递

在调用函数时，也可以使用运算符…将切片解包传递到可变参数函数中

 

func sum(ops ...int) int {
 s := 0
 for _, op := range ops {
 s += op
 }
 return s
}

可变参数，就是函数的参数数量是可变的，比如最常见的 fmt.Println 函数。

同样一个函数，可以不传参数，也可以传递一个参数，也可以两个参数，也可以是多个等等，这种函数就是具有可变参数的函数，如下所示：

fmt.Println()
fmt.Println("飞雪")
fmt.Println("飞雪","无情")

下面所演示的是 Println 函数的声明，从中可以看到，定义可变参数，只要在参数类型前加三个点 … 即可：

func Println(a ...interface{}) (n int, err error)

现在我们也可以定义自己的可变参数的函数了。还是以 sum 函数为例，在下面的代码中，我通过可变参数的方式，计算调用者传递的所有实参的和：

func sum1(params ...int) int {
    sum := 0
    for _, i := range params {
        sum += i
    }
    return sum
}

为了便于和 sum 函数区分，我定义了函数 sum1，该函数的参数是一个可变参数，然后通过 for range 循环来计算这些参数之和。

讲到这里，相信你也看明白了，可变参数的类型其实就是切片，比如示例中 params 参数的类型是 []int，所以可以使用 for range 进行循环。 

函数有了可变参数，就可以灵活地进行使用了。

如下面的调用者示例，传递几个参数都可以，非常方便，也更灵活：

fmt.Println(sum1(1,2))
fmt.Println(sum1(1,2,3))
fmt.Println(sum1(1,2,3,4))

这里需要注意，如果你定义的函数中既有普通参数，又有可变参数，那么可变参数一定要放在参数列表的最后一个，比如 sum1(tip string,params …int) ，params 可变参数一定要放在最末尾。

包级函数

---

不管是自定义的函数 sum、sum1，还是我们使用到的函数 Println，都会从属于一个包，也就是 package。sum 函数属于 main 包，Println 函数属于 fmt 包。

同一个包中的函数哪怕是私有的（函数名称首字母小写）也可以被调用。如果不同包的函数要被调用，那么函数的作用域必须是公有的，也就是函数名称的首字母要大写，比如 Println。

这里可以先记住：

• 函数名称首字母小写代表私有函数，只有在同一个包中才可以被调用
• 函数名称首字母大写代表公有函数，不同的包也可以调用
• 任何一个函数都会从属于一个包

小提示：Go 语言没有用 public、private 这样的修饰符来修饰函数是公有还是私有，而是通过函数名称的大小写来代表，这样省略了烦琐的修饰符，更简洁。 

匿名函数(函数可以作为变量的值)和闭包(函数可以作为返回值)

---

匿名函数

顾名思义，匿名函数就是没有名字的函数，这是它和正常函数的主要区别。

匿名函数就是一个没有名字的函数，当我们在一个函数内部重复调用一段代码， 并且这段代码不想 被别的函数使用，我们就可以定义一个匿名函数，或者在一段代码需要并发的时候使用匿名函数。

在下面的示例中，变量 sum2 所对应的值就是一个匿名函数。需要注意的是，这里的 sum2 只是一个函数类型的变量，并不是函数的名字。

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

   fmt.Println(sum2(1, 2))

通过 sum2，我们可以对匿名函数进行调用，以上示例算出的结果是 3，和使用正常的函数一样。

func main(){

//将匿名函数fun 赋给变量test_fun
//则test_fun的数据类型是函数类型，可以通过test_fun完成调用
        test_fun := func (n1 int, n2 int) int {
        return n1 - n2
    }

    res2 := test_fun(10, 30)
    res3 := test_fun(50, 30)
    fmt.Println("res2=", res2)
    fmt.Println("res3=", res3)
    fmt.Printf("%T", test_fun)
}

/*
res2= -20
res3= 20
func(int, int) int
*/

闭包

• 在函数外部访问函数内部变量成为可能
• 闭包函数的返回值是匿名函数
• 这种用法主要场景就是未免函数内部的环境（变量等）被外部污染，如gin中间件

有了匿名函数，就可以在函数中再定义函数（函数嵌套），定义的这个匿名函数，也可以称为内部函数。更重要的是，在函数内定义的内部函数，可以使用外部函数的变量等，这种方式也称为闭包。

我们用下面的代码进行演示：

func main() {
    cl:=colsure()
    fmt.Println(cl())
    fmt.Println(cl())
    fmt.Println(cl())
}


#返回一个函数
func colsure() func() int {

    i:=0

    return func() int {
        i++
        return i
    }

}

运行这个代码，你会看到输出打印的结果是：

1
2
3

这都得益于匿名函数闭包的能力，让我们自定义的 colsure 函数，可以返回一个匿名函数，并且持有外部函数 colsure 的变量 i。因而在 main 函数中，每调用一次 cl()，i 的值就会加 1。

小提示：在 Go 语言中，函数也是一种类型，它也可以被用来声明函数类型的变量、参数或者作为另一个函数的返回值类型。 

补充：

很多时候函数只要使用一次，不具有代码的复用性，临时使用的时候可以使用匿名函数。匿名函数就是没有名字的函数。

	a := func(){
       fmt.Println("我是匿名函数")
	}
	fmt.Println(reflect.TypeOf(a))
	a()


func()
我是匿名函数

	start := func(txt string)string {
      return "*" + txt + "*"
	}
	fmt.Println(start("jack"))

闭包
函数调用栈在调用完之后，里面的内存会释放掉。但是有一种场景下不会释放。比如一个函数里面又有一个函数引用来外部函数里面的参数。

这种在函数内部引用函数外部的变量，当函数返回以后，外部的变量base不能够及时的销毁，如果销毁了，函数返回的时候里面函数去访问外部变量就会报错不存在。

在函数内部引用函数外部的变量，这种在函数内部去引用函数外部的变量使得函数变量的生命周期发生了变化，这种就叫做闭包。

闭包常常就是用来返回一个函数，会去引用外部函数的一些变量。

func addBase(base int) func(int) int {
   return func(sum int) int {
     return base + sum
   }
}

func main()  {
	add1 := addBase(2)
	fmt.Println(add1(4))
}

函数变量作用域

---

1. 全局变量

全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。 在函数中可以访问到全局变量

//定义全局变量 num var num int64 = 10

func main() {
fmt.Printf("num=%d\n", num) //num=10 
}

2. 局部变量

局部变量是函数内部定义的变量， 函数内定义的变量无法在该函数外使用，例如下面的示例代码 main 函数中无法使用 test 函数中定义的变量 name

func main() { 
// 这里name是函数test的局部变量，在其他函数无法访问 
//fmt.Println(name) 
test() }

func test() { 
name := "zhangsan"
fmt.Println(name) 
}

3. for 循环语句中定义的变量

我们之前讲过的 for 循环语句中定义的变量，也是只在 for 语句块中生效

func main() { 
testLocalVar3() 
}

func testLocalVar3() {

for i := 0; i < 10; i++ {
fmt.Println(i) //变量 i 只在当前 for 语句块中生效 }
// fmt.Println(i) //此处无法使用变量 i 
}

方法

---

不同于函数的方法，在 Go 语言中，方法和函数是两个概念，但又非常相似，不同点在于方法必须要有一个接收者，这个接收者是一个类型，这样方法就和这个类型绑定在一起，称为这个类型的方法。

在下面的示例中，type Age uint 表示定义一个新类型 Age，该类型等价于 uint，可以理解为类型 uint 的重命名。其中 type 是 Go 语言关键字，表示定义一个类型，在结构体和接口中会详细介绍。

type Age uint

func (age Age) String(){
    fmt.Println("the age is",age)
}

示例中方法 String() 就是类型 Age 的方法，类型 Age 是方法 String() 的接收者。

和函数不同，定义方法时会在关键字 func 和方法名 String 之间加一个接收者 (age Age) ，接收者使用小括号包围。

接收者的定义和普通变量、函数参数等一样，前面是变量名，后面是接收者类型。

现在方法 String() 就和类型 Age 绑定在一起了，String() 是类型 Age 的方法。

定义了接收者的方法后，就可以通过点操作符调用方法，如下面的代码所示：

func main() {
    age:=Age(25)
    age.String()
}

运行这段代码，可以看到如下输出：

the age is 25

接收者就是函数和方法的最大不同，此外，上面所讲到的函数具备的能力，方法也都具备。

提示：因为 25 也是 unit 类型，unit 类型等价于我定义的 Age 类型，所以 25 可以强制转换为 Age 类型。

下面可以看到在time结构体上面有很多方法 

 

 

 

值类型接收者和指针类型接收者

---

方法的接收者除了可以是值类型，也可以是指针类型。

定义的方法的接收者类型是指针，所以我们对指针的修改是有效的，如果不是指针，修改就没有效果，如下所示：

func (age *Age) Modify(){
    *age = Age(30)
}

调用一次 Modify 方法后，再调用 String 方法查看结果，会发现已经变成了 30，说明基于指针的修改有效，如下所示：

age:=Age(25)
age.String()
age.Modify()
age.String()

提示：在调用方法的时候，传递的接收者本质上都是副本，只不过一个是这个值副本，一是指向这个值指针的副本。指针具有指向原有值的特性，所以修改了指针指向的值，也就修改了原有的值。我们可以简单地理解为值接收者使用的是值的副本来调用方法，而指针接收者使用实际的值来调用方法。

示例中调用指针接收者方法的时候，使用的是一个值类型的变量，并不是一个指针类型，其实这里使用指针变量调用也是可以的，如下面的代码所示：

(&age).Modify()

这就是 Go 语言编译器帮我们自动做的事情：

• 如果使用一个值类型变量调用指针类型接收者的方法，Go 语言编译器会自动帮我们取指针调用，以满足指针接收者的要求。

• 同样的原理，如果使用一个指针类型变量调用值类型接收者的方法，Go 语言编译器会自动帮我们解引用调用，以满足值类型接收者的要求。

总之，方法的调用者，既可以是值也可以是指针，不用太关注这些，Go 语言会帮我们自动转义，大大提高开发效率，同时避免因不小心造成的 Bug。

不管是使用值类型接收者，还是指针类型接收者，要先确定你的需求：在对类型进行操作的时候是要改变当前接收者的值，还是要创建一个新值进行返回？这些就可以决定使用哪种接收者。

 

 

总结

---

在 Go 语言中，虽然存在函数和方法两个概念，但是它们基本相同，不同的是所属的对象。函数属于一个包，方法属于一个类型，所以方法也可以简单地理解为和一个类型关联的函数。

不管是函数还是方法，它们都是代码复用的第一步，也是代码职责分离的基础。掌握好函数和方法，可以让你写出职责清晰、任务明确、可复用的代码，提高开发效率、降低 Bug 率。