Ruby Operators

Ruby supports a rich set of operators. Most operators are actually method calls. For example, a + b is interpreted as a.+(b), where the + method of the variable a is called with b as the argument.

For each operator (+ - * / % ** & | ^ << >> && ||), there is a corresponding shorthand assignment operator (+= -= etc.).

Ruby Arithmetic Operators

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

Ruby Comparison Operators

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

Ruby Assignment Operators

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

Ruby Parallel Assignment

Ruby also supports parallel assignment of variables. This allows multiple variables to be initialized with a single line of Ruby code. For example:

a = 10
b = 20
c = 30

Using parallel assignment, this can be done more quickly:

a, b, c = 10, 20, 30

Parallel assignment is also useful for swapping the values of two variables:

a, b = b, c

Ruby Bitwise Operators

Bitwise operators work on bits and perform bit-by-bit operations.

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 table lists the bitwise operators supported by Ruby:

Ruby Logical Operators

The following table lists the logical operators supported by Ruby:

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

Ruby Ternary Operator

There is one more operator called the ternary operator. The 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 syntax is as follows:

Ruby Range Operators

In Ruby, sequence ranges are used to create a range of successive values - consisting of a start value, an end value (optionally), and 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 high value.

Ruby defined? Operator

defined? is a special operator that takes the form of a method call to determine whether the passed expression is defined. It returns a description string of the expression, or nil if the expression is not defined.

Here are the various uses of the defined? operator:

Usage 1

defined? variable # True if the 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 the method is defined

For example:

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is undefined here)
defined? unpack      # => nil (undefined here)

Usage 3

# True if a method callable by super user is present
defined? super

For example:

defined? super     # => "super" (if callable)
defined? super     # => nil (if not callable)

Usage 4

defined? yield   # True if a block is passed

For example:

defined? yield    # => "yield" (if a block is passed)
defined? yield    # => nil (if no block is passed)

Ruby Dot Operator "." and Double Colon Operator "::"

You can call methods in a class or module by prefixing the method name with the class or module name and a dot .. You can reference constants using the class or module name and two colons ::.

:: is a unary operator that allows constants, instance methods, and class methods to be accessed from anywhere outside the class or module.

Remember: In Ruby, classes and methods can also be treated as constants.

You just need to prefix the constant name with :: to return the appropriate class or module object.

If the expression before :: is a class or module name, it returns the corresponding constant value within that class or module; if there is no prefix expression, it returns the corresponding constant value from the main Object class.

Here are two examples:

MR_COUNT = 0        # 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 Operator Precedence

The table below lists all the operators in order of precedence from highest to lowest.

Note: Operators marked as Yes in the method column are actually methods and can therefore be overloaded.