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 逻辑和