Ruby支持一组丰富的运算符，正如您对现代语言所期望的那样.大多数运算符实际上是方法调用例如，a+ b被解释为.+(b)，其中+变量 a 引用的对象中的方法以 b 作为参数调用.
对于每个运算符(+ - *)/％**& | ^<<>>&& ||)，有相应形式的缩写赋值运算符(+ = - = etc.).
假设变量a保持10，变量b保持20，然后&减去;
| 运算符 | 描述 | 示例 |
|---|---|---|
| + | 加法和减号;在运算符的任一侧添加值. | a+ b将给出30 |
| : | 减法和减去;从左手操作数中减去右手操作数. | a - b将给-10 |
| * | 乘法和减号;将运算符两侧的值相乘. | a * b将给出200 |
| / | Division : 用左手操作数除左手操作数. | b/a将给2 |
| ％ | 模数和减去;用左手操作数除左手操作数并返回余数. | b％a将给0 |
| ** | Exponent : 对运算符执行指数(幂)计算. | a ** b将给出10的幂20 |
假设变量a保持10，变量b保持20，然后是 :
| 运算符 | Description | 示例 |
|---|---|---|
| == | 检查两个操作数的值是否相等，如果是，则条件变为真. | (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？ | 如果接收者和参数有相同的类型和相同的值. | 1 == 1.0返回true，但1.eql？(1.0)为false. |
| 等于？ | 如果接收器和参数具有相同的结果，则为真对象id. | 如果aObj是bObj的副本，则aObj == bObj为真，a.equal？bObj为false但是a.equal？aObj为真. |
假设变量a成立10，变量b成立20，然后是 :
| 运算符 | 描述 | 示例 |
|---|---|---|
| = | 简单赋值运算符，将右侧操作数的值分配给左侧操作数. | c = a+ b将分配a&plus的值; b到c |
| + = | 添加AND赋值运算符，将右操作数添加到左操作数并将结果赋值给左操作数. | c+ = a等于c = c+ a |
| - = | 减去AND赋值运算符，从左操作数中减去右操作数并将结果赋给左操作数. | c - = a等于c = c - a |
| * = | 乘以AND赋值运算符，将右操作数与左操作数相乘，并将结果赋值为left操作数. | c * = a相当于c = c * a |
| /= | 除以AND赋值运算符，将左操作数除以右操作数，并将结果赋值给左操作数. | c/= a相当于c = c/a |
| ％= | 模数和赋值运算符，使用两个操作数获取模数并将结果赋值给左操作数. | c％= a等于c = c％a |
| ** = | 指数和分配操作r，对运算符执行指数(幂)计算并将值赋给左操作数. | c ** = a相当于c = c ** a |
Ruby还支持并行分配变量.这使得可以使用单行Ruby代码初始化多个变量.例如 :
a = 10 b = 20 c = 30
这可以使用并行分配和减号更快地声明;
a，b，c = 10,20,30
并行赋值也可用于交换两个变量中的值和减去;
a，b = b，c
按位运算符处理位并执行位运算位操作.
假设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语言支持以下按位运算符.
| 运算符 | 描述 | 示例 |
|---|---|---|
| & | 如果两个操作数都存在，则二进制AND运算符会将结果复制到结果中. | (a & b)将给出12，即0000 1100 |
| | | Binary OR Operator如果它存在于任一操作数中，则复制一点. | (a | b)将给出61，即0011 1101 |
| ^ | 二进制XOR运算符如果在一个操作数中设置但不是两者都复制该位. | ( a ^ b)将给出49，即0011 0001 |
| 〜 | Binary Ones Complement Operator是一元的，具有"翻转"位的效果. | (~a)将给出-61由于有符号的二进制数，它是2的补码形式的1100 0011. |
| << ; | 二进制左移运算符.左操作数值向左移动右操作数指定的位数. | a<< 2将给出240，即1111 0000 |
| >> | 二进制右移运算符.左操作数值向右移动右操作数指定的位数. | a>> 2将给出15，即0000 1111 |
Ruby语言支持以下逻辑运算符
假设变量 a 保持10，变量 b 保持20，然后是 :
| 运算符 | 描述 | 示例 |
|---|---|---|
| and | 被称为逻辑AND运算符.如果两个操作数均为真，则条件成立. | (a和b)为真. |
| or | 被称为逻辑OR运算符.如果两个操作数中的任何一个非零，则条件变为真. | (a或b)为真. |
| && | 被称为逻辑AND运算符.如果两个操作数都不为零，则条件成立. | (a&& b)为真. |
| || | 被称为逻辑OR运算符.如果两个操作数中的任何一个非零，则条件变为真. | (a || b)为真. |
| ！ | 被称为逻辑非运算符.用于反转其操作数的逻辑状态.如果条件为真，则Logical NOT运算符将为false. | ！(a&& b)为false. |
| 不 | 被称为逻辑非运算符.用于反转其操作数的逻辑状态.如果条件为真，则Logical NOT运算符将为false. | not(a&& b)为false. |
还有一个名为Ternary Operator的运算符.它首先计算表达式的true或false值，然后根据评估结果执行两个给定语句中的一个.条件运算符具有以下语法 :
| 运算符 | 描述 | 示例 |
|---|---|---|
| ？ : | 条件表达式 | 如果条件为真？然后是值X:否则值Y |
序列范围在Ruby中用于创建一系列连续值 - 由起始值，结束值和介于两者之间的值范围组成.
在Ruby中，这些序列是使用"......"和"......"范围运算符.双点形式创建一个包含范围，而三点形式创建一个排除指定高值的范围.
| 运算符 | 描述 | 示例 |
|---|---|---|
| .. | 创建从起点到终点的范围. | 1..10创建1到10的范围. |
| ... | 创建从起点到终点独占的范围. | 1 ... 10创建1到9的范围. |
定义了什么？是一个特殊的运算符，它采用方法调用的形式来确定是否定义了传递的表达式.它返回表达式的描述字符串，如果未定义表达式，则返回 nil .
定义的用法有多种？运算符
defined? variable # True if variable is initialized
例如
foo = 42 defined? foo # => "local-variable" defined? $_ # => "global-variable" defined? bar # => nil (undefined)
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)
＃如果为真存在一个可以用超级用户 定义的方法吗？超
例如
# True if a method exists that can be called with super user defined? super
defined? yield # True if a code block has been passed
例如
defined? super # => "super" (if it can be called) defined? super # => nil (if it cannot be)
通过在模块名称前面加上模块名称和句点来调用模块方法，并使用模块名称和两个冒号引用常量./p>
:: 是一个一元运算符，它允许:从类或模块中定义的常量，实例方法和类方法，从类外的任何地方访问或模块.
记住在Ruby中，类和方法也可以被视为常量.
你需要在前缀中加上前缀 :: 带有表达式的Const_name，该表达式返回相应的类或模块对象.
如果未使用前缀表达式，则默认使用主Object类./p>
以下是两个示例 :
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下表列出了从最高优先级到最低优先级的所有运算符.
| 方法 | 运算符 | 描述 |
|---|---|---|
| 是 | :: | 常数分辨率算子 |
| 是 | [] [] = | 元素引用，元素集 |
| 是 | ** | Exponentiation(加注到电源) |
| 是 | ！ 〜+ - | 不，补码，一元加号和减号(最后两个的方法名称是+@和 - @) |
| 是 | */％ | 乘以，除以及模数 |
| 是 | &加; - | 加法和减法 |
| 是 | >> << | 左右按位移位 |
| 是 | & | 按位'AND' |
| 是 | ^ | | 按位排除`或者'和常规`OR' |
| 是 | < =< > > = | 比较运算符 |
| 是 | < => == ===！= =〜！〜 | 等式和模式匹配运算符(！=和！〜可能不定义为方法) |
| &&& | 逻辑'AND' | |
| || | 逻辑'或' | |
| .. ... | 范围(包括和排除) | |
| ？ : | Ternary if-then-else | |
| =％= {/= - =+ = | =& =>> = << = * =&& = || = ** = | 作业 | |
| defined？ | 检查是否指定符号定义 | |
| not | 逻辑否定 | |
| or and | 逻辑构成 |
注意 : 方法列中带有是的运算符实际上是方法，因此可以覆盖.
