---

Ruby - 运算符

正如您对现代语言所期望的那样，Ruby 支持一组丰富的运算符。 大多数运算符实际上是方法调用。 例如，a + b 被解释为 a.+(b)，其中由变量 a 引用的对象中的 + 方法以 b 作为其参数调用。

对于每个运算符 (+ - * / % ** & | ^ << >> && ||)，都有相应形式的缩写赋值运算符（+= -= 等）。

---

Ruby 算术运算符

假设变量 a 为 10，变量 b 为 20，则 −

运算符	描述	示例
+	加法 − 在运算符的任一侧添加值。	a + b 将给出 30
−	减法 − 从左手操作数中减去右手操作数。	a - b 将给出 -10
*	乘法 − 将运算符两侧的值相乘。	a * b 将给出 200
/	除法 − 将左手操作数除以右手操作数。	b / a 将给出 2
%	模数 − 将左手操作数除以右手操作数并返回余数。	b % a 将给出 0
**	指数 − 对运算符执行指数（幂）计算。	a**b 将给出 10 的 20 次方

---

Ruby 比较运算符

假设变量 a 为 10，变量 b 为 20，则 −

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件为真。	(a == b) is not true.
!=	检查两个操作数的值是否相等，如果值不相等则条件为真。	(a != b) is true.
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(a > b) is not true.
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(a < b) is true.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(a >= b) is not true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(a <= b) is true.
<=>	组合比较运算符。 如果第一个操作数等于第二个，则返回 0，如果第一个操作数大于第二个，则返回 1，如果第一个操作数小于第二个，则返回 -1。	(a <=> b) returns -1.
===	用于在 case 语句的 when 子句中测试相等性。	(1...10) === 5 returns true.
.eql?	如果接收者和参数具有相同的类型和相等的值，则为真。	1 == 1.0 返回真，但 1.eql?(1.0) 为假。
equal?	如果接收者和参数具有相同的对象 id，则为真。	如果 aObj 与 bObj 重复，则 aObj == bObj 为真，a.equal?bObj 为假，但 a.equal?aObj 为真。

---

Ruby 赋值运算符

假设变量 a 为 10，变量 b 为 20，则 −

运算符	描述	示例
=	简单赋值运算符，将右侧操作数的值分配给左侧操作数。	c = a + b 将 a + b 的值赋给 c
+=	添加 AND 赋值运算符，将右操作数添加到左操作数并将结果分配给左操作数。	c += a 等价于 c = c + a
-=	减与赋值运算符，从左操作数中减去右操作数并将结果赋给左操作数。	c -= a 等价于 c = c - a
*=	乘与赋值运算符，将右操作数与左操作数相乘并将结果分配给左操作数。	c *= a is equivalent to c = c * a
/=	除与赋值运算符，将左操作数与右操作数相除，并将结果赋给左操作数。	c /= a 等价于 c = c / a
%=	模数与赋值运算符，使用两个操作数取模并将结果分配给左操作数。	c %= a 等价于 c = c % a
**=	指数与赋值运算符，对运算符进行指数（幂）计算，并为左操作数赋值。	c **= a 等价于 c = c ** a

---

Ruby 并行赋值

Ruby 还支持变量的并行赋值。 这使得多个变量可以用一行 Ruby 代码初始化。 例如 −

a = 10
b = 20
c = 30

这可以使用并行赋值更快地声明 −

a, b, c = 10, 20, 30

并行赋值对于交换两个变量中的值也很有用 −

a, b = b, c

---

Ruby 位运算符

按位运算符对位起作用，并执行逐位运算。

假设 a = 60; 和 b = 13; 现在以二进制格式，它们将如下所示 −

 a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

Ruby 语言支持以下位运算符。

运算符	描述	示例
&	如果两个操作数中都存在二进制 AND 运算符，则将位复制到结果中。	(a & b) 将给出 12, 这是 0000 1100
|	二元或运算符如果存在于任一操作数中，则复制一个位。	(a | b) 将给出 61, 这是 0011 1101
^	如果在一个操作数而不是两个操作数中设置该位，则二进制 XOR 运算符复制该位。	(a ^ b) 将给出 49, 这是 0011 0001
~	二进制补码运算符是一元的，具有"翻转"位的效果。	(~a ) 将给出 -61, 由于带符号的二进制数，它是 2 的补码形式的 1100 0011。
<<	二进制左移运算符。 左操作数的值向左移动右操作数指定的位数。	a << 2 将给出 240, 这是 1111 0000
>>	二进制右移运算符。 左操作数的值向右移动右操作数指定的位数。	a >> 2 将给出 15, 这是 0000 1111

