Go：在类型开关中将任何 int 值转换为 int64

Question

我经常遇到这样的情况，我期望 int（任何类型，int/int8/16/32/64）并使用类型开关检查它

switch t := v.(type) {
  case int, int8, int16, int32, int64:
    // cast to int64
  case uint, uint8, uint16, uint32, uint64:
    // cast to uint64
}

现在我不能使用直接转换，因为在这种情况下t 将是interface{} 类型。对于每个整数类型，我真的必须将其拆分为 cases 吗？

我知道我可以使用reflect.ValueOf(v).Int() 通过反射来做到这一点，但难道不应该有更好（不那么冗长）的方法吗？

更新：

提交了一个问题，Rob 建议在这种情况下只使用 reflect。

Answer 1

如果没有更多上下文，很难给你一个意见，但看起来你正试图让你的实现过于通用，这对于主要使用更多动态语言或具有通用支持的人来说很常见。

学习围棋过程的一部分是学习接受它的类型系统，这取决于你来自哪里，这可能具有挑战性。

通常，在 Go 中，您希望支持一种可以保存您需要处理的所有可能值的类型。在您的情况下，它可能是 int64。

例如，看看 math 包。它仅适用于 int64，并希望任何使用它的人都能正确地进行类型转换，而不是尝试转换所有内容。

另一种选择是使用与类型无关的接口，就像 sort 包一样。基本上，任何特定于类型的方法都将在您的包之外实现，并且您希望定义某些方法。

学习和接受这些属性需要一段时间，但总的来说，最终证明它在可维护性和健壮性方面是好的。接口确保您具有正交性，而强类型确保您可以控制类型转换，这最终会导致错误以及内存中不必要的副本。

干杯

Answer 2

使用reflect 包。请注意，这可能比展开开关要慢很多。

switch t := v.(type) {
case int, int8, int16, int32, int64:
    a := reflect.ValueOf(t).Int() // a has type int64
case uint, uint8, uint16, uint32, uint64:
    a := reflect.ValueOf(t).Uint() // a has type uint64
}

Answer 3

你想解决什么问题？您描述的完整解决方案如下所示：

func Num64(n interface{}) interface{} {
    switch n := n.(type) {
    case int:
        return int64(n)
    case int8:
        return int64(n)
    case int16:
        return int64(n)
    case int32:
        return int64(n)
    case int64:
        return int64(n)
    case uint:
        return uint64(n)
    case uintptr:
        return uint64(n)
    case uint8:
        return uint64(n)
    case uint16:
        return uint64(n)
    case uint32:
        return uint64(n)
    case uint64:
        return uint64(n)
    }
    return nil
}

func DoNum64Things(x interface{}) {
    switch Num64(x).(type) {
    case int64:
        // do int things
    case uint64:
        // do uint things
    default:
        // do other things
    }
}

Answer 4

你可以做这样的事情...转换成一个字符串然后解析这个字符串。效率不高但紧凑。我把这个例子放在了 Go 操场上：http://play.golang.org/p/0MCbDfUSHO

package main

import "fmt"
import "strconv"

func Num64(n interface{}) int64 {
    s := fmt.Sprintf("%d", n)
    i,err := strconv.ParseInt(s,10,64)
    if (err != nil) {
        return 0
    } else {
        return i
    }
}

func main() {
    fmt.Println(Num64(int8(100)))
    fmt.Println(Num64(int16(10000)))
    fmt.Println(Num64(int32(100000)))
    fmt.Println(Num64(int64(10000000000)))
    fmt.Println(Num64("hello"))
}

// Outputs:
// 100
// 10000
// 100000
// 10000000000
// 0