如何实现多态变参数的求和？

Question

求问下面的Add2这里怎么实现？sum为interface好像没法任意求和？

func Add(vars ... int)(ret int){
    var sum int
    for _,v := range vars {
        //fmt.Println("v",v)
        sum += v
    }

    return sum
}


//这里怎么实现？sum为interface好像没法任意求和？
func Add2(vars ... interface{})(ret interface{}){
    ／* var sum interface{}
    for _,v := range vars {
        switch v.(type){
            case int:
            sum += v
            case float64:
            sum += v
            case string:
            sum += v
        }
    } *／

    return sum
}



func main() {
    fmt.Println(Add2(1,2))
    fmt.Println(Add2(1,2,3))
    fmt.Println(Add2(2.4, 3.6, 1.0))
    fmt.Println(Add2("Hello", "world", "zhong"))
}

Answer 1

你的应该存在一个潜在的前提，就是传入的参数是一致的类型。

下面的例子，取第一个值的类型，作为整个相加运算的类型，如果有和第一个类型不一致的数据会被忽略，用到了反射。

package main

import (
    "fmt"
    "reflect"
)

func main() {
    fmt.Println(sum(1.2, 2.0))
    fmt.Println(sum(1, 2))
    fmt.Println(sum("hello", " ", "world"))
}

func sum(vars ...interface{}) interface{} {
    var result interface{}
    if len(vars) == 0 {
        return result
    }
    inferType := reflect.TypeOf(vars[0])
    for i, v := range vars {
        if i == 0 {
            result = v
            continue
        }
        if reflect.TypeOf(v) == inferType {
            switch inferType.Name() {
            case "int":
                result = result.(int) + v.(int)
            case "float64":
                result = result.(float64) + v.(float64)
            case "string":
                result = result.(string) + v.(string)
            }
        }
    }
    return result
}

输出

3.2
3
hello world

Answer 2

你想要的是泛型吧？凑合写了一个，忽略与第一个参数不同类型的值。

func add(vars ... interface{})(ret interface{}) {
    var sum interface{}
    for _, v := range vars {
        sum = addTo(sum, v)
    }
    return sum
}

func addTo(sum interface{}, v interface{})(ret interface{} ){
    if (sum == nil) {
        return v
    }
    switch v.(type) {
        case int:
        if intSum, found := sum.(int); found {
            return intSum + v.(int)
        }
        case string:
        if strSum, found := sum.(string); found {
            return strSum + v.(string)
        }
    }
    return sum
}