2 m read

Getting Started with Operators in Ruby

Introduction to Operators in Ruby

If you’re venturing into the world of Ruby, one of the key topics you need to understand is operators.

Functioning as the foundation of any programming language, operators in Ruby are symbols representing critical operations performed with one or more operands. With these, you can manipulate values for comparison or a mathematical process.

Ruby’s Rich Set of Operators

Ruby supports a multitude of operators, with each interpreting an operation in its unique way. It’s important to recognize that most of these operators in Ruby are method calls.

A simple arithmetic operation, such as a + b, is interpreted as a.+(b), where the ‘+’ operator is a method in the object referred to by variable ‘a’ with ‘b’ as its argument.

This flexibility allows for customization and enhancement of functionality.

Arithmetic Operators

These operators are used to perform typical mathematical operations.

An operation such as 5 + 3 is interpreted as 5.+(3), where the digit is treated like an object, and the operator is a method. Consequently, you can define the addition of two objects.

Comparison of Relational Operators

Commonly used in conditional statements, these operators help compare two objects.

For instance, we have the spaceship operator. This operator returns 1, 0, or -1 based on whether one object is greater than, equal to, or less than the other object, respectively. This is handy for various comparison tasks, such as sorting an array based on a custom metric.

Assignment Operators

Assignment operators, such as ‘=‘, are used to assign a value to a variable.

It’s important to note that the value on the left side must match the variable’s data type on the left side. Otherwise, the program may raise an error.

Bitwise and Logical Operators

These operators work at the bit level and perform operations bit by bit.

Logical operators like && (and) and || (or) provide short-circuiting by executing each side of the operator from left to right and stopping at the first occurrence of a false expression.

Special Ruby Operators

Ruby introduces some exceptional operators that merit mention due to their unique functions.

The Defined? Operator

This unique operator is used to check whether a passed expression is defined. It will return a string description if the expression is defined and ‘nil’ otherwise.

Let’s use real-world code:

puts defined? 1  # will return "expression"

The Splat Operator (*)

This exceptional operator explodes an array into a list of its elements.

For example:

arr = [*1..5]  # will return [1, 2, 3, 4, 5]

The Safe Navigation Operator (&.)

While calling methods on objects, we use the dot operator. However, if a requested method or key isn’t available, it throws an error.

The safe navigation operator (&.) fixes this by returning ‘nil’ instead of raising an error. It can be advantageous when dealing with objects that might be ‘nil’.

The Modulo Operator

Returning the remainder of a division operation between two numbers, this operator has many practical uses.

For instance, it’s useful for finding whether a number is even or odd.


Understanding operators and their functions is a fundamental step in mastering Ruby.

They excel in performing basic arithmetic tasks, comparing objects, performing logical operations, and even more complex tasks like defining whether an expression is defined or converting an array into a list of its elements.

Continue your learning journey with our previous article on ‘Data Types in Ruby’.


Leave a Reply