Ruby运算符
对于每个运算符 (+ - * / % ** & | ^ << >> && ||), 有相应的赋值运算符缩写形式 (+= -= 等)
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 |
注: 方法列一个是运算符实际上是方法,因此可能会被改写。
欢迎任何形式的转载,但请务必注明出处,尊重他人劳动共创优秀实例教程
转载请注明:文章转载自:代码驿站 [http:/www.codeinn.net]
本文标题:Ruby运算符
本文地址:http://www.codeinn.net/ruby/90.html