Перейти: лить любое значение int для int64 в переключателе типа

У меня часто возникает ситуация, когда я ожидаю 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{}. Действительно ли я должен разбить это на case для каждого целочисленного типа?

Я знаю, что я мог бы сделать это через отражение с помощью reflect.ValueOf(v).Int(), но не должен ли быть лучший (менее многословный) способ сделать это?

UPDATE:

Подал сбой, и Роб посоветовал просто использовать reflect в этом случае.

Ответ 1

Трудно дать вам мнение без контекста, но похоже, что вы пытаетесь сделать свою реализацию слишком универсальной, что характерно для людей, которые работали в основном с более динамическими языками или с общей поддержкой.

Часть процесса обучения Go учится охватывать систему своего типа, и в зависимости от того, откуда вы пришли, это может быть сложной задачей.

Обычно в Go вы хотите поддерживать один тип, который может содержать все возможные значения, которые необходимо обрабатывать. В вашем случае это, вероятно, будет int64.

Посмотрите, например, на математический пакет. Он работает только с int64 и ожидает, что кто-либо использует его, чтобы правильно его вывести, вместо того, чтобы пытаться преобразовать все.

Другой вариант - использовать интерфейс как агностик типа, как это делает пакет сортировки. В принципе, любой метод, специфичный по типу, будет реализован вне вашего пакета, и вы ожидаете, что определенные методы будут определены.

Требуется некоторое время, чтобы изучить и принять эти атрибуты, но в целом, в конце концов, это оказывается хорошим с точки зрения ремонтопригодности и надежности. Интерфейсы гарантируют, что у вас есть ортогональность и сильные типы, убедитесь, что вы контролируете преобразования типов, что в конечном итоге может вызвать ошибки и лишние копии в памяти.

Приветствия

Ответ 2

Какую проблему вы пытаетесь решить? Полное решение, которое вы описали, выглядит так:

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
    }
}

Ответ 3

Используйте 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
}

Ответ 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