從 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())")

不過，我懷疑這是矯枉過正，而且您的實際問題看起來像第一個答案，或者更簡單。