139.优先级和关联性
运算符优先级给一些运算符提供更高的优先级; 这些运算符首先起作用。
运算符关联性确定相同优先级的运算符分组的行为—或者从左边分组, 或者从右边分组。可以这样考虑 “它们关联左边的表达式,” 或者 “它们关联右边的表达式。”
在使用复合表达式计算时,考虑每个运算符的优先级和关联性非常重要。例如, 运算符优先级解释了为什么下面的表达式结果是 17.
2 + 3 % 4 * 5
// 等于 17
如果从左到右严格读, 你可能期望表达式按照如下执行:
2 加 3 等于 5
5 除以 4 取余为 1
1 乘以 5 等于 5
不过, 实际结果是 17, 而不是 5. 高优先级的运算符比低优先级运算符先执行。在 Swift 中, 和 C 一样, 取余运算符 (%) 和乘法运算符 (*) 比加法运算符有更高的优先级 (+). 结果就是, 它们都比加法先执行。
不过, 取余和乘法运算符优先级是相同的。为了解决准确的执行顺序, 你也需要考虑它们的关联性。取余和乘法运算符都是关联它们左边的表达式。把它想象为从左边开始,在它们的表达式部分加了一个隐式的括号:
2 + ((3 % 4) * 5)
(3 % 4) 是 3, 这个等于:
2 + (3 * 5)
(3 * 5) 是 15, 这个等于:
2 + 15
计算结果是 17.
要查看完整的 Swift 运算符优先级和关联性规则的列表, 参见表达式部分。更多表达式, 参见 Swift 标准库运算符参考。
备注 Swift 的运算符优先级和关联性,比 C 和 Objective-C 中的更加简单和可预测。不过, 这个意味着它们和基于C语言的语言有所不同。在移植代码到 Swift 时,谨慎的确保运算符行为要和你想的一样。
140.运算符方法
类和结构体可以为已存在的运算符提供自己的实现。这就是运算符的重载。
下面的例子展示如何给一个自定义的结构体,实现一个算术加法运算符(+). 算术加法运算符是一个二目运算符,因为它操作两个目标。因为它在两个目标之间,它又是一个中缀运算符。
下面的例子为一个二维位置向量(x, y)定义了一个 Vector2D 结构体, 后面是一个运算符方法的定义,这个方法把两个 Vector2D 结构体实例进行相加:
struct Vector2D {
var x = 0.0, y = 0.0
}
extension Vector2D {
static func + (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y + right.y)
}
}
这个运算符方法定义为Vector2D 的类型方法, 方法名符合重载的(+)运算符。因为加法不是向量本来的行为, 所以这个类型方法定义在结构体的扩展中,而不是主结构中。因为算术加法运算符是二目运算符, 这个运算符方法接受两个Vector2D 类型的参数,然后返回Vector2D 类型的值。
在这个实现里, 输入参数名 left 和 right 表示 Vector2D 实例在 + 运算符的左右两侧。这个方法返回了一个新的 Vector2D 实例, 它的 x 和 y 属性是左右实例 x 和 y 之和。
这个类型方法可以在两个 Vector2D 实例中用作中缀运算符:
let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
// combinedVector 是一个 Vector2D 实例,值是 (5.0, 5.0)
这个例子把向量 (3.0, 1.0) 和 (2.0, 4.0) 相加得到向量 (5.0, 5.0), 如下图所示。
前缀和后缀运算符
上面的例子展示了一个中缀运算符的自定义实现。类和结构体也可以提供标准一元运算符的实现。一元运算符只操作一个目标。如果它在目标前面就是前缀运算符 (例如 -a) ,如果在目标后面就是后缀运算符 (例如 b!).
定义运算符方法的时候,在 func 关键字前写上前后缀修饰符,就可以定义前后缀一元运算符:
extension Vector2D {
static prefix func - (vector: Vector2D) -> Vector2D {
return Vector2D(x: -vector.x, y: -vector.y)
}
}
上面的例子给Vector2D 实例实现了一元-运算符。一元-运算符是一个前缀运算符, 所以这个方法使用了前缀修饰符。
对于简单的数值, 一元-运算符把正数变成负数,反之亦然。Vector2D 实例的实现就是对 x 和 y 同时进行操作:
let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
// negative is a Vector2D instance with values of (-3.0, -4.0)
let alsoPositive = -negative
// alsoPositive is a Vector2D instance with values of (3.0, 4.0)
复合赋值运算符
复合赋值运算符把=与其他运算合并。例如, 加法赋值运算符合并了加法和赋值到一个单独的操作中。把复合赋值运算符的左边输入参数标记为 inout, 因为这个参数值会在方法内修改。
下面的例子为Vector2D 实例实现了一个加法赋值运算符:
extension Vector2D {
static func += (left: inout Vector2D, right: Vector2D) {
left = left + right
}
}
因为加法运算符早已定义, 这里你不需要替换加法部分。替代的是, 加法赋值运算符方法采用了已经存在的加法运算符方法, 然后把左右值相加赋值给左值:
var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd
// original 现在的值是 (4.0, 6.0)
备注：不可能重载默认的赋值运算符(=). 只有复合赋值运算符可以重载。相似的, 三元条件运算符 (a ? b : c) 也不能重载。
等式运算符
自定义的类和结构体没有默认的等式运算符的实现, 也就是(==) 和 (!=). Swift 猜不出来你的自定义类型是否有资格 “等于”, 因为这取决于这些类型在你代码里扮演的角色。
使用等式运算符来判断自定类型的相等, 像其他中缀运算符方法一样提供它的实现即可:
extension Vector2D {
static func == (left: Vector2D, right: Vector2D) -> Bool {
return (left.x == right.x) && (left.y == right.y)
}
static func != (left: Vector2D, right: Vector2D) -> Bool {
return !(left == right)
}
}
上面的例子实现了“等于” 运算符 (==)来判断两个Vector2D 实例是否有相同值。在 Vector2D 的上下文中, 认为相等就是 “两个实例的x和y值都一样”, 这个就是运算符实现的逻辑。这个例子同时实现了 “不等于” 运算符 (!=), 它只是简单返回了 “等于”的想法结果。
现在你可以使用这些运算符来判断两个 Vector2D 实例是否相等:
let twoThree = Vector2D(x: 2.0, y: 3.0)
let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
if twoThree == anotherTwoThree {
print("These two vectors are equivalent.")
}
// 打印 "These two vectors are equivalent."
自定义运算符
除了 Swift 提供的标准运算符,你也可以声明和实现自定义的运算符。
使用 operator 关键字, 用 prefix, infix 或者 postfix标记,新的运算符会定义在全局:
prefix operator +++
上面的例子定义了一个新的前缀运算符 +++. 这个运算符在Swift中不存在任何意义, 所以在下面使用Vector2D 实例的上下文中,给出了自定义的含义。这个例子的目的是, +++ 是一个新的“前缀双倍” 运算符。它双倍 Vector2D 实例的x和y值, 它使用早前定义的加法赋值运算符,把自己加给自己。为了实现 +++ 运算符, 给Vector2D 添加如下的类型方法 +++:
extension Vector2D {
static prefix func +++ (vector: inout Vector2D) -> Vector2D {
vector += vector
return vector
}
}
var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
// toBeDoubled 现在的值是 (2.0, 8.0)
// afterDoubling 值也是 (2.0, 8.0)
自定义中缀运算符的优先级
自定义中缀运算符每个都属于一个优先级集。一个优先级集指定一个运算符相对于其他中缀运算符的优先级, 也就是运算符的关联性。
没有显式加入优先级集的自定义中缀运算符,会被给予一个默认的优先级集。它的优先级比三目条件运算符要高。
下面的例子定义了一个新的自定义的中缀运算符 +-, 它属于优先级集 AdditionPrecedence:
infix operator +-: AdditionPrecedence
extension Vector2D {
static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y - right.y)
}
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector 是一个值为 (4.0, -2.0)的 Vector2D 实例
这个运算符把两个向量的x值相加, 然后把第二个向量的两个y值相减。因为它实际上是一个 “加法的” 运算符, 它跟其他加法中缀运算符,例如 + 和 - , 有相同的优先级集。
备注 定义一个前缀或者后缀运算符的时候,你不要指定优先级。不过, 如果你在相同的操作数上使用前缀和后缀运算符, 后缀运算符会首先发生作用。