---

Ruby 逻辑运算符

Ruby 语言支持以下逻辑运算符

假设变量a为10，变量b为20，则 −

运算符	描述	示例
and	称为逻辑与运算符。 如果两个操作数都为真，则条件为真。	(a and b) is true.
or	称为逻辑或运算符。 如果两个操作数中的任何一个不为零，则条件为真。	(a or b) is true.
&&	称为逻辑与运算符。 如果两个操作数都不为零，则条件为真。	(a && b) is true.
||	称为逻辑或运算符。 如果两个操作数中的任何一个不为零，则条件为真。	(a || b) is true.
!	称为逻辑非运算符。 用于反转其操作数的逻辑状态。 如果条件为真，则逻辑非运算符将变为假。	!(a && b) is false.
not	称为逻辑非运算符。 用于反转其操作数的逻辑状态。 如果条件为真，则逻辑非运算符将变为假。	not(a && b) is false.

---

Ruby 三元运算符

还有一种称为三元运算符的运算符。 它首先评估一个表达式的真或假值，然后根据评估结果执行两个给定语句之一。 条件运算符具有这种语法 −

运算符	描述	示例
? :	条件表达式	如果条件为真? 然后值 X :否则值 Y

---

Ruby 范围运算符

Ruby 中的序列范围用于创建一系列连续值 - 由起始值、结束值和介于两者之间的值范围组成。

在 Ruby 中，这些序列是使用".."和"..."范围运算符创建的。 两点形式创建一个包含范围，而三点形式创建一个排除指定高值的范围。

运算符	描述	示例
..	创建从起点到终点的范围。	1..10 创建一个从 1 到 10 的范围。
...	创建一个从起点到终点的范围，不包括。	1...10 创建一个从 1 到 9 的范围。

---

Ruby 定义? 运算符

定义? 是一个特殊的运算符，它采用方法调用的形式来确定是否定义了传递的表达式。 它返回表达式的描述字符串，如果未定义表达式，则返回 nil。

defined 有多种用法吗? 运算符

用法 1

defined? variable # True if variable is initialized

举例

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

用法 2

defined? method_call # True if a method is defined

举例

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

用法 3

# True if a method exists that can be called with super user
defined? super

举例

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

用法 4

defined? yield   # True if a code block has been passed

举例

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

---

Ruby 点"." 和双冒号"::"运算符

通过在模块名称前加上模块名称和句点来调用模块方法，并使用模块名称和两个冒号引用常量。

:: 是一个一元运算符，它允许:在类或模块中定义的常量、实例方法和类方法，可以从类或模块之外的任何地方访问。

记住在 Ruby 中，类和方法也可以被视为常量。

您只需在 :: Const_name 前面加上一个返回适当类或模块对象的表达式。

如果不使用前缀表达式，则默认使用主Object类。

这里有两个例子 −

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

第二个例子

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

---

Ruby 运算符优先级

下表列出了从最高优先级到最低优先级的所有运算符。

方法	运算符	说明
Yes	::	常数分辨率运算符
Yes	[ ] [ ]=	元素参考，元素集
Yes	**	求幂（乘幂）
Yes	! ~ + -	非、补、一元加减（最后两个的方法名是 +@ 和 -@）
Yes	* / %	乘法、除法和取模
Yes	+ -	加法和减法
Yes	>> <<	左右位移
Yes	&	按位"与"
Yes	^ |	按位异或'OR'和正则'OR'
Yes	<= < > >=	比较运算符
Yes	<=> == === != =~ !~	相等和模式匹配运算符（!= 和 !~ 可能不被定义为方法）
	&&	逻辑'AND'
	||	逻辑 'OR'
	.. ...	范围（包括和不包括）
	? :	三元 if-then-else
	= %= { /= -= += |= &= >>= <<= *= &&= ||= **=	赋值
	defined?	检查指定符号是否定义
	not	逻辑否定
	or and	逻辑组合

注意 − 在方法列中带有 Yes 的运算符实际上是方法，因此可能会被覆盖。

---