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定义？运营商

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

定义有多种用法？操作员

用法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 运算符优先级

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

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