I have been googling and not getting the real usage of the map method. Here is what i tried in my console.
a = ["kevin","john","ryan"]
a.each {|i| puts i.upcase}
The above would print the values in caps.
a = ["kevin","john","ryan"]
a.map {|i| puts i.upcase}
This would also print the values in caps. So what's so special in map method? and also can anyone lead me to a good source for this topic for better understanding.
map (or collect) collects the output of the block in an array.
Your example is not that useful; the block is used only for its side-effects.
Compare with a.map { |i| i.upcase } or, more Ruby-y, a.collect(&:upcase):
> a2 = a.collect(&:upcase)
=> ['KEVIN', 'JOHN', 'RYAN']
each simply returns the value that it was called on, in this case, the original array.
Without the output of puts shown:
> a2 = a.each(&:upcase)
=> ['kevin', 'john', 'ryan']
If you collect the output of puts you'll get an array of nils:
> a2 = a.collect { |i| puts i.upcase }
=> [nil, nil, nil]
Whatever is printed by puts is the side effect of evaluating the block. Regarding the side effect of evaluating the block, each and map are the same.
Besides side effect (which some methods do not have), all Ruby methods have a return value. It is the return value that differs between each and map. The former returns the receiver, the latter returns the result of the evaluation of the block.
b = a.each{|i| puts i.upcase}
b # => ["kevin","john","ryan"]
b = a.map{|i| puts i.upcase}
b # => ["KEVIN","JOHN","RYAN"]
In the case of map, it will execute what's in the block and do the puts just like each does, but it is also collecting the return values of your puts statements into an array and returning that as a result. That result is useless to you, so there's no point in using map in that case. You'll get an array of nils. each executes what's inside the block without collecting any results.
each executes the block and just returns the original array:
> a = ["kevin","john","ryan"]
=> ["kevin", "john", "ryan"]
> a.each {|i| puts i.upcase}
KEVIN
JOHN
RYAN
=> ["kevin", "john", "ryan"]
>
map executes the block and returns the values of what's in the block in an array:
> a = ["kevin","john","ryan"]
=> ["kevin", "john", "ryan"]
> a.map {|i| puts i.upcase}
KEVIN
JOHN
RYAN
=> [nil, nil, nil]
>
Note the returned array of nil, since each puts returned a nil and map collected those. If you want to collect the upper case strings in an array, you'd use map properly like this:
> a.map {|i| i.upcase}
=> ['KEVIN', 'JOHN', 'RYAN']
Or, equivalently, a.map(&:upcase). You can also assign it to a variable:
> foo = a.map {|i| i.upcase}
=> ['KEVIN', 'JOHN', 'RYAN']
> foo
=> ['KEVIN', 'JOHN', 'RYAN']
In your example, when you want to print each value individually right away, each is better. map is useful when you want to save the new versions your elements back into an array, and use that data later in your program.
For instance, say you wanted to forget whether the names had ever been lower or uppercase. Everywhere in your program, the names will be uppercase, so you just want to convert them to uppercase now and be done with that.
a = ["kevin","john","ryan"]
a = a.map{ |n| n.upcase }
Compare that to using each – you would have to use each_with_index, actually, since you need a way to assign the new values back:
a = ["kevin","john","ryan"]
a.each_with_index do |n, i|
a[i] = n.upcase
end
This is the kind of situation map is for. Getting a new Enumerable with changed values, so that you can use the new values later.
By the way, as a shortcut, if you’re assigning a mapped variable back to itself, instead of a = a.map{}, you can use a.map!{}.
Another situation is if you wanted to print all names with an even number of letters. If you used each, here’s how it would look:
a = ["kevin","john","ryan"]
a.each do |n|
if n.size.even?
puts n.upcase
end
end
If you used map, that would give you an array back. Then you could pass that array to select, and finally use each to print the values. This separates the steps more clearly for anyone reading the code, and makes your code more modular if you want to extend it later.
a = ["kevin","john","ryan"]
a.map(&:upcase) \
.select{ |n| n.size.even? } \
.each{ |n| puts n }
The last line could also be this:
.each(&Kernel.method(:puts))
but that is probably unnecessarily confusing for such a small bit of code. What that does is convert the global puts method into a block using the & operator. Kernel holds all global methods, and .method is the way you get a variable with a method from a class. So .each(&Kernel.method(:puts)) says “get the global puts method, and turn it into a block so that puts is called with the block arguments as parameters”. But in this case, it’s clearer and simpler to write .each{ |n| puts n }.
