Velocity Reviews > Ruby > difference between the each iterator and the collect iterator?

# difference between the each iterator and the collect iterator?

vasten@gmail.com
Guest
Posts: n/a

 10-28-2005
Hi:
I am a newbie as far as Ruby is concerned. I was going through the
programming ruby book (2nd Edition), but was not able to figure out the
difference between the 2 statements:

[1, 2, 3, 4].collect{[i] puts i }
and
[1, 2, 3, 4].each{|i| puts i }

Can some guru in this group shed some light?

Thanks.

Morus Walter
Guest
Posts: n/a

 10-28-2005
In article <(E-Mail Removed) .com>,
http://www.velocityreviews.com/forums/(E-Mail Removed) writes:
> Hi:
> I am a newbie as far as Ruby is concerned. I was going through the
> programming ruby book (2nd Edition), but was not able to figure out the
> difference between the 2 statements:
>
> [1, 2, 3, 4].collect{[i] puts i }

I guess that should read [1, 2, 3, 4].collect{|i| puts i }

> and
> [1, 2, 3, 4].each{|i| puts i }
>
> Can some guru in this group shed some light?
>

run it in irb and you'll see, that your collect statement returns an
array of nils ( [nil, nil, nil, nil] ) while the each statement returns
the initial array ( [1, 2, 3, 4] )

I'm not a guru but AFAIK this is since collect returns an array created
from the return values of the block (puts returns nil) while each returns
the array it's called on.

HTH
Morus

dave.burt@gmail.com
Guest
Posts: n/a

 10-28-2005
Collect is called for the return value:

[1, 2, 3, 4].collect {|i| puts i } #=> [nil, nil, nil, nil]

Another transformation might be:

[1,2,3,4].collect {|i| i * 2 } #=> [2, 4, 6, 8]

Each just returns the original collection, but we usually call each
just as an iterator, while we call collect to get the transformed
result.

Cheers,
Dave

Eric Hodel
Guest
Posts: n/a

 10-28-2005

On Oct 27, 2005, at 8:17 PM, (E-Mail Removed) wrote:

> Hi:
> I am a newbie as far as Ruby is concerned. I was going through the
> programming ruby book (2nd Edition), but was not able to figure out
> the
> difference between the 2 statements:
>
> [1, 2, 3, 4].collect{[i] puts i }
> and
> [1, 2, 3, 4].each{|i| puts i }
>
> Can some guru in this group shed some light?

\$ ri Enumerable#collect
----------------------------------------------------- Enumerable#collect
enum.collect {| obj | block } => array
enum.map {| obj | block } => array
------------------------------------------------------------------------
Returns a new array with the results of running _block_ once for
every element in _enum_.

(1..4).collect {|i| i*i } #=> [1, 4, 9, 16]
(1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]

--
Eric Hodel - (E-Mail Removed) - http://segment7.net
FEC2 57F1 D465 EB15 5D6E 7C11 332A 551C 796C 9F04

Christophe Grandsire
Guest
Posts: n/a

 10-28-2005
Selon (E-Mail Removed) :
> Hi:
> I am a newbie as far as Ruby is concerned. I was going through the
> programming ruby book (2nd Edition), but was not able to figure out the
> difference between the 2 statements:
>
> [1, 2, 3, 4].collect{[i] puts i }
> and
> [1, 2, 3, 4].each{|i| puts i }
>
> Can some guru in this group shed some light?
>
> Thanks.
>
>

#collect applies the block on each value of the array, and *returns the
result of the expression as an array for each value*. #each applies the
block on each value of the array, but *returns the unmodified array*.
#collect is used for the effect it has on the array, #each is just used
for looping.

You can't see the difference here because you are not catching the array
returned by #collect. Usually one would do:
result = [1,2,3,4].collect{|i| do_something(i)}
while leaving #each the way you did it.
--
Christophe Grandsire.

http://rainbow.conlang.free.fr

You need a straight mind to invent a twisted conlang.