Ruby - 运算符

---

---

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

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

Ruby 算术运算符

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

Ruby 比较运算符

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

Ruby 赋值运算符

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

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 语言支持以下按位运算符。

Ruby 逻辑运算符

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

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

Ruby 三元运算符

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

Ruby 范围运算符

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

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

Ruby defined? 运算符

defined? 是一个特殊的运算符，它采用方法调用的形式来确定传递的表达式是否已定义。它返回表达式的描述字符串，如果表达式未定义则返回 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 运算符优先级

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

注意 − 方法列中为“是”的运算符实际上是方法，因此可以被重写。