How to Use Enums in Ruby?

What is Enum?

In programming, an enum, short for enumeration, is a data type that represents a collection of named constants. Enums are used to define a collection of values with distinct, specified meanings. They are commonly used to make code more clear and understandable.

In Ruby, an enum does not exist as a built-in language construct like in some other programming languages. However, we can achieve similar functionality using various approaches.

To simulate an enum Ruby, one typical way is to utilize a module and constants. Here's an example:

In this example, we define a module called Day and assign integer values to constants representing each day of the week.

We can then use these constants in our code to represent different days:

In this code, we assign the constant Day::SUNDAY to the current_day variable. We then use an if statement to check if the current day is either Saturday or Sunday and print a corresponding message.

Why Should We Use an Enum?

Some of the benefits of using Ruby enum are as follows:

• Improved code readability: Ruby enums improve code readability by making it more readable and manageable. We don't have to memorize the names of all the potential values for an attribute when we use an enum. We may use the enum name instead, which is much more straightforward. This makes our code simpler to read and comprehend, and it also makes future modifications to our code easier.
• Type safety: Ruby enums are implemented as a class, which implies they have a specified type. This ensures that only predefined or valid values are utilized in the code.
• Data integrity: When we use an enum, we indicate that a certain attribute can only have one of a predetermined range of values. This helps in mistake prevention and guarantees that our data is always consistent.
• Improved performance: When we use an enum, the database may save the attribute values as integers rather than strings. This can increase query performance, especially when working with huge datasets.
• Code maintenance: Enums make it easier to maintain code over time by providing a central location for managing related constants.

How Enum Works?

As already mentioned above, Ruby has no built-in enum type. However, we can simulate enum-like behavior using various techniques. One common approach is to use a class with named constants to represent a Ruby enum.

To create an enum in Ruby, we define a class with a set of named constants that represent the possible values of the enum. Each constant typically corresponds to a discrete option or state that the Ruby enum can have.

For example, let's create an enum to represent the different types of colors:

In this example, we define a Colors class as an enum, and each constant (RED, BLUE, GREEN) represents a specific color type.

We can then use these constants throughout our code to represent the different color options:

In this code, we assign the constant Colors::BLUE to the favorite_color variable. Then, we use conditional statements to check which color was selected and print a corresponding message.

Using Ruby Symbols to Create Enum Constants

Enums in Ruby are flexible and can be defined with any valid Ruby data type, such as strings, symbols, or integers. It's common to use symbols as Ruby enum values, as they are lightweight and immutable. For example:

In this case, each constant represents a specific day of the week as a symbol.

Enhancing Code Readability With Enums

Enums in Ruby can also be used to enhance code readability and maintainability. By using meaningful names for the constants, we make our code more self-explanatory and easier to understand. For example, instead of using numerical values to represent states, we can define a Ruby enum:

This approach makes the code more expressive and self-documenting. Instead of using arbitrary strings or numbers to represent states, we can use the Ruby enum constants OrderState::NEW, OrderState::PENDING, and so on, which indicate the possible states an order can have.

Enums in Ruby can be useful in scenarios such as state machines, where an object can be in a limited number of predefined states. By using enums, we can ensure that the states are clearly defined and easily manageable throughout our code.

Ensuring Immutability of Enum Constants

It's important to note that the constants in the Ruby enum are still mutable by default. If we want to ensure immutability, we can freeze the Ruby enum class or the individual constants using the freeze method:

By freezing the class and constants, we prevent accidental modification of their values.

How to Implement Enums in Ruby?

Ruby provides several ways to implement enums. The two most common ways are using modules and using hashes.

Implementing Enums Using a Module in Ruby

A module is one approach to implementing enums in Ruby. The enum is declared as a module in this way, and the constants are specified as module-level constants.

In this example, OrderState is defined as a module that contains the constants for the enum. Because the constants are specified at the module level, they are available across the module. To use the Ruby enum, just refer to the constant by its name, as follows:

Implementing Enums Using a Hash in Ruby

A hash is another method for implementing enums in Ruby. The keys of the hash represent the constant names and the values represent the constant values. For example:

The ORDER_STATES enum is defined using a hash. To use the enum, we can refer to the constant by its key, like this:

It is essential to notice that the keys of the hash in this approach must be unique. Otherwise, the hash lookup will not function properly.