位置:首页 > > Ruby运算符

Ruby运算符

Ruby支持一系列丰富的运算符的一个现代化的语言。大多数运算符实际上是方法调用。例如,a + b的被解释为a,
+(b)变量引用的对象的方法被称为一个用b作为它的参数。

对于每个运算符 (+ - * / % ** & | ^ << >> && ||), 有相应的赋值运算符缩写形式 (+= -= 等)

Ruby算术运算符:

假设变量a=10,变量b=20:

操作符 描述 例子
+ Addition - Adds values on either side of the operator a + b = 30
- Subtraction - Subtracts right hand operand from left hand operand a - b = -10
* Multiplication - Multiplies values on either side of the operator a * b = 200
/ Division - Divides left hand operand by right hand operand b / a = 2
% Modulus - Divides left hand operand by right hand operand and returns remainder b % a = 0
** Exponent - Performs exponential (power) calculation on operators a**b = 10 to the power 20

Ruby比较操作符:

假设变量a=10,变量b=20:

操作符 描述 例子
== Checks if the value of two operands are equal or not, if yes then condition becomes true. (a == b) is not true.
!= Checks if the value of two operands are equal or not, if values are not equal then condition becomes true. (a != b) is true.
> Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. (a > b) is not true.
< Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. (a < b) is true.
>= Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. (a >= b) is not true.
<= Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. (a <= b) is true.
<=> Combined comparison operator. Returns 0 if first operand equals second, 1 if first operand is greater than the second and -1 if first operand is less than the second. (a <=> b) returns -1.
=== Used to test equality within a when clause of a case statement. (1...10) === 5 returns true.
.eql? True if the receiver and argument have both the same type and equal values. 1 == 1.0 returns true, but 1.eql?(1.0) is false.
equal? True if the receiver and argument have the same object id. if aObj is duplicate of bObj then aObj == bObj is true, a.equal?bObj is false but a.equal?aObj is true.

Ruby赋值运算符:

假设变量a=10,变量b=20:

操作符 描述 例子
= Simple assignment operator, Assigns values from right side operands to left side operand c = a + b will assigne value of a + b into c
+= Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand c += a is equivalent to c = c + a
-= Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand c -= a is equivalent to c = c - a
*= Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand c *= a is equivalent to c = c * a
/= Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand c /= a is equivalent to c = c / a
%= Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand c %= a is equivalent to c = c % a
**= Exponent AND assignment operator, Performs exponential (power) calculation on operators and assign value to the left operand c **= a is equivalent to 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语言的位运算符

运算符 描述 实例
& Binary AND Operator copies a bit to the result if it exists in both operands. (a & b) will give 12 which is 0000 1100
| Binary OR Operator copies a bit if it exists in either operand. (a | b) will give 61 which is 0011 1101
^ Binary XOR Operator copies the bit if it is set in one operand but not both. (a ^ b) will give 49 which is 0011 0001
~ Binary Ones Complement Operator is unary and has the efect of 'flipping' bits. (~a ) will give -61 which is 1100 0011 in 2's complement form due to a signed binary number.
<< Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. a << 2 will give 240 which is 1111 0000
>> Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. a >> 2 will give 15 which is 0000 1111

Ruby逻辑运算符:

支持Ruby语言的逻辑运算符

假设变量a=10,变量b=20:

运算符 描述 例子
and Called Logical AND operator. If both the operands are true then then condition becomes true. (a and b) is true.
or Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true. (a or b) is true.
&& Called Logical AND operator. If both the operands are non zero then then condition becomes true. (a && b) is true.
|| Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true. (a || b) is true.
! Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. !(a && b) is false.
not Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. not(a && b) is false.

Ruby三元运算符:

还有一个运算符称为三元运算符。这首先计算一个表达式为true或false值,然后执行一个计算结果来决定两个语句的哪一个。条件运算符的语法如下:

运算符 描述 例子
? : Conditional Expression If Condition is true ? Then value X : Otherwise value Y

Ruby范围运算符:

Ruby中的序列范围是用来创建连续值 - 组成了开始值/结束值,并在两者之间的值的范围内。

在Ruby中,创建这些序列使用“..”和“...”范围运算符。这两个点的形式建立一个包容性的范围,而三个点的形式创建了一个范围,不包括指定的最大值。

运算符 描述 例子
.. Creates a range from start yiibai to end yiibai inclusive 1..10 Creates a range from 1 to 10 inclusive
... Creates a range from start yiibai to end yiibai exclusive 1...10 Creates a range from 1 to 9

Ruby defined? 操作符:

defined? 是一个特殊的操作符采取的形式的方法调用,以确定是否通过表达式定义。如果没有被定义的表达式,它返回一个描述字符串求解出的表达式或nil

有很多种用法 defined? 操作符:

用法 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 "." 双冒号 "::" 运算符:

调用一个模块方法,通过模块的名称和句点它的名字前,引用一个常数使用该模块的名称和两个冒号。
::使得一元运算符,常数,实例方法和类方法在类或模块定义,从任何地方访问外的类或模块。
请记住:在Ruby中,类和方法可以被视为常数。只需要前缀::Const_name的表达式返回相应的类或模块对象。
如果没有前缀表达式时,主要对象类默认情况下使用。
这里有两个例子:

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

Second Example:

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运算符优先级

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

方法 运算符 描述
Yes :: Constant resolution operator
Yes [ ] [ ]= Element reference, element set
Yes ** Exponentiation (raise to the power)
Yes ! ~ + - Not, complement, unary plus and minus (method names for the last two are +@ and -@)
Yes * / % Multiply, divide, and modulo
Yes + - Addition and subtraction
Yes >> << Right and left bitwise shift
Yes & Bitwise 'AND'
Yes ^ | Bitwise exclusive `OR' and regular `OR'
Yes <= < > >= Comparison operators
Yes <=> == === != =~ !~ Equality and pattern match operators (!= and !~ may not be defined as methods)
  && Logical 'AND'
  || Logical 'OR'
  .. ... Range (inclusive and exclusive)
  ? : Ternary if-then-else
  = %= { /= -= += |= &= >>= <<= *= &&= ||= **= Assignment
  defined? Check if specified symbol defined
  not Logical negation
  or and Logical composition

注: 方法列一个是运算符实际上是方法,因此可能会被改写。