原文：https://blog.csdn.net/CMbug/article/details/49592585

今天的一个例子中发现，对于在调用可变参数函数时，不是总能使用省略号将一个切片展开，有时候编译器可能会报错，为了清楚的说明这个问题，我用几个小例子一步一步说明。

1. 提出假想的需求

假如想要在一堆数据中找出最小的一个，该怎么做？

如果数据的类型为int，那么我可以这么做：

func MinimumInt(first int, others ...int) int {
    min := first
    for _, value := range others {
        if value < min {
            min = value
        }
    }
    return min
}

上述的MinimumInt函数的第二个参数声明为：others …int，表示这是一个可变参数，可以给它传入0个或者任意多个int型参数，在该函数内部，它被表示成一个切片。而声明第一个参数，仅仅是为了让调用者必须传入至少一个参数，如果写成

func MinimumInt(others ...int) int {
}

则此函数接收一个可变参数，甚至长度可为0（即不传入参数），显然，不传入参数时调用该函数不满足提出的需求。

对于MinimumInt函数的调用，可通过如下的几种方式：

    MinimumInt(10, 15, 32, 46, 2, 3)  //1
    var sliceInt = []int{10, 15, 32, 46, 2, 3}
    MinimumInt(sliceInt[0], sliceInt[1], sliceInt[2], sliceInt[3], sliceInt[4], sliceInt[5])  //2
    MinimumInt(sliceInt[0], sliceInt[1:]...)  //3

对于第一种调用方式，直接使用了int类型的字面值常量来作为参数，在MinimumInt函数内部除第一参数外的所有参数被放入到了一个int型切片中进行处理；
第二种调用方式，本质上和第一种相同，只是不再使用字面值常量，而事先构建了一个int型切片，使用该切片的元素依次作为参数；
第三种调用方式，实际上可看做第二种的简化版本，只不过使用了省略号(…)来自动展开切片；

2. 完善需求

上面的例子中，我们仅仅做了对int型数据的处理，如果数据是其他类型呢？能否实现一个通用的处理函数，可以处理几乎所有类型的数据？

对于这个问题，在C++中很容易通过泛型来解决，Go中虽不支持这么做，但也还是有解决方法–空接口

func Minimum(first interface{}, rest ...interface{}) interface{} {
    min := first
    for _, value := range rest {
        switch value := value.(type) {
        case int:
            if value < min.(int) {
                min = value
            }
        case float64:
            if value < min.(float64) {
                min = value
            }
        case string:
            if value < min.(string) {
                min = value
            }
        }
    }
    return min
}

对于上述函数，将其参数类型声明为空接口interface{}，同时返回值也为interface{}，这样，该函数就能接收任意类型的数据，并且对于第二个参数来说，参数的数目也是任意的。然后在函数中使用非检查类型断言来分别处理不同类型的数据，这里使用了一个基于类型开关的switch语句。

对于Minimum函数的调用方式，先做一些尝试：

    Minimum(10, 15, 32, 46, 2, 3)  //1
    var sliceInt = []int{10, 15, 32, 46, 2, 3}
    Minimum(sliceInt[0], sliceInt[1], sliceInt[2], sliceInt[3], sliceInt[4], sliceInt[5])  //2
    Minimum(sliceInt[0], sliceInt[1:]...)  //3

总体来说，调用方式和MinimumInt函数一致：
第一个直接使用字面值常量；
第二个先构造切片，依次使用每个元素
第三个使用切片，并试图用省略号自动展开切片以使用每个元素

但是，当我们编译时却发现编译器报告了错误：

# command-line-arguments
./test.go:14: cannot use sliceInt[1:] (type []int) as type []interface {} in argument to Minimum

这种错误发生在了第三种调用方式上，而这里就显得有些奇怪了，在MinimumInt函数中使用省略号自动展开一个切片都是正常的啊！

于是我将调用方式改成了如下：

