-

Ruby支持一组丰富的运算符，就像您所期望的一种现代语言一样。大多数运算符实际上是方法调用。例如，a + b被解释为一个+（b），其中变量a引用的对象中的+方法以b为参数来调用。

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

Ruby算术运算符

假设变量a保持10，变量b保持20，则 -

没有 操作符和说明 例
1 +

加法 - 在运算符的两边添加值。

 a + b将给予30
2 -

减法 - 从左手操作数减去右手操作数。

 a - b会给-10
3 *

乘法 - 在运算符的两边乘以值。

 a * b会给予200
4 /

部门 - 用右手操纵数除数左手操作数。

 b / a将给予2
5 ％

模数 - 用右手操作数除左手操作数并返回余数。

 b％a会给0
6 **

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

 a ** b将给予权力20

Ruby比较运算符

假设变量a保持10，变量b保持20，则 -

没有 操作符和说明 例
1 ==

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

 （a == b）不正确。
2 ！=

检查两个操作数的值是否相等，如果值不等于条件成立。

 （a！= b）是真的。
3 >

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

 （a> b）不正确。
4 <

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

 （a <b）是真的。
5 > =

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

 （a> = b）不是真的。
6 <=

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

 （a <= b）是真的。
7 <=>

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

 （a <=> b）返回-1。
8 ===

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

 （1 ... 10）=== 5返回true。
9 .eql？

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

 1 == 1.0返回true，但是1.eql？（1.0）是false。
10 等于？

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

 如果aObj与bObj重复，那么aObj == bObj为true，则a.equal？bObj为false，但a.equal？aObj为true。

Ruby分配运算符

假设变量a保持10，变量b保持20，则 -

没有 操作符和说明 例
1 =

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

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

添加AND赋值运算符，将右操作数添加到左操作数，并将结果分配给左操作数。

 c + = a等价于c = c + a
3 - =

减去AND赋值运算符，从左操作数中减去右操作数，并将结果分配给左操作数。

 c * - = a等价于c = c - a
4 * =

乘以AND赋值运算符，将右操作数与左操作数相乘，并将结果分配给左操作数。

 c * = a等价于c = c * a
5 / =

除以AND赋值运算符，将左操作数与右操作数分开，并将结果分配给左操作数。

 c / = a等价于c = c / a
6 ％=

模数AND分配运算符，使用两个操作数来计算模数，并将结果分配给左操作数。

 c％= a等价于c = c％a
7 ** =

指数AND赋值运算符对运算符进行指数（幂）运算，并将值分配给左操作数。

 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 Bitwise运算符

按位运算符对位执行，并进行逐位运算。

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

没有 操作符和说明 例
1 ＆

如果二进制AND运算符存在于两个操作数中，则二进制AND运算符将对结果复制一位。

 （a＆b）将给予12，即0000 1100
2 |

二进制OR运算符如果存在于任一操作数中，则复制一位。

 （a | b）将给出61，即0011 1101
3 ^

二进制XOR操作符复制该位，如果它设置在一个操作数中，而不是两者。

 （a ^ b）将给出49，即0011 0001
4

二进制补码运算符是一元的，具有“翻转”位的作用。

 （a）将给出-61，由于符号二进制数，其为2的补码形式为1100 0011。
5 <<

二进制左移操作符。左操作数值左移由右操作数指定的位数。

 一个<< 2将给予240，即1111 0000
6 >>

二进制右移操作符。左操作数值被右操作数指定的位移动。

 a >> 2将给出15，这是0000 1111

Ruby逻辑运算符

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

假设变量a保持10，变量b保持20，则 -

没有 操作符和说明 例
1 和

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

 （a和b）是真的。
2 或

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

 （a或b）是真的。
3 &&

称为逻辑AND运算符。如果两个操作数都不为零，则条件成立。

 （a && b）是真的。
4 ||

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

 （a || b）为真。
5 ！

称为逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真，则逻辑NOT运算符将为false。

 ！（a && b）是假的。
6 不

称为逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真，则逻辑NOT运算符将为false。

 不（a && b）是假的。

Ruby三元运算符

还有一个叫三元运算符的运算符。它首先计算一个表达式的true或false值，然后根据评估结果执行两个给定语句之一。条件运算符具有这种语法 -

没有 操作符和说明 例
1 ？：

条件表达式

 如果条件是真的？那么值X：否则值Y

红宝石范围运算符

Ruby中的序列范围用于创建一系列连续的值 - 由起始值，结束值和值之间的范围组成。

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

没有 操作符和说明 例
1 .. ..

创建从起点到终点的范围。

 1..10创建范围从1到10（含）。
2 ...

创建从起始点到终点独占的范围。

 1 ... 10创建范围从1到9。

Ruby定义？经营者

定义？是一个特殊的操作符，采用方法调用的形式来确定传递的表达式是否被定义。它返回表达式的描述字符string，如果表达式未定义，则返回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中，类和方法也可以被认为是常量。

您需要在:: 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运算符优先级

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

方法 操作符 描述
是 :: 恒定分辨率算子
是 [] [] = 元素参考，元素集
是 ** 指数（提高权力）
是 ！+ - 不，补，一元加减（最后两个的方法名称是+ @和 - @）
是 * /％ 乘，除和模
是 + - 加减
是 >> << 左右向右移位
是 ＆ 按位“AND”
是 ^ | 按位异或“OR”和常规的“OR”
是 <= <>> = 比较运算符
是 <=> == ===！= =！ 平等和模式匹配运算符（！=和！可能不被定义为方法）
  && 逻辑"AND"
  || 逻辑"OR"
  .. ... 范围（包括和排他性）
  ？： 三元如果 - 否则
  =％= {/ = - = + = | =＆= >> = << = * = && = || = ** = 分配
  定义？ 检查指定的符号是否定义
  不 逻辑否定
  或者 逻辑构成

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

(c) 2024 chaojicainiao.com MIT license