从 func 获取 Int 或 Double 而不转换

Question

在我的应用程序中，我有一个返回 int 或 double 的函数。 将 Int 转换为 Double 可能不应该有任何问题，但我想知道是否有办法在没有特定转换的情况下实现它。

我有以下代码，我想开始工作，但无法这样做。

struct FuncEquatableView: View {
   let int = 25
   let double = 30.0
   
   var body: some View {
       Text("\(returnEquatable())")
   }

   func returnEquatable<T: Equatable>(returnInt: Bool = true) -> T {
       if returnInt {
           return int as! T
       }
       else {
           return double as! T
       }
   }
}

Answer 1

对于您描述的用例，此解决方案是返回一个字符串：

func returnEquatable(returnInt: Bool = true) -> String {
    if returnInt {
        return "\(int)"
    }
    else {
        return "\(double)"
    }
}

如果您有一个值希望是 Int 或 Double，那就是“或”类型（正式名称是“sum 类型”）。 那是一个枚举。 此枚举可能适用于您的目的； 它有很多小问题，但可能就足够了。 此表单允许您检查是否相等或对一组值进行排序。 （请记住，并非每个 Int 都可以表示为 Double，因此非常大的 Int 将彼此相等。）

enum Value: Comparable, CustomStringConvertible {
    case int(Int)
    case double(Double)

    // NOTE: This is lossy for non-integers
    var intValue: Int {
        switch self {
        case .int(let x): return x
        case .double(let x): return Int(x)
        }
    }

    // NOTE: This is lossy for large integers
    var doubleValue: Double {
        switch self {
        case .int(let x): return Double(x)
        case .double(let x): return x
        }
    }

    static func == (lhs: Value, rhs: Value) -> Bool {
        // NOTE: This does not work for large integers
        lhs.doubleValue == rhs.doubleValue
    }

    static func < (lhs: Value, rhs: Value) -> Bool {
        // NOTE: This does not work for large integers
        lhs.doubleValue < rhs.doubleValue
    }

    var description: String {
        switch self {
        case .int(let x): return x.description
        case .double(let x): return x.description
        }
    }
}

然后你的returnEquatable将是：

func returnEquatable(returnInt: Bool = true) -> Value {
    if returnInt {
        return .int(int)
    }
    else {
        return .double(double)
    }
}

请注意，在这种情况下您需要逐字文本，而不是本地化键：

    Text(verbatim: "\(returnEquatable())")

不过，我怀疑这是矫枉过正，而且您的实际问题看起来像第一个答案，或者更简单。