Minimum(sliceInt[0], sliceInt[1:])

编译就通过了，但是这样调用后并不能得到数据中的最小值，原因稍后解释！

然后，本着好奇，我尝试着将MinimumInt函数的调用方式改成了如下：

MinimumInt(sliceInt[0], sliceInt[1:]) //不再使用省略号展开

再次编译，我得到了如下的错误提示：

# command-line-arguments
./test.go:15: cannot use sliceInt[1:] (type []int) as type int in argument to MinimumInt

由上提示，很容易得出一个结论：MinimumInt函数的第二个参数others在编译器看来仅仅是一个int型变量，尽管在MinimumInt函数内部它是一个int型切片（[]int），所以我们传入参数时需要使用省略号来将一个切片展开成一个一个的元素，这样才能做到参数匹配（Go不支持默认的类型转换）

对于interface{}空接口，它可以代指任何类型的数据，比如：

    var i int = 10
    var sliceInt = []int{10, 15, 32, 46, 2, 3}
    var sliceIntz [][]int = [][]int{[]int{1, 2, 3}, []int{4, 5, 6}, []int{7, 8, 9}}
    var inter_a interface{} = i         //int
    var inter_b interface{} = sliceInt  //[]int
    var inter_c interface{} = sliceIntz //[][]int

可见interface{}可指代int型数据，又可指代[]int型数据和[][]int型数据。

可能有人会认为，interface{}可用于指代int型数据,那么是不是[]interface{}就是指代[]int型数据的呢？那么做一个测试：

var inter_d []interface{} = sliceInt[:]

而在编译时，编译器报告错误：

# command-line-arguments
./test.go:27: cannot use sliceInt[:] (type []int) as type []interface {} in assignment

既它们类型不兼容，不能直接赋值！不过按照常理来说，好像是可以这么做的？为什么会报错呢？
原因在于，对于var inter_d []interface{}声明，其实我们是在声明一个切片，该切片可保存任意类型的值，可是切片的定义语句却不是这样的，对于一个已经声明的切片类型，我们只能使用如下的形式来定义：

var inter_d []interface{} = []interface{}{sliceIntz[0], sliceIntz[1], sliceIntz[2]}

这样就不会报错了，那么说到了这里，对于Minimum函数的错误也应该有答案了吧？我们将它的调用方式改成如下：

Minimum(sliceInt[0], sliceInt[1], sliceInt[2], sliceInt[3])

这样调用也就没有错误了！因为我们用正确的方式构造了一个切片！

对于Minimum函数的调用方式，如果写成如下：

Minimum(sliceInt[0], sliceInt[1:])

虽然编译通过，但是却无法得到正确的最小值，因为我们在传入实参时，传入的是一个切片的引用，而非由一个个值去构建了一个切片！因为此时interface{}本身就指代了[]int类型，虽然reset的类型还是[]interface{}，但reset[0]的类型已经发生了变化！

可以来做一个验证，将Minimum函数改成如下形式：

func Minimum(first interface{}, rest ...interface{}) interface{} {
    min := first
    fmt.Printf("%T\t%T\n", rest, rest[0]) //打印类型信息
    for _, value := range rest {
        switch value := value.(type) {
        case int:
            if value < min.(int) {
                min = value
            }
        case float64:
            if value < min.(float64) {
                min = value
            }
        case string:
            if value < min.(string) {
                min = value
            }
        }
    }
    return min
}

第一种调用方式：

fmt.Println(Minimum(sliceInt[0], sliceInt[1], sliceInt[2], sliceInt[3], sliceInt[4], sliceInt[5]))
//结果为：
//[]interface {}    int
//2

第二种调用方式：

fmt.Println(Minimum(sliceInt[0], sliceInt[1:]))
//结果为：
//[]interface {}    []int
//10

我不知道这种解释是否合理，语言表述的可能不是特别明确，无奈思考再三，觉得只有这种解释稍微合理一些！