最近與同事討論時，提到Go語言的可變引數，之前沒有總結過相關知識點，今天我們介紹一下Go語言的可變引數，
可變引數（Variable Parameters）：引數數量可變的函式稱之為可變引數函式，主要是在使用語法糖（syntactic sugar），最經典的例子就是fmt.Printf()和類似的函式，fmt.Printf首先接收一個引數，后面可接收若干個引數，
在開始Go語言實體之前，我們先看一下在C語言里面是如何實作可變引數的，如示例：
/n#include/n/nint sum(int count, ...)/n{/n int sum=0;/n int val=0;/n/n // 定義一個可變引數串列，可以看成是一種特殊的指標型別，list指向的物件是堆疊上的資料，/n va_list list;/n/n // 初始化list，list指向第一個被壓堆疊的引數，即函式的最后一個引數，而count則是堆疊上最后一個引數，系統由此確定堆疊上引數記憶體的范圍，/n va_start(list, count);/n/n while(count--)/n {/n // 通過va_arg依次獲取引數值，兩個引數，一個是指向堆疊上引數的指標list，這個指標每取出一個資料移動一次，總是指向堆疊上第一個未取出的引數，int指需要取出的引數的型別，CPU根據這個型別所占的地址空間來進行尋址，/n val = va_arg(list,int);/n // printf(/"%d at %X//n/", val, &val);/n sum += val;/n }/n/n //釋放list，釋放后list置為空，/n va_end(list);/n/n return sum;/n}/n/nint main()/n{/n printf(/"Sum of 1,2,3,4,5 = %d//n/", sum(5, 1, 2, 3, 4, 5));/n printf(/"Sum of 10,20,30 = %d//n/", sum(3, 10,20,30));/n}","classes":[]}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet"> #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"的使用，
引數個數靈活，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/24395.html
標籤：Go
上一篇：Go語言 命令列決議（一）