swift - 具有数值类型通用类型约束的最佳自定义运算符

Question

我正在(为一篇文章)实现两个自定义中缀运算符:

• ¿% - 计算总数的百分比。
• %? - 计算代表总计部分的百分比。

在调试了一些错误并查找了信息之后，我终于找到了一种让我的代码正常工作的方法:

protocol NumericType {
    static func *(lhs: Self, rhs: Self) -> Self
    static func *(lhs: Self, rhs: Int) -> Self
    static func /(lhs: Self, rhs: Self) -> Self
    static func /(lhs: Self, rhs: Int) -> Self
} // NumericType

extension Double : NumericType {
    internal static func *(lhs: Double, rhs: Int) -> Double {
        return lhs * Double(rhs)
    }

    internal static func /(lhs: Double, rhs: Int) -> Double {
        return lhs / Double(rhs)
    }
 }

extension Float  : NumericType {
    internal static func *(lhs: Float, rhs: Int) -> Float {
        return lhs * Float(rhs)
    }

    internal static func /(lhs: Float, rhs: Int) -> Float {
        return lhs / Float(rhs)
    }
 }

extension Int : NumericType { }

infix operator ¿%

func ¿% <T: NumericType>(percentage: T, ofThisTotalValue: T) -> T {

    return (percentage * ofThisTotalValue) / 100

} // infix operator ¿%

infix operator %?

func %? <T: NumericType>(segmentOf: T, thisTotalValue: T) -> T {

    return (segmentOf * 100) / thisTotalValue

} // infix operator %?

let percentage: Double = 8
let price: Double = 45

let save = percentage ¿% price

print("\(percentage) % of \(price) $ = \(save) $")

print("\(save) $ of \(price) $ = \(save %? price) %")

...输出:

8.0 % of 45.0 $ = 3.6 $
3.6 $ of 45.0 $ = 8.0 %

我的问题如下:

您认为可以有更优化和可读性更好的方法吗？

是吗？您能提供一些建议或分享示例吗？

Answer 1

首先，我对为此使用自定义运算符持怀疑态度。个人我宁愿只有一个函数来做这个计算:

func percent(of partial: Double, from amount: Double) -> Double {
    return partial / amount * 100
}

percent(of: 50, from: 100)
// -> 50

我觉得从长期(和短期)的可读性和可维护性来看，这会容易得多。

话虽如此...如果您真的想创建这些自定义运算符，我会采用以下方法。

你走对了!你会得到错误:

binary operator '*' cannot be applied to operands of type 'NumericType' and 'Double'

并且您沿着实现函数的路径前进，以便 * 和/运算符可以用于类型 NumericType 和 Double。

但实际上，与其重新定义 * 和/的签名以处理新类型，不如找到一种方法从泛型类型中获取 double 值并在计算中使用它会容易得多。

它可能是这样的:

protocol NumericType {
    var doubleValue: Double { get }
}

infix operator ¿%
infix operator %?

func ¿% <T: NumericType>(percentage: T, ofTotal: Double) -> Double {
    return percentage.doubleValue * ofTotal / 100.0
}

func %? <T: NumericType>(segment: T, ofTotal: Double) -> Double {
    return segment.doubleValue * 100 / ofTotal
}

extension Double: NumericType {
    var doubleValue: Double { return self }
}

extension Int: NumericType {
    var doubleValue: Double { return Double(self) }
}

希望这有帮助，请重新考虑使用标准函数而不是这些自定义运算符!