Ruby 運算符

Ruby 算術(shù)運算符

假設(shè)變量 a 的值為 10，變量 b 的值為 20，那么：

Ruby 比較運算符

假設(shè)變量 a 的值為 10，變量 b 的值為 20，那么：

Ruby 賦值運算符

假設(shè)變量 a 的值為 10，變量 b 的值為 20，那么：

Ruby 并行賦值

Ruby 也支持變量的并行賦值。這使得多個變量可以通過一行的 Ruby 代碼進行初始化。例如：

a = 10
b = 20
c = 30

使用并行賦值可以更快地聲明：

a, b, c = 10, 20, 30

并行賦值在交換兩個變量的值時也很有用：

a, b = b, c

Ruby 位運算符

位運算符作用于位，并逐位執(zhí)行操作。

假設(shè)如果 a = 60，且 b = 13，現(xiàn)在以二進制格式，它們?nèi)缦滤荆?/p>

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

下表列出了 Ruby 支持的位運算符。

Ruby 邏輯運算符

下表列出了 Ruby 支持的邏輯運算符。

假設(shè)變量 a 的值為 10，變量 b 的值為 20，那么：

Ruby 三元運算符

有一個以上的操作稱為三元運算符。第一個計算表達式的真假值，然后根據(jù)這個結(jié)果決定執(zhí)行后邊兩個語句中的一個。條件運算符的語法如下：

Ruby 范圍運算符

在 Ruby 中，序列范圍用于創(chuàng)建一系列連續(xù)的值 - 包含起始值、結(jié)束值（視情況而定）和它們之間的值。

在 Ruby 中，這些序列是使用 ".." 和 "..." 范圍運算符來創(chuàng)建的。兩點形式創(chuàng)建的范圍包含起始值和結(jié)束值，三點形式創(chuàng)建的范圍只包含起始值不包含結(jié)束值。

Ruby defined? 運算符

defined? 是一個特殊的運算符，以方法調(diào)用的形式來判斷傳遞的表達式是否已定義。它返回表達式的描述字符串，如果表達式未定義則返回 nil。

下面是 defined? 運算符的各種用法：

用法 1

defined? variable # 如果 variable 已經(jīng)初始化，則為 True

例如：

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil（未定義）

用法 2

defined? method_call # 如果方法已經(jīng)定義，則為 True

例如：

defined? puts        # => "method"
defined? puts(bar)   # => nil（在這里 bar 未定義）
defined? unpack      # => nil（在這里未定義）

用法 3

# 如果存在可被 super 用戶調(diào)用的方法，則為 True
defined? super

例如：

defined? super     # => "super"（如果可被調(diào)用）
defined? super     # => nil（如果不可被調(diào)用）

用法 4

defined? yield   # 如果已傳遞代碼塊，則為 True

例如：

defined? yield    # => "yield"（如果已傳遞塊）
defined? yield    # => nil（如果未傳遞塊）

Ruby 點運算符 "." 和雙冒號運算符 "::"

您可以通過在方法名稱前加上模塊名稱和一條下劃線來調(diào)用模塊方法。您可以使用模塊名稱和兩個冒號來引用一個常量。

:: 是一元運算符，允許在類或模塊內(nèi)定義常量、實例方法和類方法，可以從類或模塊外的任何地方進行訪問。

請記?。?/b>在 Ruby 中，類和方法也可以被當作常量。

MR_COUNT = 0        # 定義在主 Object 類上的常量
module Foo
  MR_COUNT = 0
  ::MR_COUNT = 1    # 設(shè)置全局計數(shù)為 1
  MR_COUNT = 2      # 設(shè)置局部計數(shù)為 2
end
puts MR_COUNT       # 這是全局常量
puts Foo::MR_COUNT  # 這是 "Foo" 的局部常量 

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