Dev Bootcamp

A Tear-Down of the Enumerable map Method

What does map do?

Here is the map method:

map { |item| block }

And here is what it returns:

#=> new_array

Essentially, map is an Enumerable method that runs a code block once for each element of the object and returns a new array of of the results of the block.

If you’re just starting to learn programming, you may be asking, “what does this really mean?” Let me try to break it down.

Enumerable provides collection classes with several searching and sorting methods. Arrays and Hashes are two examples of classes that have Enumerable properties, and therefore, can use Enumerable methods. map is one of those Enumerable methods.

What does it really mean? I work out.

Here is an example senario and code:

benched_weights = [90,140,160,120,165] { |wt| wt + 45 } 
#=> [135,185,205,165,210]

One the first line of the code, you’re keeping track of how much weight you are putting onto the barbell when you bench on chest days. You are storing this in an array called benched_weights. On the first day, you put 90lbs on the bar. On the second day, you put 140lbs on the bar. Third day, 160lbs. You had a bad day on the fourth day and only put 120 lbs on the bar. And so forth…

Now, let’s say, you want to see how much weight you are benching in total, including the weight of the barbell itself. The barbell weighs 45lbs. On the second line if the code, you used the map method. You assigned the variable wt in between the pipes as a placeholder for each element in the Array and then a code block that says wt + 45. What the code is doing here is going through each weight that you logged and adding 45 to it.

During the first pass, wt is equal to the first element of the array, which is 90, and then returns wt + 45, which is 135. After the first pass, it loops to the second element, which is 140, and then returns wt + 45, which is 185. Third pass, the wt is 160 and returns wt + 45, which is 205, and so on until it goes through each element in the given array.

When all is said and done, the map method will return all of the values given by the code block in the form of a new Array, which is shown on the third line.

As a side note, you can also use Enumerable#collect interchangeably with #map. They are completely synonymous (i.e. benched_weights.collect { |wt| wt + 45 }.

How does this compare to “each”?

Many beginner’s Ruby books and courses use the each method as an introduction to teach iterators and code blocks. If you are familiar with the Array each method, you’ll notice that the Enumerable map method is very similar to it. Both methods calls the code block once for each element in the object. The key difference between the two methods stop here.

After the each method runs the block for each element, it stops and then returns nil. The map method, on the other hand, stores the results that the code block return for each element into a new array and then return the new array after the method is finished. Using the map method can save you several lines of code if you’re making the each method store the results in a new array. It can also be useful in many other ways.

If you have any questions or what further clarification, please leave a message in the comment box below.

This blog has been initially published on

Dev Bootcamp

What Are The Differences Between Ruby Arrays And Hashes, And When To Use Each?


This is a pretty long blog, so I will seperate this post into three parts:

  1. Arrays
  2. Hashes
  3. Summary


1a. What is an Array?

Do you find yourself assigning way too many variables to different values? Arrays are the solution to that.

A array is a list of objects (strings, numbers, booleans, another array, etc.). Every slot in an array acts like a variable.



1b. How do I create an Array?

One way to create an array is to put the values you want to store in a set of brackets, like this:

my_array = ['object_1','object_2','object_3']

Another way is to use the new method:

my_array = #no arguments, creates an empty array
my_array = #one argument, creates an array with the specified number of values, which will be nil. In this example, it will create an array of 3 nil values: `[nil, nil, nil]`
my_array =, 'object') #two arguments, creates a array with the specified number of values with the specified value. In this example, it will create: `['object', 'object', 'object']`

1c. How do I access elements in an Array?

Arrays are ordered lists that use integers as an index. Each element in an Array is stored in a specific order and can be retrieved by calling the number it is associated with by using the #[] method. One thing to keep in mind, though, is that the ordered list starts at 0. The first element in an Array is at position 0, the second element is at position 1, etc.


my_array = ['I','am',24]
my_array[0] #returns 'I'
my_array[1] #returns 'am'
my_array[2] #returns 24

You can also do the same thing using the at method.

Example: #returns 'am'

1d. What are some other Array methods?


2a. What are Hashes?

A hash is an unordered list of unique keys and their values. They are similar to Arrays. One key difference is that while an Array associates its list of values with an index of integers, a Hash allows you to assign any object type to the values as a key. So a Hash stores the key and the value in the list; kind of like a dictionary.

2b. How do I create a Hash?

One way to create hash is to put the keys and values you want to store in a set of curly brackets, like this:

my_hash = { 'gender' => 'male',
'legal' => true,
'height' => 62

Noticed how I used => to assign a key to a value and commas to separate each pair of key and value. Each key MUST be unique. There can NOT be a duplicate key in the same hash.

Another key difference is that hashes allows an alternative syntax, called symbols, as keys (marked by : in front of the name):

my_hash = { :gender => 'male',
:legal => true,
:height => 62,

Or (more conveniently):

my_hash = { gender: 'male',
legal: true,
height: 62

A second way to add a hash is:

my_hash =
my_hash['gender'] = 'male'
my_hash['legal'] = true
my_hash['height'] = 62

2c. How do I access elements in a Hash?

Hash elements can be accessed in a similar fashion as Array elements, but instead of calling for the integer index, you would call for the key.


my_hash['gender'] #returns 'male'
my_hash['legal'] #returns true

Default Hash Value:

Another key difference between Arrays and Hashes is that Hashes allow you to store a default value if the key is not assigned to any value, like this:

my_hash ='default value')
my_hash['gender'] = 'male'
puts my_hash['gender'] #'male'
puts my_hash['legal'] #'default value'
puts my_hash['height'] #'default value'

2d. What are some other Hash methods?


3a. Key Differences

Whew, that was quite a bit of information!

Here’s a little table that summarizes the key differences between Arrays and Hashes:

Arrays Hashes
Create new: my_array = []
my_array =
my_hash = {}
my_hash =
Accessing elements: Via an index of integers, starting at 0 Via assigned unique keys, which can be any object
Other unique factors: Can use symbols as keys
Can set a default value for non-assigned keys

3b. Still not sure what the differences are or when to use what?

Here is a good summary I found:

  • An array is an ordered list of things: a, b, c, d
  • A hash is a collection of key/value pairs: john has a peugeot, bob has a renault, adam has a ford
  • Source: Stack Overflow

If you need to store a collection of things, use an Array. If you need to store a collection of things that are associated with something else, use a Hash.

Feel free to reach out to me if you still have any questions!

This blog has been initially published on