Ruby 運算符

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) 不為真。
!=	檢查兩個運算元的值是否相等，如果不相等則條件為真。	(a != b) 為真。
>	檢查左運算元的值是否大於右邊運算元的值，如果是則條件為真。	(a > b) 不為真。
<	檢查左運算元的值是否小於右邊運算元的值，如果是則條件為真。	(a < b) 為真。
>=	檢查左運算元的值是否大於或等於右運算元的值，如果是則條件為真。	(a >= b) 不為真。
<=	檢查左運算元的值是否小於或等於右邊運算元的值，如果是則條件為真。	(a <= b) 為真。
<=>	聯合比較運算子。如果第一個操作數等於第二個運算元則傳回 0，如果第一個運算元大於第二個運算元則傳回 1，如果第一個運算元小於第二個運算元則傳回 -1。	(a <=> b)  回傳 -1。
===	用於測試 case 語句的 when 子句內的相等。	(1...10) === 5 傳回 true。
.eql?	如果接收器和參數具有相同的類型和相等的值，則傳回 true。	1 == 1.0 傳回 true，但是 1.eql?(1.0) 傳回 false。
equal?	如果接收器和參數具有相同的物件 id，則傳回 true。	如果 aObj 是 bObj 的副本，那麼 aObj == bObj 回傳 true，a.equal?bObj 回傳 false，但 a.equal?aObj 傳回 true。

Ruby 賦值運算子

假設變數a 的值為10，變數b 的值為20，那麼：

##運算子描述實例=#簡單的賦值運算符，把右邊運算元的值賦給左邊運算元c = a + b 將把a + b 的值賦給c#+=加且賦值運算符，把右運算元加上左運算元的結果賦值給左運算元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 支援的位元運算子。

乘且賦值運算符，把右邊運算元乘以左運算元的結果賦值給左運算元	c *= a 相當於c = c * a
除且賦值運算符，將左運算元除以右運算元的結果賦值給左運算元	c /= a 相當於c = c / a
求模且賦值運算符，求兩個運算符的模賦值給左運算元	c %= a 相當於c = c % a
指數且賦值運算符，執行指數計算，並賦值給左運算元	c **= a 相當於c = c ** a

運算子	描述	#實例
&	#如果同時存在於兩個運算元中，二進位AND 運算子複製一位到結果中。	(a & b) 將得到12，即為0000 1100
|	如果存在於任一操作數中，二進位OR 運算符複製一位到結果中。	(a | b) 將會得到61，也就是0011 1101
^	如果存在於其中一個運算元中但不同時存在於兩個運算元中，二進位異或運算子複製一位到結果中。	(a ^ b) 將會得到49，即為0011 0001
~	二進位補碼運算子是一元運算符，具有"翻轉"位效果。	(~a ) 將得到 -61，即為 1100 0011，2 的補碼形式，帶符號的二進制數。
<<	二進位左移運算子。左操作數的值向左移動右操作數所指定的位數。	a << 2 將得到 240，即為 1111 0000
>>	#二進位右移運算子。左操作數的值向右移動右操作數所指定的位數。	a >> 2 將得到 15，即為 0000 1111

Ruby 邏輯運算子

下表列出了 Ruby 支援的邏輯運算子。

假設變數a 的值為10，變數b 的值為20，那麼：

運算子	描述	實例
and	稱為邏輯與運算子。如果兩個操作數都為真，則條件為真。	(a and b) 為真。
or	稱為邏輯或運算子。如果兩個操作數中有任一個非零，則條件為真。	(a or b) 為真。
&&	稱為邏輯與運算子。如果兩個操作數都非零，則條件為真。	(a && b) 為真。
||	稱為邏輯或運算子。如果兩個操作數中有任一個非零，則條件為真。	(a || b) 為真。
!	稱為邏輯非運算子。用來逆轉操作數的邏輯狀態。如果條件為真則邏輯非運算子將使其為假。	!(a && b) 為假。
not	稱為邏輯非運算子。用來逆轉操作數的邏輯狀態。如果條件為真則邏輯非運算子將使其為假。	not(a && b) 為假。

Ruby 三元運算子

有一個以上的運算稱為三元運算子。第一個計算表達式的真假值，然後根據這個結果決定執行後邊兩個語句中的一個。條件運算子的語法如下：

#運算子	#描述

## ?:

條件式表達式

如果條件為真?則值為X : 否則值為Y

Ruby範圍運算子在Ruby 中，序列範圍用於建立一系列連續的值- 包含起始值、結束值（視情況而定）和它們之間的值。 在 Ruby 中，這些序列是使用 ".." 和 "..." 範圍運算子來建立的。兩點形式所建立的範圍包含起始值和結束值，三點形式所建立的範圍只包含起始值不包含結束值。

運算子	描述	#實例
..

##### #建立一個從開始點到結束點的範圍（包含結束點）######1..10 建立從1 到10 的範圍###########...## ####建立一個從開始點到結束點的範圍（不包含結束點）######1...10 建立從1 到9 的範圍############

Ruby defined? 運算子

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

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

用法1

defined? variable # 如果 variable 已经初始化，则为 True

例如：

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

用法2

defined? method_call # 如果方法已经定义，则为 True

例如：

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

用法3

# 如果存在可被 super 用户调用的方法，则为 True
defined? super

例如：

defined? super     # => "super"（如果可被调用）
defined? super     # => nil（如果不可被调用）

用法4

defined? yield   # 如果已传递代码块，则为 True

例如：

defined? yield    # => "yield"（如果已传递块）
defined? yield    # => nil（如果未传递块）

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

您可以透過在方法名稱前加上模組名稱和一條底線來呼叫模組方法。您可以使用模組名稱和兩個冒號來引用一個常數。

:: 是一元運算符，允許在類別或模組內定義常數、實例方法和類別方法，可以從類別或模組外的任何地方存取。

請記住：在 Ruby 中，類別和方法也可以被當作常數。

您只需要在表達式的常數名稱前加上 :: 前綴，即可傳回適當的類別或模組物件。

如果未使用前綴表達式，則預設使用主 Object 類別。

下面是兩個實例：

MR_COUNT = 0        # 定义在主 Object 类上的常量
module Foo
  MR_COUNT = 0
  ::MR_COUNT = 1    # 设置全局计数为 1
  MR_COUNT = 2      # 设置局部计数为 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

Ruby 運算子的優先權

下表依照運算子的優先級從高到低列出了所有的運算符。

##是## ::常數解析運算子是[ ] [ ]=元素參考、元素集合是**#指數#是! ~ + -#非、補、一元加、一元減（最後兩個的方法名為+@ 和-@）#是乘法、除法、求模加法與減法#是>> <<位元右移、位元左移是 &位元與##位異或、位元或是<= < > >=比較運算子##< ;=> == === != =~ !~相等和模式匹配運算子（!= 和!~ 不能定義為方法）&&邏輯與||

方法	運算子	#描述
		##* / %
	是	#+ -
是	^ |
是
	##邏輯或
.. ...	範圍（包含、不包含）
? :	三元if-then-else
= %= { /= -= += |= &= >>= <<= *= &&= ||= **=	#賦值

###defined?######檢查指定符號是否已定義#####################not######邏輯否定#####################or and#######邏輯組成###############or and#######邏輯組成############

注意：在方法列標識為 是 的運算子實際上是方法，因此可以被重載。