函数是基本的代码块，用于执行一个任务 Go 语言最少有个 main() 函数 你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务 函数声明告诉了编译器函数的名称，返回类型，和参数 Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数

函数定义

Go 语言函数定义格式如下：

  1. func function_name( [parameter list] ) [return_types] {
  2.    函数体
  3. }
  • func 函数由 func 开始声明
  • function_name 函数名称，函数名和参数列表一起构成了函数签名
  • parameter list 参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数
  • return_types 返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的
  • 函数体 函数定义的代码集合

以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：

  1. package main
  2. import "fmt"
  4. // 函数返回两个数的最大值
  5. func max(num1, num2 int) int {
  6.     // 声明局部变量
  7.     var result int
  8.     if (num1 > num2) {
  9.             result = num1
  10.     } else {
  11.             result = num2
  12.     }
  13.     return result 
  14. }
  16. func main() {
  17.     fmt.Printf("%d\n",max(1,2))
  18. }

函数调用

当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务
调用函数，向函数传递参数，并返回值，例如：

  1. package main
  2. import "fmt"
  4. func main() {
  5.   //  定义局部变量
  6.    var a int = 100
  7.    var b int = 200
  8.    var ret int
  11.    ret = max(a, b) // 调用函数并返回最大值
  12.    fmt.Printf( "最大值是 : %d\n", ret )
  13. }
  15. // 函数返回两个数的最大值
  16. func max(num1, num2 int) int {
  17.    var result int
  18.    if (num1 > num2) {
  19.       result = num1
  20.    } else {
  21.       result = num2
  22.    }
  23.    return result 
  24. }
  26. /* 
  27. 以上实例在 main() 函数中调用 max（）函数，执行结果为：
  28. 最大值是 : 200 
  29. */

函数返回多个值与使用下标_接收

Go 函数可以返回多个值，例如：

  1. package main
  2. import "fmt"
  4. func swap(x, y string) (string, string) {
  5.    return x, y
  6. }
  8. func main() {
  9.    a, b := swap("Google", "android")
  10.    c, _ := swap("Apple", "ios")
  12.    fmt.Println(a, b, c)
  13. }
  15. /* 
  16. 以上实例执行结果为：
  17. Google android Apple
  18. */

函数参数的传递

函数如果使用参数，该变量可称为函数的形参 形参就像定义在函数体内的局部变量

调用函数，可以通过两种方式来传递参数：

传递类型 描述
值传递 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数

⚠️ 默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数

传递值

传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数

  1. package main
  2. import "fmt"
  4. func main() {
  5.    /* 定义局部变量 */
  6.    var a, b int = 100, 200
  8.    fmt.Printf("交换前 a=%d, b=%d\n", a,b )
  9.    swap(a, b) // 通过调用函数来交换值
  10.    fmt.Printf("交换后 a=%d, b=%d\n", a,b )
  11. }
  14. // 定义相互交换值的函数
  15. func swap(x, y int) int {
  16.    var temp int
  17.    temp = x  //保存 x 的值 
  18.    x = y     //将 y 值赋给 x 
  19.    y = temp  //将 temp 值赋给 y
  20.    return temp;
  21. }
  24. func swap1(x int,y int)  {
  25.    var temp int
  26.    temp = x + y
  27.    y = temp - y
  28.    x = temp - x
  29. }
  31. func swap2(x int,y int)  {
  32.   x =x ^ y
  33.   y =x ^ y
  34.   x =x ^ y
  35. }
  37. func swap3(x int,y int)  {
  38.   x, y = y, x
  39. }
  41. /* 
  42. 交换前 a=100, b=200
  43. 交换后 a=100, b=200
  44. */

程序中使用的是值传递, 所以两个值并没有实现交互，我们可以使用 引用传递 来实现交换效果

引用传递

  1. package main
  2. import "fmt"
  4. func main() {
  5.    /* 定义局部变量 */
  6.    var a, b int = 100, 200
  8.    fmt.Printf("交换前 a=%d, b=%d\n", a,b )
  9.    swap(&a, &b)
  10.    fmt.Printf("交换后 a=%d, b=%d\n", a,b )
  11. }
  14. // 定义相互交换值的函数
  15. func swap(x , y *int) int {
  16.    var temp int
  17.    temp = *x   //保存 x 的值 
  18.    *x = *y     //将 y 值赋给 x 
  19.    *y = temp   //将 temp 值赋给 y
  20.    return temp;
  21. }
  24. func swap1(x *int,y *int)  {
  25.    var temp int
  26.    temp = *x + *y
  27.    *y = temp - *y
  28.    *x = temp - *x
  29. }
  31. func swap2(x *int,y *int)  {
  32.   *x =*x ^ *y
  33.   *y =*x ^ *y
  34.   *x =*x ^ *y
  35. }
  37. func swap3(x *int,y *int)  {
  38.   *x, *y = *y, *x
  39. }
  41. /* 
  42. 交换前 a=100, b=200
  43. 交换后 a=200, b=100
  44. */

