Приведение типов в GO, можно сделать красивее?

Question

[Алексей Сумин]

Нужна функция которая:
- на входе принимает, что угодно
- на выходе, если это возможно должно возвращаться число типа int64
Получился такой код:

func interToInt64(inp interface{}) (int64, error) {
	switch inp.(type) {
	case int:
		return int64(inp.(int)), nil
	case int8:
		return int64(inp.(int8)), nil
	case int16:
		return int64(inp.(int16)), nil
	case int32:
		return int64(inp.(int32)), nil
	case int64:
		return inp.(int64), nil
	case uint:
		return int64(inp.(uint)), nil
	case uint8:
		return int64(inp.(uint8)), nil
	case uint16:
		return int64(inp.(uint16)), nil
	case uint32:
		return int64(inp.(uint32)), nil
	case uint64:
		return int64(inp.(uint64)), nil
	case string:
		return strconv.ParseInt(inp.(string), 10, 64)
	default:
		return 0, fmt.Errorf("unsupported type %T", inp)
	}
}

Можно ли решить эту задачу по-аккуратнее? Напрягает, что приходится явно перечислять все возможные подтипы интов.

Answer 1

[Александр Павлюк]

Можно сделать так, будет меньше кода. В остальном, ничего не уменьшить, ибо го довольно низкоуровневый язык.

func interToInt64(inp interface{}) (int64, error) {
	switch v := inp.(type) {
	case int:
		return int64(v), nil
	case int8:
		return int64(v), nil
	case int16:
		return int64(v), nil
	case int32:
		return int64(v), nil
	case int64:
		return v, nil
	case uint:
		return int64(v), nil
	case uint8:
		return int64(v), nil
	case uint16:
		return int64(v), nil
	case uint32:
		return int64(v), nil
	case uint64:
		return int64(v), nil
	case string:
		return strconv.ParseInt(v, 10, 64)
	default:
		return 0, fmt.Errorf("unsupported type %T", inp)
	}
}

Comments

[Андрей]

я не очень в go, но у вас же куча одинаковых case, почему нельзя сделать так:

case int:
case int8:
case int16:
    return int64(v), nil

[Александр Павлюк]

Андрей, можно сделать так:
case int, int8, int16:
но внутри кейса придется все равно приводить типы, ибо в этом случае v будет interface{} )))

[devalone]

Багна таких входных данных:

interToInt64(uint64(18446744073709551615))

выдаёт -1

[Александр Павлюк]

devalone, логично, там overflow

[devalone]

Александр Павлюк, а не должно быть

[Александр Павлюк]

devalone, почему не должно, если int64 имеет верхний предел в два раза ниже, чем uint64?

[devalone]

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

[Александр Павлюк]

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

[devalone]

Александр Павлюк, в каких случаях нужно не очевидное поведение? Твоя функция уже проверяет часть ошибок, но не все.

[Алексей Сумин]

devalone, ну так преобразование делаем сам Go, я даже не уверен, что смогу спалить эту ситуацию, чтобы возвращать error, например.

[Алексей Сумин]

Андрей, так нельзя в Go :(

[devalone]

Алексей Сумин, почему нет?

if v > max int64 {
return error

[Александр Павлюк]

Алексей Сумин, сможешь, просто проверить, что значение не больше определенного

[Александр Павлюк]

devalone, не моя, а автора вопроса. Мы тут обсуждаем не обработку ошибок, как удобнее типы привести.

[devalone]

Александр Павлюк, задача перевода типов не должна без ошибки возвращать некорректное значение

[Алексей Сумин]

devalone, получается как то так:

case uint64:
		if v > math.MaxInt64 {
			return 0, fmt.Errorf("value overflows int64")
		}
		return int64(v), nil

тогда все ок, спасибо!

Answer 2

[Philipp]

Идея такой функции не самая здравая. Конверсия некоторых чисел будет вызывать непредсказуемое поведение.
Что-то в духе uint64(2^32+1) может здорово пошатать ваш int64.
Я советую вам не играть с огнем и рассмотреть альтернативные варианты работы с данными.

Answer 3

[devalone]

Ещё вариант:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	fmt.Println(interToInt64(1))
	fmt.Println(interToInt64(int64(10)))
	fmt.Println(interToInt64(int8(10)))
	fmt.Println(interToInt64(15.5))
	fmt.Println(interToInt64("15.5"))
	fmt.Println(interToInt64("15"))
	fmt.Println(interToInt64(uint(10)))
	fmt.Println(interToInt64(uint64(999)))
	fmt.Println(interToInt64(uint64(18446744073709551615)))
}

func interToInt64(inp interface{}) (int64, error) {
	strVal := fmt.Sprint(inp)
	if res, err := strconv.ParseInt(strVal, 10, 64); err == nil {
		return res, nil
	}
	return 0, fmt.Errorf("unsupported type %T with value %v", inp, inp)
}

https://play.golang.org/p/Q0_5UIoU3KP

Comments

[Алексей Сумин]

Строковые функции на большой нагрузке вроде сильно проигрывают в производительности

[devalone]

Алексей Сумин, ну, если нужна производительность, то подойдёт вариант выше, только нужно исправить баг с uint, это я привёл для альтернативы.