欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Go语言 可变参数

程序员文章站 2022-04-14 16:14:08
最近与同事讨论时,提到Go语言的可变参数,之前没有总结过相关知识点,今天我们介绍一下Go语言的可变参数。 可变参数(Variable Parameters):参数数量可变的函数称之为可变参数函数,主要是在使用语法糖(syntactic sugar)。最经典的例子就是fmt.Printf()和类似的函 ......

最近与同事讨论时,提到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)); }
Go语言 可变参数

运行结果:

Go语言 可变参数Go语言 可变参数

我们可以看到,在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)
}
Go语言 可变参数

调用一:

func testfunc1(t *testing.t) {
	var params = []int{1, 2, 3}
	func1(params...)
	func1(2, 5)
	func1(2, 5, 8)
}
Go语言 可变参数

结果一:

=== run   testfunc1
params :  [1 2 3]       sum :  6
params :  [2 5]         sum :  7
params :  [2 5 8]       sum :  15
--- pass: testfunc1 (0.00s)
Go语言 可变参数

实例二:

func2虽然同样实现了不定参数的功能,但是使用起来比较繁琐,需要[]type{}来构造切片实例。我们可以看到传递的数据是slice,但是在参数传递的时候,我们需要手工初始化slice再传入函数。

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

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

	fmt.println("params : ", params, "\tsum : ", sum)
}
Go语言 可变参数

调用二:

func testfunc2(t *testing.t) {
	func2([]int{3})
	func2([]int{3, 6})
	func2([]int{3, 6, 9})
}
Go语言 可变参数

结果二:

=== run   testfunc2
params :  [3]   sum :  3
params :  [3 6]         sum :  9
params :  [3 6 9]       sum :  18
--- pass: testfunc2 (0.00s)
Go语言 可变参数

综上两例,我们可以看出语法糖实现更简洁方便。

实例三:

我们再看一下可变类型的可变参数,见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)
		}
	}
}
Go语言 可变参数

调用三:

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)
}
Go语言 可变参数

结果三:

=== 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语言 可变参数

总结:

可变参数,主要是go语言的语法糖之"...type"的使用。

参数个数灵活。