Ruby Enumerable

Ruby Enumerable Module

Ruby Enumerable is a module in the Ruby programming language that provides a collection of methods for traversing, filtering, and manipulating collections (arrays, hashes, and more) of objects. The Enumerable module is included in many core classes in Ruby, such as Array, Hash, and Range, which allows these classes to use the methods provided by Enumerable.

The each, map, select, find, reduce, and many other methods are part of the standard interface for working with collections defined by the Enumerable module. You can do different activities for a group of items using Enumerable. Some of these actions include going through each item, changing them, picking out certain items that meet certain conditions, and turning a group of items into a single item.

As numerous actions may be performed with just a few lines of code, using Ruby Enumerables can help you to make your code simpler and more expressive. Furthermore, Ruby Enumerable's methods are frequently performance-optimized, so even when working with enormous collections, you can count on them to be effective.

What is an Enumerator?

An Enumerator in Ruby is like a tool that helps you go through a bunch of items one by one. Let's say you have a list of employees, and you want to look at the details of each of them to see how they are performing. You could review the list by seeing one employee's details at a time and remember which ones you've already looked at. But if the list is large, it could take a long time, and it's easy to forget which ones you've already seen.

An Enumerator is like a little helper that keeps track of which employee details you're looking at and which ones you've already looked at. So instead of remembering where you left off each time, you can keep going through the list with the help of the Enumerator. In programming, you might use an Enumerator to go through a list of names or look at each character in a sentence individually. It's a way to make it easier to work with many items without getting lost or confused. An enumerator is logically equivalent to a "lazy iterator" that generates a sequence of values on-demand when requested rather than generating all values upfront, like an array or a hash.

Why is there a Need for Enumerable?

Before the invention of Ruby Enumerable, writing code to manipulate collections of items in Ruby was much more complex. Imagine you have a big list of things you need to sort through and perform different actions on. Without Enumerables, you'd have to write a lot of code to keep track of which item you're on and what you want to do with it. This process could be time-consuming and confusing, especially for more extensive collections.

For example, let's say you have a list of 1000 numbers and want to find all the even ones. Without Ruby Enumerable, you would have to write a loop that goes through each number, checks if it's even, and then adds it to a new list if it is. Then you'd have to go through that new list again to perform other actions on the even numbers. This could quickly become a messy and complicated process.

Fortunately, Ruby Enumerable makes working with collections much simpler in the following manner:

• Ruby Enumerables provide built-in methods that allow you to iterate through collections and perform actions on each item without having to write a lot of extra code.
• With Ruby Enumerable, you can filter collections based on certain criteria, transform them into new collections, or reduce them down to a single value.
• Ruby Enumerables offer a strong abstraction that helps you write efficient, easier-to-understand code. This is because you don't have to keep track of as many details yourself.
• Ruby Enumerable is a powerful tool that makes working with collections in Ruby much simpler and more intuitive.
• Enumerators can be particularly useful when dealing with large or infinite collections of data, where generating all values upfront would be impractical or impossible. By generating values on-demand, an Enumerator allows you to control the pace of iteration and handle each value in a custom way.

The Each Method in Ruby

Each method is a core feature of the Ruby programming language. It allows you to iterate over a collection and execute code blocks for each element in that collection. It's an important tool for working with arrays and hashes in Ruby. It's also commonly used with other collection-like objects.

Syntax

The syntax of each method is straightforward. It's called on an enumerable object, and a block of code is passed to it. The following is the syntax of the for-each method:

Parameter

Each method requires a block of code to be executed for each element in the collection. The block has one variable which is the element from your array that the block is currently iterating over.

Return value

After each iteration, each method returns the initial collection. This means that the return value is the same as the receiver of the method call.

Examples

The following examples demonstrate how to use the each method in Ruby.

Example 1: Iterating over an array

Code:

Output:

Example 2: Iterating over a hash

Code:

Output:

The each_with_index method in Ruby

The each_with_index method is a built-in Ruby method that is used to iterate over an array and retrieve both the element and its index within the array. This method is quite useful for operations that require accessing both the element and its index. For example, it is useful for printing out a numbered list of items.

Syntax

The syntax for using each_with_index is as follows:

In this syntax, array refers to the array that we want to iterate over, element is the current element being processed, and index is the index of the current element.

Parameters

The each_with_index method takes a block of code as input. This block must take two arguments: element and index. Element is the current element of the array in the iteration and index is the index of that element.

Return value

The return value of each_with_index is the value of the given object.

Examples

The following examples demonstrate how to use the each_with_index method in Ruby.

Code:

Output:

The map method in Ruby

The map method is a built-in method in Ruby that is used to transform elements in an array by applying a specific operation to each element. This method creates a new array that contains the transformed elements.

Syntax

The syntax for using the map method is as follows:

In the above syntax, array refers to the array that we want to transform, element is the current element being processed, and the code inside the block specifies the operation that will be applied to each element.

Parameter

The map method takes only one parameter, i.e., the code block that will be executed for each element in the array. This block must take one argument which is the element of the array.

Return value

The return value of the map is a new array that contains the transformed elements.

Examples

The following examples demonstrate how to use the map method in Ruby.

Code:

Output:

The select method in Ruby

The select method is a built-in method in Ruby that is used to filter elements in an array based on a specific condition. This method creates a new array that contains only the elements that meet the condition.

Syntax

The syntax for using the select method is as follows:

In the above syntax, array refers to the array that we want to filter, and element is the current element being processed. The code block specifies the condition that will be evaluated for each element.

Parameter

The select method takes only one parameter, i.e., the code block that will be executed for each element in the array. This block must evaluate to either true or false.

Return value

The return value of select is a new array that contains only the elements that meet the condition.

Examples

The following example demonstrates how to use the select method in Ruby.

Code:

Output:

In the above example, the select method is used to filter an array of numbers and extract the numbers that are not divisible by 10.

The reduce method in Ruby

The reduce method is a built-in method in Ruby that is used to aggregate the elements of an array into a single value. It applies a code block to each element of the array and accumulates the result into a single value.

Syntax

The syntax for using the reduce method is as follows:

Parameter

The reduce method takes the following two parameters as input:

• An optional initial value of the accumulator. The first element of the array is used as the initial value if the initial value is not specified.
• A code block that will be executed for each element in the array.
  • This block must take two parameters: the current value of the accumulator and the current element being processed.
  • It must evaluate a new value of the accumulator.

Return value

The return value of reduce is the final value of the accumulator after all elements in the array have been processed.

Examples

The following examples demonstrate how to use the reduce method in Ruby.

Code:

Output:

Calling enumerable with the bang method in Ruby

When you use an Enumerable method in Ruby, it will return a new value by default rather than changing the original collection. This means that when you operate on a collection using an Enumerable method, the original collection will remain unchanged, and a new collection will be returned as a result.

For example, if you have an array of numbers and you want to double each number in the array, you can use the map method like this:

In this case, twos_multiple will be a new array containing the doubled values of the original numbers array, but the original numbers array will remain unchanged.

However, there is a way to modify the original collection using Enumerable methods, and that is by using the bang operator method. A bang method is simply an Enumerable method that has a bang operator (!) at the end of its name. When you call an Enumerable method with a bang operator, it overrides the default behavior of returning a new value and instead modifies the original collection in place.

For example, if you want to double each number in the array in-place rather than returning a new copy, you can use the map method with the bang operator as follows:

As we can notice from the above example, calling the map! modifies the original numbers array in place while calling the map returned a new array. Using bang operators with caution is important because they modify the original collection and can have unintended side effects. However, when used appropriately, they can be useful for modifying collections in place.