Ios 如何在Swift中定制三元运算符

我知道如何自定义二进制运算符，就像这样

infix operator ** { associativity left precedence 170 }
func ** (left: Double, right: Double) -> Double {
    return pow(left, right)
}

但是，如何在Swift中自定义三元运算符？谁能给我一些建议吗？非常感谢

一个“真”三元运算符，如

\uuux\ux：_需要语言支持。Swift只允许创建和自定义一元运算符和二元运算符

您可以使用@NateCook的答案中的技术来生成一对二元运算符，它们一起工作就像三元运算符一样，但它们仍然是独立的二元运算符--您可以单独使用它们。（相比之下，
\uu:\u
只是一个三元运算符；
\u？\ u
和
\u:
不能单独使用。）

当然，为什么要到此为止？您可以链接更多的二元运算符来创建四元运算符，等等。为了获得额外的积分，请尝试让自己成为一名扩展的宇宙飞船操作员：

let c: String = a <=> b
    |<| "a < b"
    |=| "a = b"
    |>| "a > b"

func +-<I: SignedIntegerType, T>(lhs: I, rhs: (left: Bool) -> T) -> T {
    return rhs(left: lhs >= 0)
}

设c:String=ab
||“a>b”

（…但请仅作为学术练习，否则任何使用您编写的代码的人都会讨厌您。）
您实际上可以通过声明两个单独的运算符并对其中一个运算符使用curried函数来实现这一点

让我们声明一个三元运算符
x+-y+|-z
，它将检查初始值
x
的符号，然后如果符号为零或正，则返回第二个值
y
，如果符号为负，则返回最终值
z
。也就是说，我们应该能够写：

let sign = -5 +- "non-negative" +|- "negative"
// sign is now "negative"

我们将首先声明这两个操作符。重要的是在第二个运算符上具有更高的优先级-我们将首先计算该部分并返回一个函数：

infix operator +- { precedence 60 }
infix operator +|- { precedence 70 }

然后定义函数-我们将首先定义第二个：

func +|-<T>(lhs: @autoclosure () -> T, rhs: @autoclosure () -> T)(left: Bool) -> T {
    return left ? lhs() : rhs()
}

现在我们可以使用“三元”运算符，如下所示：

for i in -1...1 {
    let sign = i +- "" +|- "-"
    println("\(i): '\(sign)'")
}
// -1: '-'
// 0: ''
// 1: ''


注意：我用另一个例子写了一篇文章。
以下是如何在Swift 4中实现这一点：
precencegroup secondaryernaryprecence{
结合性：对
高于：三元优先
lowerThan:LogicalDisjunctionPreference
}
中缀运算符~：二次三次优先
func~（lhs:@autoclosure（）->Bool，rhs:@escaping@autoclosure（）->T）->（Bool，（）->T）{
返回（lhs（），rhs）
}
中缀运算符><：三元优先
@discardableResult func><（lhs:（Bool，（）->T），rhs:@escaping@autoclosure（）->T）->T{
如果lhs.0{
返回lhs.1（）
}否则{
返回rhs（）
}
}

用法
let n=false~“它是真的”><“它是假的”/“它是假的”
真的~print（“它是真的”）>

注意：虽然这本身不是一个真正的三元运算符，因为它使用两个中缀运算符，但事实上，当这两个运算符以上述方式一起使用时，它在某种程度上模拟了它的行为。
func+|-
可能也应该使用自动关闭，这样就可以像通常的
？：
一样，惰性地计算参数。此外，虽然这创建了类似于三元运算符的东西，但实际上不能使用
？
和
：
，因为它们在swift中都不是有效的
运算符
标记。我刚刚回来做那个编辑！是的，
？：
本身不能被覆盖。这里类似的例子：@MartinR没有看到！刚刚发布了关于这一点的小更正：
SignedInteger
应该是使用Xcode 6.1的
SignedIntegerType
precedencegroup SecondaryTernaryPrecedence {
    associativity: right
    higherThan: TernaryPrecedence
    lowerThan: LogicalDisjunctionPrecedence
}

infix operator ~ : SecondaryTernaryPrecedence

func ~ <T>(lhs: @autoclosure () -> Bool, rhs: @escaping @autoclosure () -> T) -> (Bool, () -> T) {
    return (lhs(), rhs)
}

infix operator >< : TernaryPrecedence

@discardableResult func >< <T>(lhs: (Bool, () -> T), rhs: @escaping @autoclosure () -> T) -> T {
    if lhs.0 {
        return lhs.1()
    } else {
        return rhs()
    }
}