Ruby supports a rich set of operators, as you'd expect from a modern language. Most operators are actually method calls. For example, a + b is interpreted as a.+(b), where the + method in the object referred to by variable a is called with b as its argument.
For each operator (+ - * / % ** & | ^ << >> && ||), there is a corresponding form of abbreviated assignment operator (+= -= etc.).
Assume variable a holds 10 and variable b holds 20, then −
Operator | Description | Example |
---|---|---|
+ | Addition − Adds values on either side of the operator. | a + b will give 30 |
− | Subtraction − Subtracts right hand operand from left hand operand. | a - b will give -10 |
* | Multiplication − Multiplies values on either side of the operator. | a * b will give 200 |
/ | Division − Divides left hand operand by right hand operand. | b / a will give 2 |
% | Modulus − Divides left hand operand by right hand operand and returns remainder. | b % a will give 0 |
** | Exponent − Performs exponential (power) calculation on operators. | a**b will give 10 to the power 20 |
Assume variable a holds 10 and variable b holds 20, then −
Operator | Description | Example |
---|---|---|
== | 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. |
Assume variable a holds 10 and variable b holds 20, then −
Operator | Description | Example |
---|---|---|
= | Simple assignment operator, assigns values from right side operands to left side operand. | c = a + b will assign the value of a + b into c |
+= | Add AND assignment operator, 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, 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, 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, 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, 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 also supports the parallel assignment of variables. This enables multiple variables to be initialized with a single line of Ruby code. For example −
a = 10 b = 20 c = 30
This may be more quickly declared using parallel assignment −
a, b, c = 10, 20, 30
Parallel assignment is also useful for swapping the values held in two variables −
a, b = b, c
Bitwise operator works on bits and performs bit by bit operation.
Assume if a = 60; and b = 13; now in binary format they will be as follows −
a = 0011 1100 b = 0000 1101 ------------------ a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011
The following Bitwise operators are supported by Ruby language.
Operator | Description | Example |
---|---|---|
& | 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 effect 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 |
The following logical operators are supported by Ruby language
Assume variable a holds 10 and variable b holds 20, then −
Operator | Description | Example |
---|---|---|
and | Called Logical AND operator. If both the operands are true, then the condition becomes true. | (a and b) is true. |
or | Called Logical OR Operator. If any of the two operands are non zero, then the condition becomes true. | (a or b) is true. |
&& | Called Logical AND operator. If both the operands are non zero, then the condition becomes true. | (a && b) is true. |
|| | Called Logical OR Operator. If any of the two operands are non zero, then the 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. |
There is one more operator called Ternary Operator. It first evaluates an expression for a true or false value and then executes one of the two given statements depending upon the result of the evaluation. The conditional operator has this syntax −
Operator | Description | Example |
---|---|---|
? : | Conditional Expression | If Condition is true ? Then value X : Otherwise value Y |
Sequence ranges in Ruby are used to create a range of successive values - consisting of a start value, an end value, and a range of values in between.
In Ruby, these sequences are created using the ".." and "..." range operators. The two-dot form creates an inclusive range, while the three-dot form creates a range that excludes the specified high value.
Operator | Description | Example |
---|---|---|
.. | Creates a range from start point to end point inclusive. | 1..10 Creates a range from 1 to 10 inclusive. |
... | Creates a range from start point to end point exclusive. | 1...10 Creates a range from 1 to 9. |
defined? is a special operator that takes the form of a method call to determine whether or not the passed expression is defined. It returns a description string of the expression, or nil if the expression isn't defined.
There are various usage of defined? Operator
defined? variable # True if variable is initialized
For Example
foo = 42 defined? foo # => "local-variable" defined? $_ # => "global-variable" defined? bar # => nil (undefined)
defined? method_call # True if a method is defined
For Example
defined? puts # => "method" defined? puts(bar) # => nil (bar is not defined here) defined? unpack # => nil (not defined here)
# True if a method exists that can be called with super user defined? super
For Example
defined? super # => "super" (if it can be called) defined? super # => nil (if it cannot be)
defined? yield # True if a code block has been passed
For Example
defined? yield # => "yield" (if there is a block passed) defined? yield # => nil (if there is no block)
You call a module method by preceding its name with the module's name and a period, and you reference a constant using the module name and two colons.
The :: is a unary operator that allows: constants, instance methods and class methods defined within a class or module, to be accessed from anywhere outside the class or module.
Remember in Ruby, classes and methods may be considered constants too.
You need to just prefix the :: Const_name with an expression that returns the appropriate class or module object.
If no prefix expression is used, the main Object class is used by default.
Here are two examples −
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
The following table lists all operators from highest precedence to lowest.
Method | Operator | Description |
---|---|---|
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 |
NOTE − Operators with a Yes in the method column are actually methods, and as such may be overridden.