2.1.4 函数的参数传递

一、参数的使用

1. 函数可以有一个或多个参数，如果函数使用参数，则该参数可以被称为函数的形参，形参就像是定义在函数体内的局部变量

   1. 形参：定义函数时，用于接收外部传入的数据，叫做形式参数，简称形参

   2. 实参：调用函数时，传给形参的实际数据，叫做实际参数，简称实参

2. 函数参数调用需遵守如下规则：

   1. 函数名称必须匹配

   2. 实参与形参必须一一对应：顺序，个数，类型都需要一致

二、可变参数

1. Go语言函数支持可变参数(简称变参)，接收变参的函数有不定数量的参数。

2. 定义可接受变参的数据格式如下：

   func myFunction(args ...string) {
       // TODO:
   }

   备注：其中args ...string是指这个函数接收不定数量的字符串类型的参数

   这些参数的类型都是string

   在相应的函数体中，变量args是一个string的切片

三、参数传递

1. 在Go语言中，当调用一个函数时，可通过值传递、引用传递两种方式来传递参数

   1. 值传递

      1. 值传递是指在调用函数时将实际参数赋值一份专递到函数中。这样在函数中如果对参数进行修改，则不会影响实际参数

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

      // 定义一个相互交换值的函数
      func exchange(x, y int) int {
      	var tem int
      	tem = x
      	x = y
      	y = tem
      	return tem
      }
      
      func main() {
      	num1, num2 := 6, 8
      	fmt.Printf("交换前，num1: %d； num2: %d \n", num1, num2)
      
      	exchange(num1, num2)
      	fmt.Printf("交换后，num1: %d； num2: %d \n", num1, num2)
      
      }

      结果：

      交换前，num1: 6； num2: 8 
      交换后，num1: 6； num2: 8 

      原因：

      因为是值传递，所以交换失败

   2. 引用传递

      1. 引用传递是指在调用函数时将实际参数的地址传递到函数中，引用传递会在函数中对参数进行修改，因此会影响到实际参数

      func exchange2(x, y *int) int {
      	var tem int
      	tem = *x
      	*x = *y
      	*y = tem
      	return tem
      }
      
      func main() {
      	num1, num2 := 6, 8
      	fmt.Printf("交换前，num1: %d； num2: %d \n", num1, num2)
      
      	exchange2(&num1, &num2)
      	fmt.Printf("交换后，num1: %d； num2: %d \n", num1, num2)
      
      }
      

      结果：

      交换前，num1: 6； num2: 8 
      交换后，num1: 8； num2: 6 

四、函数作为参数传递

1. 在Go语言中，一个函数可以作为参数传递给另一个函数

   // Func 定义一个函数，参数为定义为func(int, int) int
   func Func(i func(int, int) int) int {
   	fmt.Printf("i type: %T \n", i)
   	return i(6, 9)
   }
   
   func main() {
   
   	f := func(x, y int) int {
   		return x + y
   	}
   
   	fmt.Printf("f type: %T \n", f)
   
   	fmt.Println(Func(f))
   
   }

   结果：

   f type: func(int, int) int 
   i type: func(int, int) int 
   15