Exploring the power of the Ruby method: Flatten

Photo by Jason D on Unsplash

Exploring the power of the Ruby method: Flatten


In this article, we will explore the amazing built-in Ruby method called flatten.

We will understand its capabilities, use cases, and potential benefits. If you're a Ruby beginner or an experienced developer, understanding the flatten method can be valuable in solving problems and writing more efficient code.


We're going to start by talking about Arrays, since the main usage of the flatten method is related to Arrays.

Arrays are fundamental data structures in programming languages that allow us to organize and store collections of related data.

In its simplest form, an array is an ordered collection of elements, where each element is identified by its index.

Arrays in Ruby

In Ruby, Arrays provide a convenient way to group related data, such as a list of numbers, strings, objects, or any other data type supported.

Elements in an array are accessible by their index positions. Ruby arrays use a zero-based index system, where the first element is at index 0, the second at index 1, and so on.

Unlike some languages, Ruby arrays are not fixed in size. They can grow or shrink dynamically as needed, allowing for flexible data storage. You can add or remove elements from an array at any time, enabling dynamic data manipulation.

Array class

The Array class is an integral part of Ruby's core library, making it readily available for use in any Ruby program.

Arrays in Ruby can be easily iterated using loops or enumerable methods such as each, map, select, and reduce.

Arrays can also be easily manipulated through the use of fantastic methods, such as the flatten method.

The flatten method is a built-in Ruby method that belongs to the Array class.

The flatten method


It allows you to transform a nested array into a single-dimensional array.

By calling flatten on an array, you can obtain a new array with all the elements from the original array, but without any nested arrays. The resulting array retains the order of the elements and eliminates the nested structure.

This operation, commonly known as "flattening," removes all nested levels and arranges the elements in a linear structure.


The syntax for using the flatten method is straightforward:





The flatten method can be used in three different ways: traditional (immutable), depth-limited flattening and as a mutable method.

  • Traditional

    The traditional usage is to flatten all nested arrays, this full flattening process is reached when no arguments are provided.


In this case, a new array is going to be returned, eliminating all nested arrays and adding them to the new array, this is also called a immutable method.

  • Depth-limited

    By passing an optional argument to the flatten method, you can control the depth to which the flattening operation occurs.


In the following example, number specifies the maximum depth of flattening. If number is 1, only the top-level elements are flattened, leaving nested arrays intact.

Increasing the value of number allows you to flatten nested arrays to a deeper level.

array = [1, [[2]], [[["hi"]]], [nil, false]]
 => [1, [[2]], [[["hi"]]], [nil, false]]

Now, if you use the flatten method with the number 1 as an argument, we're going to flatten only the first level. The result of the previous array would look like the following:

array = [1, [[2]], [[["hi"]]], [nil, false]]
 => [1, [[2]], [[["hi"]]], [nil, false]] 

 => [1, [2], [["hi"]], nil, false]

  • Mutable method

    In Ruby, The exclamation mark (!) conventionally indicates that a method will modify the object it is called on, making it a destructive or mutable method.

    When you call flatten! on an array, it modifies the original array in-place by flattening any nested arrays directly within the original array itself.

    This means that the original array is mutated or changed without creating a new array.


The flatten method provides a powerful tool for manipulating nested data structures and simplifying complex algorithms

  • Data Processing:

When dealing with multi-level data structures, such as JSON or XML responses, the flatten method can transform them into a more manageable format for analysis or further processing.

  • Recursive Operations:

If you need to perform recursive operations on nested arrays, such as searching for an element or applying a specific transformation, flatten can help flatten the structure temporarily, simplifying the task.

  • User Interface Rendering:

Flattening nested arrays can be beneficial in rendering user interfaces, especially when dealing with dynamic menus or tree-like structures.


The Office GIF - The Office Happy - Discover & Share GIFs

Let's connect

Final thoughts

I hope this article helped you. Let me know if you have any questions. Your thoughts, suggestions and corrections are more than welcome.

By the way, feel free to drop your suggestions on new blog articles.

Hope to see you next time.