函数可变参数

Go支持可变长参数列表 … 的函数可以支持任意个传入参数，比如fmt.Println函数就是一个支持可变长参数列表的函数

  1. package main
  2. import "fmt"
  4. // 这个函数可以传入任意数量的整型参数
  5. func sum(nums ...int) {
  6.     total := 0
  7.     for _, num := range nums {
  8.         total += num
  9.     }
  10.     fmt.Printf("传入的可变参数nums=%v,每项相加的总和total=%d\n", nums, total)
  11. }
  13. func main() {
  14.     // 支持可变长参数的函数调用方法和普通函数一样, 也支持只有一个参数的情况
  15.     sum(1, 2)
  16.     sum(1, 2, 3)
  18.     // 如果你需要传入的参数在一个切片中，像下面一样,"func(slice...)"把切片打散传入
  19.     nums := []int{1, 2, 3, 4}
  20.     sum(nums...)
  21. }
  23. /* 
  24. 传入的可变参数nums=[1 2],每项相加的总和total=3
  25. 传入的可变参数nums=[1 2 3],每项相加的总和total=6
  26. 传入的可变参数nums=[1 2 3 4],每项相加的总和total=10 
  27. */

函数用法

函数用法 描述
函数作为另外一个函数的实参 函数定义后可作为另外一个函数的实参数传入
闭包 闭包是匿名函数，可在动态编程中使用
方法 方法就是一个包含了接受者的函数

函数作为实参

Go 语言可以很灵活的创建函数，并作为另外一个函数的实参。以下实例中我们在定义的函数中初始化一个变量，该函数仅仅是为了使用内置函数 math.sqrt()，示例为：

  1. package main
  2. import (
  3.    "fmt"
  4.    "math"
  5. )
  7. func main(){
  8.   //  声明函数变量
  9.    getSquareRoot := func(x float64) float64 {
  10.       return math.Sqrt(x)
  11.    }
  13.   //  使用函数
  14.    fmt.Println(getSquareRoot(9))
  16. }
  18. /* 
  19. 以上代码执行结果为：
  20. 3 
  21. */

函数作为参数传递，实现回调

  2. package main
  3. import "fmt"
  5. func main() {
  6.     testCallBack(1, callBack)
  7.     testCallBack(2, func(x int) int {
  8.         fmt.Printf("我是回调，x：%d\n", x)
  9.         return x
  10.     })
  11. }
  13. // 声明一个函数类型
  14. type cb func(int) int
  16. func testCallBack(x int, f cb) {
  17.     f(x)
  18. }
  20. func callBack(x int) int {
  21.     fmt.Printf("我是回调，x：%d\n", x)
  22.     return x
  23. }
  25. /* 
  26. 我是回调，x：1
  27. 我是回调，x：2 
  28. */

闭包

闭包传递的是功能(引用)+数据(值),在其他语言(python,JavaScript)中比对象的功能少少一点但不耗费资源,是隔离数据使用功能的优先选择
Go 语言支持匿名函数，可作为闭包。匿名函数是一个”内联”语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明
以下实例中，我们创建了函数 getSequence() ，返回另外一个函数。该函数的目的是在闭包中递增 i 变量，代码如下

  1. package main
  2. import "fmt"
  4. func getSequence() func() int {
  5.    i:=0
  6.    return func() int {
  7.       i+=1
  8.      return i  
  9.    }
  10. }
  12. func main(){
  13.   //  nextNumber 为一个函数，函数 i 为 0
  14.    nextNumber := getSequence()  
  16.   //  调用 nextNumber 函数，i 变量自增 1 并返回
  17.    fmt.Println(nextNumber())
  18.    fmt.Println(nextNumber())
  19.    fmt.Println(nextNumber())
  21.    fmt.Println("——————————————————————————————")
  23.   //  创建新的函数 nextNumber1，并查看结果
  24.    nextNumber1 := getSequence()  
  25.    fmt.Println(nextNumber1())
  26.    fmt.Println(nextNumber1())
  27. }
  29. /* 
  30. 1
  31. 2
  32. 3
  33. ——————————————————————————————
  34. 1
  35. 2
  36. */

