Go語言 可變參數

最近與同事討論時，提到Go語言的可變參數，之前沒有總結過相關知識點，今天我們介紹一下Go語言的可變參數。

可變參數（Variable Parameters）：參數數量可變的函數稱之為可變參數函數，主要是在使用語法糖（syntactic sugar）。最經典的例子就是fmt.Printf()和類似的函數，fmt.Printf首先接收一個參數，後面可接收若幹個參數。

在開始Go語言實例之前，我們先看一下在C語言裡面是如何實現可變參數的，如示例：

#include <stdio.h>
#include <stdarg.h>

int sum(int count, ...)
{
    int sum=0;
    int val=0;

    // 定義一個可變參數列表，可以看成是一種特殊的指針類型，list指向的對象是棧上的數據。
    va_list list;

    // 初始化list，list指向第一個被壓棧的參數，即函數的最後一個參數，而count則是棧上最後一個參數，系統由此確定棧上參數記憶體的範圍。
    va_start(list, count);

    while(count--)
    {
        // 通過va_arg依次獲取參數值，兩個參數，一個是指向棧上參數的指針list，
　　　　// 這個指針每取出一個數據移動一次，總是指向棧上第一個未取出的參數，
　　　　// int指需要取出的參數的類型，CPU根據這個類型所占的地址空間來進行定址。
        val = va_arg(list,int);
        // printf("%d at %X\n", val, &val);
        sum += val;
    }

    //釋放list，釋放後list置為空。
    va_end(list);

    return sum;
}

int main()
{
    printf("Sum of 1,2,3,4,5 = %d\n", sum(5, 1, 2, 3, 4, 5));
    printf("Sum of 10,20,30 = %d\n", sum(3, 10,20,30));
}

運行結果：

​

我們可以看到，在C語言裡面，需要指定參數個數和若幹個參數，下麵我們介紹一下Go語言中的實現。

實例一：

func1使用的是Go語言的語法糖，按照內部機制來說，...type本質是一個切片，也就是[]type，params被看作是類型為[] int的切片傳入func1中，func1可接收任意個int值，返回sum結果。

雖然在可變參數函數內部，...int型參數的行為看起來類似slice，實際上，可變參數函數和切片作為參數的函數是不相同的。

// 可變參數
func func1(params ...int) {

	sum := 0
	for _, param := range params {
		sum += param
	}

	fmt.Println("params : ", params, "\tsum : ", sum)
}

調用一：

func TestFunc1(t *testing.T) {
	var params = []int{1, 2, 3}
	func1(params...)
	func1(2, 5)
	func1(2, 5, 8)
}

結果一：

=== RUN   TestFunc1
params :  [1 2 3]       sum :  6
params :  [2 5]         sum :  7
params :  [2 5 8]       sum :  15
--- PASS: TestFunc1 (0.00s)

實例二：

func2雖然同樣實現了不定參數的功能，但是使用起來比較繁瑣，需要[]type{}來構造切片實例。我們可以看到傳遞的數據是slice，但是在參數傳遞的時候，我們需要手工初始化slice再傳入函數。

// 切片
func func2(params []int) {

	sum := 0
	for _, param := range params {
		sum += param
	}

	fmt.Println("params : ", params, "\tsum : ", sum)
}

調用二：

func TestFunc2(t *testing.T) {
	func2([]int{3})
	func2([]int{3, 6})
	func2([]int{3, 6, 9})
}

結果二：

=== RUN   TestFunc2
params :  [3]   sum :  3
params :  [3 6]         sum :  9
params :  [3 6 9]       sum :  18
--- PASS: TestFunc2 (0.00s)

綜上兩例，我們可以看出語法糖實現更簡潔方便。

實例三：

我們再看一下可變類型的可變參數，見func3：

// 可變類型的可變參數
func func3(params ...interface{}) {

	for _, param := range params {
		switch reflect.TypeOf(param).Kind().String() {
		case "int":
			fmt.Printf("param:%d is an int value!\n", param)
		case "int32":
			fmt.Printf("param:%v is an int32 value!\n", param)
		case "int64":
			fmt.Printf("param:%v is an int64 value!\n", param)
		case "float32":
			fmt.Printf("param:%v is an float32 value!\n", param)
		case "float64":
			fmt.Printf("param:%v is an float64 value!\n", param)
		case "string":
			fmt.Printf("param:%s is an string value!\n", param)
		case "func":
			fmt.Printf("param:%v is an func value!\n", param)
		case "map":
			fmt.Printf("param:%v is an map value!\n", param)
		default:
			fmt.Printf("param:%v is an unknown type.\n", param)
		}
	}
}

調用三：

func TestFunc3(t *testing.T) {
	var p1 int = 100 //傳遞int值
	func3(p1)

	var p2 int32 = 200 //傳遞int32
	func3(p2)

	var p3 int64 = 300 //傳遞int64
	func3(p3)

	var p4 = "test string" //傳遞string
	func3(p4)

	var p5 float32 = 1.11 //傳遞float32
	func3(p5)

	var p6 float64 = 2.22 //傳遞float64
	func3(p6)

	var p7 = func(a, b int) int { return a + b } //傳遞func
	func3(p7)

	var p8 = map[string]string{} ////傳遞map
	func3(p8)
}

結果三：

=== RUN   TestFunc3
param:100 is an int value!
param:200 is an int32 value!
param:300 is an int64 value!
param:test string is an string value!
param:1.11 is an float32 value!
param:2.22 is an float64 value!
param:0x506b50 is an func value!
param:map[] is an map value!
--- PASS: TestFunc3 (0.00s)
PASS

總結：

可變參數，主要是Go語言的語法糖之"...type"的使用。

參數個數靈活。