17

我经常遇到一种情况，我期望一个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在这种情况下将是 type interface{}。case对于每个整数类型，我真的必须将其拆分为s 吗？

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

更新：

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

4

4 回答 4

25

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

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

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

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

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

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

干杯

于 2013-06-20T20:34:07.663 回答
14

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

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
    }
}
于 2013-06-20T19:18:28.243 回答
8

使用反射包。请注意，这可能比展开开关要慢得多。

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
}
于 2013-06-20T18:34:11.023 回答
-1

你可以做这样的事情......转换为字符串，然后解析字符串。效率不高但紧凑。我把这个例子放在了 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
于 2013-06-21T13:23:19.187 回答