方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。更多介绍请查看 Go语言 结构体 所有给定类型的方法属于该类型的方法集。语法格式如下

  1. func (variable_name variable_data_type) function_name() [return_type]{
  2.    /* 函数体*/
  3. }

下面定义一个结构体类型和该类型的一个方法

  1. package main
  2. import (
  3.   "fmt"
  4. )
  6. // 定义结构体
  7. type Circle struct {
  8.   radius float64
  9. }
  11. //该 method 属于 Circle 类型对象中的方法
  12. func (c Circle) getArea() float64 {
  13.   //c.radius 即为 Circle 类型对象中的属性
  14.   return 3.14 * c.radius * c.radius
  15. }
  17. func main() {
  18.   var c1 Circle = Circle{radius:10.00}
  19.   c1.radius = 10.00
  20.   fmt.Println(c1.getArea())
  21. }
  23. /* 
  24. 以上代码执行结果为：
  25. 圆的面积 =  314 
  26. */

Go 没有面向对象，而我们知道常见的 Java、C++ 、TypeScript、Python等语言中，实现类的方法做法都是编译器隐式的给函数加一个 this 指针，而在 Go 里，这个 this 指针需要明确的申明出来，其实和其它 OO语言 并没有很大的区别,各个语言的对比

  1. //—————————————————————— C++ ——————————————————————
  2. class Circle {
  3.   public:
  4.     float getArea() {
  5.        return 3.14 * radius * radius;
  6.     }
  7.   private:
  8.     float radius;
  9. }
  10. // 其中 getArea 经过编译器处理大致变为
  11. float getArea(Circle *const c) {
  12.   ...
  13. }
  15. //—————————————————————— Java ——————————————————————
  16. public class Circle {
  17.     final private double radius;
  19.     public Circle(double radius) {
  20.         this.radius = radius;
  21.     }
  22.     public double getArea() {
  23.         return 3.14 * this.radius * this.radius;
  24.     }
  26.     public static void main(final String[] args) {
  27.          Circle c = new Circle(10);
  28.          System.out.println(c.getArea());
  29.     }
  30. }
  32. //—————————————————————— TypeScript ——————————————————————
  33. class Circle {
  34.   private radius: number;
  35.   constructor(radius) { 
  36.     this.radius = radius
  37.   }
  38.   getArea() {
  39.     return 3.14 * this.radius * this.radius;
  40.   }
  41. }
  43. const c = new Circle(10);
  44. console.log(c.getArea());
  46. //—————————————————————— Python ——————————————————————
  47. class Circle(object):
  48.     def __init__(self, radius, *args):
  49.         self.radius = radius
  50.         super(Circle, self).__init__()
  52.     def getArea(self):
  53.         return 3.14 * self.radius * self.radius
  55. if __name__ == "__main__":
  56.     print(Circle(10,20).getArea())

关于值和指针，如果想在方法中改变结构体类型的属性，需要对方法传递指针，体会如下对结构体类型改变的方法 changRadis() 和普通的函数 change() 中的指针操作:

  1. package main
  2. import (
  3.    "fmt"  
  4. )
  6. /* 定义结构体 */
  7. type Square struct {
  8.   radius float64
  9. }
  11. func (s Square) getSquareArea() float64  {
  12.    return s.radius * s.radius
  13. }
  16. func main()  { 
  17.    var s Square
  18.    fmt.Println(s.radius)
  20.    s.radius = 10.00
  21.    fmt.Println(s.getSquareArea())
  23.    s.changeRadius(20)
  24.    fmt.Println(s.radius)
  26.    change(&s, 30)
  27.    fmt.Println(s.radius)
  28. }
  31. // 引用类型要想改变值需要传指针
  32. func change(s *Square, radius float64)  {
  33.    s.radius = radius
  34. }
  36. // 注意如果想要更改成功c的值，这里需要传指针
  37. func (s *Square) changeRadius(radius float64)  {
  38.    s.radius = radius
  39. }
  41. // 以下操作将不生效
  42. func (s Square) noChangeRadius(radius float64)  {
  43.   s.radius = radius
  44. }
  46. /* 
  47. 0
  48. 100
  49. 20
  50. 30
  51. */