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 的运算符实际上是方法,因此可能会被覆盖。