# Ruby - Operators

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.).

## Ruby Arithmetic Operators

Assume variable a holds 10 and variable b holds 20, then −

Sr.No. | Operator & Description | Example |
---|---|---|

1 | +
Addition − Adds values on either side of the operator. |
a + b will give 30 |

2 | −
Subtraction − Subtracts right hand operand from left hand operand. |
a - b will give -10 |

3 | *
Multiplication − Multiplies values on either side of the operator. |
a * b will give 200 |

4 | /
Division − Divides left hand operand by right hand operand. |
b / a will give 2 |

5 | %
Modulus − Divides left hand operand by right hand operand and returns remainder. |
b % a will give 0 |

6 | **
Exponent − Performs exponential (power) calculation on operators. |
a**b will give 10 to the power 20 |

## Ruby Comparison Operators

Assume variable a holds 10 and variable b holds 20, then −

Sr.No. | Operator & Description | Example |
---|---|---|

1 | ==
Checks if the value of two operands are equal or not, if yes then condition becomes true. |
(a == b) is not true. |

2 | !=
Checks if the value of two operands are equal or not, if values are not equal then condition becomes true. |
(a != b) is true. |

3 | >
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. |

4 | <
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. |

5 | >=
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. |

6 | <=
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. |

7 | <=>
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. |

8 | ===
Used to test equality within a when clause of a |
(1...10) === 5 returns true. |

9 | .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. |

10 | 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 Assignment Operators

Assume variable a holds 10 and variable b holds 20, then −

Sr.No. | Operator & Description | Example |
---|---|---|

1 | =
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 |

2 | +=
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 |

3 | -=
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 |

4 | *=
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 |

5 | /=
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 |

6 | %=
Modulus AND assignment operator, takes modulus using two operands and assign the result to left operand. |
c %= a is equivalent to c = c % a |

7 | **=
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 Parallel Assignment

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

## Ruby Bitwise Operators

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.

Sr.No. | Operator & Description | Example |
---|---|---|

1 | &
Binary AND Operator copies a bit to the result if it exists in both operands. |
(a & b) will give 12, which is 0000 1100 |

2 | |
Binary OR Operator copies a bit if it exists in either operand. |
(a | b) will give 61, which is 0011 1101 |

3 | ^
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 |

4 | ~
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. |

5 | <<
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 |

6 | >>
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 Logical Operators

The following logical operators are supported by Ruby language

Assume variable *a* holds 10 and variable *b* holds 20, then −

Sr.No. | Operator & Description | Example |
---|---|---|

1 | and
Called Logical AND operator. If both the operands are true, then the condition becomes true. |
(a and b) is true. |

2 | or
Called Logical OR Operator. If any of the two operands are non zero, then the condition becomes true. |
(a or b) is true. |

3 | &&
Called Logical AND operator. If both the operands are non zero, then the condition becomes true. |
(a && b) is true. |

4 | ||
Called Logical OR Operator. If any of the two operands are non zero, then the condition becomes true. |
(a || b) is true. |

5 | !
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. |

6 | 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 Ternary Operator

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 −

Sr.No. | Operator & Description | Example |
---|---|---|

1 | ? :
Conditional Expression |
If Condition is true ? Then value X : Otherwise value Y |

## Ruby Range Operators

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.

Sr.No. | Operator & Description | Example |
---|---|---|

1 | ..
Creates a range from start point to end point inclusive. |
1..10 Creates a range from 1 to 10 inclusive. |

2 | ...
Creates a range from start point to end point exclusive. |
1...10 Creates a range from 1 to 9. |

## Ruby defined? Operators

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

### Usage 1

defined? variable # True if variable is initialized

**For Example**

foo = 42 defined? foo # => "local-variable" defined? $_ # => "global-variable" defined? bar # => nil (undefined)

### Usage 2

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)

### Usage 3

# 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)

### Usage 4

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)

## Ruby Dot "." and Double Colon "::" Operators

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

## Ruby Operators Precedence

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.