Ruby Operators¶
Ruby operators can be broadly categorized into the following :
 Arithmetic
 Shift or Append
 Comparison
 Booleans
 Ranges
Arithmetic Operators¶
The arithmetic operators are :
 +  Addition
   Subtraction
 *  Multiplication
 **  Exponential
 /  Division
 %  Modulo
Addition¶
> 1 + 1 => 2
Division¶
> 5 / 2 => 2
To get 2.5 as the answer you will need to use floating point numbers as follows :
> 5.0 / 2.0 => 2.5
Modulo¶
Remainder division
> 5 % 2 => 1
You will get an exception if you try to divide by 0.
> 2 /0 ZeroDivisionError: divided by 0 from (irb):9:in `/'
Floating point division with 0 will give Infinity
as a result.
> 2.0 / 0.0 => Infinity
Addition on Arrays¶
We can apply addition to arrays, the result in a concatenation of the two arrays as follows :
> [1,2] + [3,4,5] => [1, 2, 3, 4, 5]
Arithmetic Operators on Strings¶
We can also apply arithmetic operators on string objects as follows :
> "Hello world " * 2 => "Hello world Hello world "
Only the multiplication operator works, other arithmetic operators will produce an error.
Exponential Operators¶
We use the ** for exponent as follows :
> 2 ** 2 => 4
Shift operators¶
We can use the two shift operators, << and >>. This allows us to manipulate the numbers in binary. E.g we can easily get a 4 by shifting the 2 in binary by 1 as follows.
> 2 << 1 => 4
Here is how it works. The number 2 in binary is represented as 10. When we shift by 1 we push an additional 0 at the end, so we now get the number 100, which is 4 in binary.
We can display the value of 2 in binary using the to_s(2) method as follows :
> 2.to_s(2) => "10"
We can see that 2 in binary is 10.
If we change the operator and push to the right, we now remove the leading 0.
> 2 >> 1 => 1
We now get a 1 since we removed the leading 0 from 10.
We can shift with more bits if we prefer, e.g. to get the value 8 we can push 2 by 3 bits as follows :
> 2 << 2 => 8
Append Operator¶
The same operator for left shifting, << is for appending on arrays.
> nums = [] => [] 2.2.5 :029 > nums << 1 => [1] 2.2.5 :030 > nums << 2 => [1, 2]
We could also apply the append multiple times as follows :
> nums << 3 << 4 => [1, 2, 3, 4]
Output to Standard Output¶
The << operator is also used to output to Standard Output as follows :
> STDOUT << "Hello World" Hello World => #<IO:<STDOUT>>
Comparison Operators¶
 <  Less than operator
 <=  Less then or equal to operator

 Greater than operator

=  Greater than operator
 <=>  Comparable operator
 !=  Not equal to operator
Comparable operator <=>¶
The other operators perform exactly as they are supposed to except the comparable operator. The comparable operator works as follows :
 Returns 1 if the left hand value is less than the right hand operand
 Returns 1 if the left hand operand is greater than the right hand operand
 Return 0 is they are equal
 Returns nil if they can not be compared
> 2 <=> 2 => 0
> 1 <=> 2 => 1
> 2 <=> 1 => 1
Boolean Operators¶
 &&  Logical AND operator
   Logical OR operator
 !  NOT operator
&& operator¶
The operator returns tru if all the operands are true or false otherwise.
> 10 > 0 && 10 < 9 => false
 operator¶
The logical OR operator returns true if any of the operands returns true. It returns false if both operands return false.
> 10 > 0  10 == 10 => true
! NOT Operator¶
Negates the operand.
> !true => false
> !false => true
= OR Equal¶
This operator returns the current value if its initialized or initializes the new value.
> b = 5 # b is not defined, so we get 5 => 5 2.2.5 :049 > b = 10 # assign b to a new value of 10 => 10 2.2.5 :050 > b = 5 # assign 5 if b does not have a value => 10 # b have a value so we get the value already assigned
Performing the same operation above only using the (logical OR) operator results in an error as follows :
> a  5 NameError: undefined local variable or method `a' for main:Object
Range Operators¶
Range operators are used to implement sequences, conditions and intervals.
Range operator¶
We define the range with ..(inclusive) or ...(exclusive) operators.
Inclusive range operator¶
> (1..3).each {i p i} 1 2 3 => 1..3
Exclusive range operator¶
> (1...3).each {i p i} 1 2 => 1...3
Verify that the class is a range :
> (1..2).class => Range
Convert a range to array¶
We can convert the Range to an array using the to_a
as follows :
> (1..5).to_a => [1, 2, 3, 4, 5]
Convert to an enum¶
We can also convert the range to an enumerable using to_enum
as follows :
> n = (1..5).to_enum => #<Enumerator: 1..5:each> 2.2.5 :060 > n.next => 1 2.2.5 :061 > n.next => 2
We can also create and convert range of type character as follows :
> alphabet = ('a'..'z').to_enum => #<Enumerator: "a".."z":each> 2.2.5 :065 > alphabet.next => "a" 2.2.5 :066 > alphabet.next => "b"