Go语言的可变（不定长）参数函数-白红宇

一般情况一个函数的传入参数都是固定的，但是有一些函数能传入不定数量的参数（可变长的）。比如c语言中的printf。可以看：《》

在Go语言中，也有这样的函数。用法类似，也是三个点。

可变参数函数声明：

                  1          // 这个函数可以传入任意数量的整型参数         
       
                  2           func sum(nums ...int) { 
          
                  3               fmt.Println(nums)          
       
                  4               total := 0          
       
                  5               for _, num := range nums { 
          
                  6                   total += num          
       
                  7               }          
       
                  8               fmt.Println(total)          
       
                  9          }

这是可变参数的声明方式：

                  1          func Function(args …Type) { 
         
                  2                    
       
                  3          }

上面的三个点(…)就表示args是一个可变参数。在函数Function中，参数args是被当做一个slice来处理的。

可变参数函数的使用：

                  1          func main() { 
         
                  2               sum(1, 2)          
       
                  3               sum(1, 2, 3)          
       
                  4          }

可变参数的用法和一般的参数一样，只是可以随意的指定参数的个数。

给可变参数函数传递数组：

当然，我们的参数可能本来就是一个slice，但是函数不允许传入参数。所以只能反过来，把slice打散传入给函数。

                  1          func main() { 
         
                  2               // 如果你需要传入的参数在一个slice中，像下面一样          
       
                  3               // "func(slice...)"把slice打散传入          
       
                  4               nums := []int{1, 2, 3, 4}          
       
                  5               sum(nums...)          
       
                  6          }

使用时可变参数函数时可能遇到的错误：

这是我遇到的一个问题，在调用一个可变参数函数的时候。如果我把slice手动使用Function(slice[0],slice[1])这样传入，可以编译运行，但是如果我使用Function(slice …)就会爆如下错误。

                  1          cannot use args (type []string) as type []interface {} in function argument         
       

相关代码：

                  01          package main         
       
                  02                    
       
                  03          import (         
       
                  04               "fmt"          
       
                  05               "flag"          
       
                  06          )         
       
                  07                    
       
                  08          func main() { 
         
                  09               flag.Parse()          
       
                  10               fmt.Println(flag.Args()...)          
       
                  11          }

这是我在stackoverflow找到的问题的原因。（上面你的代码也是stackoverflow的）

其实，从错误代码中也可以看出来，这是变量类型的问题。[]string和[]interface {}类型的问题。估计在使用Function（slice…）这种，打散数组传递时，函数是直接把slice传递进去，而不是像一般的用法那样，单个合并到slice里。string传递给ingerface{}类型的变量是允许的，但是[]string无法转换成[]interface {}类型。

对此，我们只能手动把[]string类型转换成[]interface {}类型，再传参。

                  1          old := flag.Args()         
       
                  2           new := make([]interface{}, len(old))          
       
                  3           for i, v := range old { 
          
                  4               new[i] = interface{}(v)          
       
                  5          }         
       
                  6           fmt.Println(new...)

所以，解法就是写一个循环，把[]string类型转换成[]interface{}类型。

转载请注明： »