上一节:
下一节:

  Ruby 运算符

  • Ruby 运算符

    正如您期望的那样，Ruby支持大量的运算符。大多数运算符实际上是方法调用。例如，a + b被解释为a.+（b），其中变量a所引用的对象中的+方法以b作为其参数来调用。对于每个运算符（+ - * / ％ ** ＆ | ^ << >> && ||），都有对应形式的缩写赋值运算符（+=  -= 等等）。

  • 算术运算符

    假设变量a持有10，变量b持有20，则-
    操作符 描述 示例
    + 加法-在运算符的任一侧添加值。 a + b得30
    - 减法-从左手操作数中减去右手操作数。 a - b得-10
    * 乘法-将运算符两侧的值相乘。 a * b得200
    / 除法-将左操作数除以右操作数。 b / a得2
    ％ 模数-将左操作数除以右操作数，并返回余数。 b ％a得0
    ** 指数-对运算符执行指数（幂）计算。 a ** b得1020

  • 比较运算符

    假设变量a持有10，变量b持有20，则-
    操作符 描述 示例
    == 检查两个操作数的值是否相等，如果是，则条件为真。 （a == b）false。
    != 检查两个操作数的值是否相等，如果值不相等，则条件为真。 （a != b）true。
    > 检查左操作数的值是否大于右操作数的值，如果是，则条件为真。 （a > b）false
    < 检查左操作数的值是否小于右操作数的值，如果是，则条件为真。 （a < b）true
    >= 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件为真。 （a >= b）true
    <= 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件为真。 （a <= b）true
    <=> 组合比较运算符。如果第一个操作数等于第二个，则返回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为真，则a.equal?bObj为假，而a.equal?aObj为真。

  • 赋值运算符

    假设变量a持有10，变量b持有20，则-
    操作符 描述 示例
    = 简单赋值运算符，用于将值从右侧操作数分配到左侧操作数。 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还支持变量的并行分配。这使得可以用一行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语言支持以下按位运算符。
    操作符 描述 示例
    & 如果两个操作数中都存在二进制位1，则会将一位复制到结果中。 （a＆b）将得到12，即0000 1100
    | 如果任一操作数中存在二进制1，则会对其进行复制。 （a | b）将给出61，即0011 1101
    ^ 如果在一个操作数中设置了该位，但不是在两个操作数中都设置了位，则二进制异或运算符将复制该位。 （a ^ b）将得出49，即0011 0001
    ~ 二进制补码运算符是一元的，具有“翻转”位的作用。 （~a）将给出-61，这是2的补码形式的1100 0011（由于带符号的二进制数）。
    << 二进制左移运算符。左操作数的值向左移动右操作数指定的位数。 << 2将得到240，即1111 0000
    >> 二进制右移运算符。左操作数的值向右移动右操作数指定的位数。 a >> 2将得到15，即0000 1111

  • 逻辑运算符

    Ruby语言支持以下逻辑运算符，假设变量a持有10，变量b持有20，则-
    操作符 描述 示例
    and 称为逻辑和运算符。如果两个操作数都为真，则条件为真。 （a and b）是true。
    or 称为逻辑或运算符。如果两个操作数中的任何一个都不为零，则条件变为true。 （a or b）是true。
    && 称为逻辑和运算符。如果两个操作数都不为零，则条件变为true。 （a && b）是true。
    || 称为逻辑或运算符。如果两个操作数中的任何一个都不为零，则条件变为true。 （a || b）是true。
    ! 称为逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真，则逻辑非运算符将为假。 !(a && b) 是false。
    not 称为逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真，则逻辑非运算符将为假。 not(a && b)是false。

  • 三元运算符

    还有一个运算符称为三元运算符。它首先对表达式的真值或假值求值，然后根据求值结果执行两个给定语句之一。条件运算符具有以下语法-
    操作符 描述 示例
    ?： 条件表达式 （如果条件为真 ? 然后值X ： 否则值Y

  • Range运算符

    Ruby中的序列范围用于创建一系列连续值-由开始值，结束值以及介于两者之间的值范围组成。在Ruby中，这些序列是使用“..”和“...”范围运算符创建的。两点形式创建一个包含范围，而三点形式创建一个排除指定高值的范围。
    操作符 描述 示例
    .. 创建一个从起点到终点的范围。 1..10创建一个1到10（含）范围。
    ... 创建一个从起点到终点的范围。 1...10创建1到9的范围。

  • defined? 运算符

    defined? 是一个特殊的运算符，采用方法调用的形式来确定是否定义了所传递的表达式。它返回表达式的描述字符串，如果未定义表达式，则返回nil。defined? 有各种用法
    用法1 
    
defined? variable # 如果变量已初始化则为true
    例如 
    
foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)
    用法2 
    
defined? method_call # 如果定义了方法则为真
    例如 
    
defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)
    用法3 
    
# 如果存在可以由超级用户调用的方法，则为true
defined? super
    例如 
    
defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)
    用法4 
    
defined? yield   # 如果已传递代码块，则为真
    例如 
    
defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

  • . 和 :: 运算符

    您可以通过在模块名称前加上模块名称和句点.来调用模块方法，使用模块名称和两个冒号::引用常量。
    ::是一元运算符，其允许一个类或模块中定义的，常数，实例方法和类方法从类或模块以外的任何地方进行访问。请记住，在Ruby中，类和方法也可以视为常量。
    您只需要在::Const_name前面添加一个表达式，即可返回适当的类或模块对象。
    如果不使用前缀表达式，则默认使用主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

  • 运算符优先级

    下表列出了从最高优先级到最低优先级的所有运算符。
    注 – 在方法列中为是的运算符实际上是方法，因此可能会被覆盖。
    方法 操作符 描述
    是 :: 常量，位置运算符
    是 [ ] [ ]= 元素引用，元素集
    是 ** 求幂（提高幂）
    是 ! ~ + - 不是，补码，一元加号和减号（最后两个的方法名称是+ @和-@）
    是 * / % 乘，除和取模
    是 + - 加减
    是 >> << 左右位移
    是 & 按位“与”
    是 ^ | 按位异或或常规OR
    是 <= < > >= 比较运算符
    是 <=> == === != =~ !~ 相等和模式匹配运算符（！=和！〜可能未定义为方法）
      && 逻辑“AND”
      || 逻辑“OR”
      .. ... 范围（包括和不包括）
      ? : 三元if-then-else
      = %= { /= -= += |= &= >>= <<= *= &&= ||= **= 赋值
      defined? 检查是否定义了指定的符号
      not 逻辑非
      or and 逻辑和
上一节:
下一节: