细节汇总

1、函数的形参列表可以是多个，返回值列表也可以是多个
2、形参列表和返回值列表的数据类型，可以是值类型、也可以是引用类型
3、函数的命名遵循标识符命名规范，首字母不能是数字，首字母大写表示该函数可以被本包文件和其它文件使用，类似public；首字母小写只能被本包文件使用，类似private。
4、函数中的变量是局部的，外部不能访问。作用域
5、基本数据类型和数组都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值，
6、如果希望函数内的变量能够修改函数外的变量，可以传入变量的地址（&），函数内以指针的方式操作变量，从效果上看类似引用
7、Go函数不支持函数重载。
8、在Go中，函数也是一种数据类型，可以赋值给一个变量，则该变量是一个函数类型的变量，通过该变量可以对函数调用。
9、函数既然是一种数据类型，因此在Go中，函数也可以作为形参，并且调用。（回调函数）
10、为了简化数据类型定义，Go支持自定义数据类型
语法： type 自定数据类型名 数据类型 // (相当于一个别名)
案例： type myInt int // 这时，myInt就等价于int来使用了
type mySum func(int, int) int // 这时，mySum就等价于func(int, int) int
11、支持对函数返回值命名（可以不受返回值顺序限制）
12、使用 _ 下划线标识符，忽略返回值。（占位符）
13、Go支持可变参数

值传递和指针传递

  1. func test(n1 int) {
  2.     n1 = n1 + 10
  3.     fmt.Println("test n1=", n1)
  4. }
  6. // 指针类型接收处理
  7. func test02(n2 *int) {
  8.     *n2 = *n2 + 10
  9.     fmt.Println("test02 n2=", *n2)
  10. }
  12. func main() {
  13.     n1 := 20
  14.     n2 := 2
  15.     test(n1) // 值类型
  16.     test02(&n2) // 指针类型
  17.     fmt.Println("main n1=", n1)
  18.     fmt.Println("main n2=", n2)
  19. }

什么是重载

重载： 函数名相同，但是形参不同或者数据类型不同的情况
Golang语言中是不支持传统的函数重载的，fn redeclared in this block
Golang语言是支持可变参数的，空接口的形式
image.png

函数类型的变量

类型： func(int, int) int

  1. func getSum(n1 int, n2 int) int {
  2.     return n1 + n2
  3. }
  4. func getSums(n1 int, n2 int, n3 int) int {
  5.     return n1 + n2 + n3
  6. }
  8. // main 函数
  9. sumFn := getSum
  10. res := sumFn(10, 20)
  11. fmt.Printf("%T %v\n", res, res) // int 30
  12. fmt.Printf("%T \n", sumFn) // func(int, int) int
  14. sumsFn := getSums
  15. result := sumsFn(10, 20, 30)
  16. fmt.Printf("result : %T %v\n", result, result) // result : int 60
  17. fmt.Printf("sumsFn类型：%T \n", sumFn) // sumsFn类型：func(int, int) int

函数作为形参传入

  1. func getSum(n1 int, n2 int) int {
  2.     return n1 + n2
  3. }
  4. func testFn(fnVar func(int, int) int, num1 int, num2 int) int {
  5.     return fnVar(num1, num2) // 调用传入的函数，并返回值
  6. }
  8. // 函数类型形参
  9. sumFn := getSum
  10. total := testFn(sumFn, 1, 2)
  11. fmt.Println("total=", total) // 3

自定义数据类型

  1. // 自定义函数数据类型， 相当于起了一个别名
  2. type mySum func(int, int) int
  4. func testFn(fnVar mySum, num1 int, num2 int) int {
  5.     return fnVar(num1, num2)
  6. }
  8. // func testFn(fnVar func(int, int) int, num1 int, num2 int) int {
  9. //     return fnVar(num1, num2)
  10. // }
  13. main函数下
  14. // 自定义数据类型
  15. type myInt int
  16. var num1 myInt = 2
  17. // var num2 int = num1 // 这样是报错的， myInt和int并不等价
  18. var num2 int = int(num1) // 显式类型转换
  19. fmt.Printf("num1的类型：%T 值：%v \n", num1, num1) // num1的类型：main.myInt 值：2
  20. fmt.Printf("num2的类型：%T 值：%v \n", num2, num2) // num2的类型：int 值：2
  22. // 是定义的类型: 包名.类型名
  23. // 以下是utils包
  24. package utils
  26. import "fmt"
  28. func TestFn() string {
  29.     fmt.Println("TestFn 函数被调用")
  30.     type myInt int
  31.     var n myInt = 10
  32.     fmt.Printf("n的类型：%T 值：%v", n, n) // n的类型：utils.myInt 值：10
  33.     return "hahaha"
  34. }

返回值命名

  1. func sumSub(n1 int, n2 int) (sum int, sub int) {
  2.     // 这里不需要声明sum, sub变量了，也不用在return时写
  3.     sum = n1 + n2
  4.     sub = n1 - n2
  5.     return
  6. }
  8. // main函数
  9. sum, sub := sumSub(9, 8)
  10. fmt.Println("sum=", sum, "sub=", sub) // sum= 17 sub= 1

可变参数

基本语法
1、支持零到多个参数
func sum(args… int) {}
2、支持1到多个参数
func sum(n1 int, args… int) {}
args：就是一个承接的变量名，可以自定义，如：func sum(n1 int, vars… int) {}
说明：

  • args是slice切片，通过args[index]可以访问到各个值
  • args必须放到形参列表的最后面 ```go // 参数个数可变 func sumV2(n1 int, args …int) int { sum := n1 fmt.Printf(“args类型是：%T\n”, args) // args类型是：[]int // 遍历args切片 for i := 0; i < len(args); i++ {
    1.   sum += args[i]
    } return sum }

// main函数 // 参数可变 total02 := sumV2(1, 2, 3, 4) fmt.Println(“total02=”, total02) // total02= 10

  1. <a name="Rdfra"></a>
  2. # 练习
  3. 交换变量a, b的值
  4. ```go
  5. package main
  7. import "fmt"
  9. func swap(n1 *int, n2 *int) {
  10.     *n1 = *n1 + *n2
  11.     *n2 = *n1 - *n2 // *n1
  12.     *n1 = *n1 - *n2 // *n2
  13. }
  15. func main() {
  16.     a := 12
  17.     b := 20
  18.     swap(&a, &b)
  19.     fmt.Println("a = ", a, "b = ", b)
  20. }