Ruby 简明教程

Ruby - Operators

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

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

Ruby Arithmetic Operators

假设变量 a 等于 10，变量 b 等于 20，则 −

Operator

Description

Example

+

加法 - 加上操作符两侧的值。

a + b 将得到 30

−

减法 - 从左运算数中减去右运算数。

a - b 将得到 -10

*

乘法 - 乘以操作符两侧的值。

a * b 将得到 200

/

除法 - 左运算数除以右运算数。

b / a 将得到 2

%

模数 - 将左运算数组以右运算数组除，并返回余数。

b % a 将得到 0

**

指数 - 对运算符执行指数（幂）计算。

a**b 将给出 20 次方的 10

Ruby Comparison Operators

假设变量 a 等于 10，变量 b 等于 20，则 −

Operator

Description

Example

==

检查两个操作数的值是否相等，如果相等，则条件变为真。

(a == b)为 false。

!=

检查两个操作数的值是否相等，如果不相等，则条件变为真。

(a != b) 为 true。

>

检查左操作数的值是否大于右操作数的值，如果大于，则条件变为真。

(a > b) 为 false。

<

检查左操作数的值是否小于右操作数的值，如果小于，则条件变为真。

(a < b) 为 true。

>=

检查左操作数的值是否大于或等于右操作数的值，如果大于或等于，则条件变为真。

(a >= b) 为 false。

⇐

检查左操作数的值是否小于或等于右操作数的值，如果小于或等于，则条件变为真。

(a ⇐ b) 为 true。

<⇒

组合比较运算符。如果第一个运算数等于第二个运算数，则返回 0，如果第一个运算数大于第二个运算数，则返回 1，如果第一个运算数小于第二个运算数，则返回 -1。

(a <⇒ b) 返回 -1。

===

用于在 case 语句的 when 子句中测试相等性。

(1…​10) === 5 返回 true。

.eql?

如果接收方和参数都具有相同的类型和相等的值，则为真。

1 == 1.0 返回 true，但 1.eql?(1.0) 为 false。

equal?

如果接收方和参数具有相同的对象 ID，则为真。

如果 aObj 是 bObj 的副本，则 aObj == bObj 为 true，a.equal?bObj 为 false，但 a.equal?aObj 为 true。

Ruby Assignment Operators

假设变量 a 等于 10，变量 b 等于 20，则 −

Operator

Description

Example

=

简单赋值运算符，将右侧运算数的值分配给左侧运算数。

c = a + b 将 a + b 的值分配给 c

+=

添加 AND 赋值运算符，将右运算符添加到左运算符并将其结果赋值给左运算符。

c += a 等同于 c = c + a

-=

减 AND 赋值运算符，从左运算符中减去右运算符并将其结果赋值给左运算符。

c -= a 等同于 c = c - a

*=

乘 AND 赋值运算符，用右运算符乘以左运算符并将其结果赋值给左运算符。

c *= a 等同于 c = c * a

/=

除 AND 赋值运算符，用右运算符除以左运算符并将其结果赋值给左运算符。

c /= a 等同于 c = c / a

%=

模 AND 赋值运算符，使用两个运算符取模并将其结果赋值给左运算符。

c %= a 等同于 c = c % a

**=

指数 AND 赋值运算符，对运算符执行指数（幂）计算并将值赋值给左运算符。

c *= a 等同于 c = c * a

Ruby Parallel Assignment

Ruby 也支持变量的并行赋值。这允许使用单行 Ruby 代码初始化多个变量。例如 −

a = 10
b = 20
c = 30

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

a, b, c = 10, 20, 30

并行赋值还可用于交换两个变量中的值 −

a, b = b, c

Ruby Bitwise Operators

按位运算符处理位并执行逐位运算。

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

Operator

Description

Example

&

二进制与运算符将位复制到结果中（如果它存在于两个操作数中）。

(a & b) 将得到 12，即 0000 1100

二进制 OR 运算符会在任一操作数中存在的情况下复制比特。

(a

b) 将给出 61，即 0011 1101

^

二进制 XOR 运算符会在其中一个操作数中但不在两个操作数中都设置的情况下复制比特。

(a ^ b) 将给出 49，即 0011 0001

~

二进制逻辑补运算符是单操作数运算符，它会“翻转”比特。

(~a) 将给出 -61，即 1100 0011，这是由于带有符号的二进制数字的 2 的补码形式。

<<

二进制左移运算符。左操作数的值会向左移动由右操作数指定的比特数。

a << 2 将给出 240，即 1111 0000

>>

Ruby Logical Operators

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

假设变量 a 等于 10，变量 b 等于 20，则 −

Operator

Description

Example

and

称为逻辑与运算符。如果两个操作数都为真，则条件变为真。

(a and b) 为真。

or

称为逻辑或运算符。如果两个操作数中的任何一个非零，则条件变为真。

(a or b) 为真。

&&

称为逻辑与运算符。如果两个操作数都非零，则条件变为真。

(a && b) 为真。

称为逻辑或运算符。如果两个操作数中的任何一个非零，则条件变为真。

(a

b) is true.

!

称为逻辑 NOT 运算符。用于反转运算数的逻辑状态。如果条件为真，逻辑 NOT 运算符将变为假。

!(a && b) 为假。

not

称为逻辑 NOT 运算符。用于反转运算数的逻辑状态。如果条件为真，逻辑 NOT 运算符将变为假。

Ruby Ternary Operator

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

Operator

Description

Example

? :

Conditional Expression

如果条件为真？然后值为 X：否则值为 Y

Ruby Range Operators

Ruby 中的序列范围用于创建一系列连续值，包括一个起始值、一个结束值和介于两者之间的值范围。

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

Operator

Description

Example

..

从起点到终点（包括终点）创建一个范围。

1..10 从 1 到 10（包括 10）创建一个范围。

…​

从起点到终点（不包括终点）创建一个范围。

1…​10 从 1 到 9 创建一个范围。

Ruby defined? Operators

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

defined? 运算符有以下各种使用方法

Usage 1

defined? variable # True if variable is initialized

For Example

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

Usage 2

defined? method_call # True if a method is defined

For Example

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

Usage 3

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

For Example

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

Usage 4

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

For Example

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

Ruby Dot "." and Double Colon "::" Operators

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

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

在 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

Second Example

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 Operators Precedence

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

Method

Operator

Description

Yes

::

Constant resolution operator

Yes

[ ] [ ]=

Element reference, element set

Yes

**

指数（乘方）

Yes

! ~ + -

非、补码、一元加和一元减（最后两个的方法名为 +@ 和 -@）

Yes

* / %

Multiply, divide, and modulo

Yes

+ -

Addition and subtraction

Yes

>> <<

右位移和左位移

Yes

&

Bitwise 'AND'

Yes

^

异或和或

Yes

⇐ < > >=

Comparison operators

Yes

⇒ == === != =~ !~

相等和模式匹配运算符（!= 和 !~ 可能未定义为方法）

&&

Logical 'AND'

Logical 'OR'

.. …​

Range (inclusive and exclusive)

? :

Ternary if-then-else

= %= { /= -= +=

= &= >>= <⇐ *= &&=

= **=

Assignment

defined?

检查指定的符号是否已定义

not

Logical negation

or and

Logical composition

NOTE − 方法列包含“是”的运算符实际上是方法，因此可以被覆盖。