通用数字类型的比较方法

哈喽！今天心血来潮给大家带来了《通用数字类型的比较方法》，想必大家应该对Golang都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习Golang，千万别错过这篇文章~希望能帮助到你！

我有一个验证函数 positive，它可以工作，但看起来很丑。

type positiver interface {
    decimal.decimal | int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64 | float32 | float64
}

//nolint:cyclop
func positive[t positiver](value t, name string, errs *[]error) {
    adderror := func() {
        err := fmt.errorf(`%s %w, but it's %v`, name, failures.shouldbepositive, value)
        *errs = append(*errs, err)
    }

    const prescision = 8

    switch val := any(value).(type) {
    case decimal.decimal:
        if val.isnegative() || val.iszero() {
            err := fmt.errorf(`%s %w, but it's %s`, name, failures.shouldbepositive, val.stringfixedbank(prescision))
            *errs = append(*errs, err)
        }

        return
    case int:
        if val <= 0 {
            adderror()
        }
    case int64:
        if val <= 0 {
            adderror()
        }
    case int32:
        if val <= 0 {
            adderror()
        }
    case int16:
        if val <= 0 {
            adderror()
        }
    case int8:
        if val <= 0 {
            adderror()
        }
    case uint:
        if val <= 0 {
            adderror()
        }
    case uint64:
        if val <= 0 {
            adderror()
        }
    case uint32:
        if val <= 0 {
            adderror()
        }
    case uint16:
        if val <= 0 {
            adderror()
        }
    case uint8:
        if val <= 0 {
            adderror()
        }
    case float32:
        if val <= 0 {
            adderror()
        }
    case float64:
        if val <= 0 {
            adderror()
        }
    default:
        panic(fmt.sprintf(`%t is not supported type`, val))
    }
}

我知道使用 []error 是不好的方法，最好返回一个包装的错误。 但这是一个兼容性问题。

我尝试这样做：

func Positive[T Positiver](value T, name string, errs *[]error) {
    switch val := any(value).(type) {
    case decimal.Decimal:
        if val.IsNegative() || val.IsZero() {
            err := fmt.Errorf(`%s %w, but it's not`, name, failures.ShouldBePositive)
            *errs = append(*errs, err)
        }

        return
    case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
        if val.(int64) <= 0 {
            err := fmt.Errorf(`%s %w, but it's not`, name, failures.ShouldBePositive)
            *errs = append(*errs, err)
        }

        return
    case float32, float64:
        if val.(float64) < 0 {
            err := fmt.Errorf(`%s %w, but it's not`, name, failures.ShouldBePositive)
            *errs = append(*errs, err)
        }

        return
    default:
        panic(fmt.Sprintf(`%T is not supported type`, val))
    }
}

但是这种方法返回一个错误： 测试惊慌：接口转换：interface {} 是 int，而不是 int64

比较该值是否超过零的更好方法是什么？

正确答案

您的代码不适用于“接口转换：interface {} is int，not int64”，因为在多类型 case 中，类型切换变量 val 保留其原始类型。另请参阅：golang 类型开关中的多种大小写了解详细信息。

因此，在这种情况下，您确实必须断言某些内容才能使用顺序运算符。这个“东西”可能是一个类型参数。

case int, int8, int16, int32, int64:
        if val.(t) <= 0 {
            // ...
        }

but此代码仍然无法使用排序运算符，因为约束 positive 包含 decimal.decimal，它不支持排序。

尝试为 decimal.decimal 编写 case 并为其他数字类型编写 case 也不会很好地工作，因为您没有一个好的方法来减少类型约束的类型集。您回来为每种类型编写一个 case 。有一天 go 可能会允许在类型开关中使用联合约束。

今天您可以做的是以不同的方式静态处理 decimal.decimal 和其他数字类型。您可以使用包 constraints 中的类型来避免重新声明所有内容： signed, unsigned 和 float。那么只有数字类型的简单函数就像这样简单：

func strictlypositive[t signed | unsigned | float](v t) bool {
    return v > 0
}

但是 对于浮动，使用 < 是不够的。浮点变量也可以是 nan 或+/-无穷大。您必须决定如何对 nan 进行排序；无穷大有符号位，但 imo 最好使用 math.isinf 不要隐藏顺序运算符后面的内容。

所以总而言之，我认为这个函数最好使用反射，这可能会更慢，但代码并不完全糟糕。以下是示例的简化版本：

func CheckPositive[T Positive](value T) string {
    switch val := any(value).(type) {
    case decimal.Decimal:
        if val.IsNegative() || val.IsZero() {
            return "non positive decimal"
        }

    case int, int8, int16, int32, int64:
        if reflect.ValueOf(val).Int() <= 0 {
            return "non positive signed"
        }

    case uint, uint8, uint16, uint32, uint64:
        if reflect.ValueOf(val).Uint() == 0 {
            return "non positive unsigned"
        }

    case float32, float64:
        f := reflect.ValueOf(val).Float()
        switch {
        case math.IsNaN(f):
            return "NaN float"
        case math.IsInf(f, -1):
            return "negative infinite"
        case math.IsInf(f, 1):
            // do nothing
        default:
            // not a NaN and not an Infinite
            if f <= 0.0 {
                return "negative float"
            }
        }

    default:
        panic(fmt.Sprintf(`%T is not supported type`, val))
    }
    return "positive"
}

以上就是《通用数字类型的比较方法》的详细内容，更多关于的资料请关注golang学习网公众号！