I agree with David. I did a simple benchmarking test and you can already 
see a difference with an array of ten integers:

irb(main):001:0> require 'benchmark'
=> true
irb(main):002:0> a = [1,2,3,4,5,6,7,8,9,10]
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):003:0> Benchmark.bm do |b|
irb(main):004:1*     b.report { new_array = a.inject([]) { |array,item| 
array << item * 100 } }
irb(main):005:1>   end
      user     system      total        real
  0.000000   0.000000   0.000000 (  0.000035)
=> true
irb(main):006:0> Benchmark.bm do |b|
irb(main):007:1*     b.report { new_array = a.map { |item| item * 100 } 
}
irb(main):008:1>   end
      user     system      total        real
  0.000000   0.000000   0.000000 (  0.000022)
=> true
irb(main):009:0>

But if you up the ante (because how often is it that we deal with an 
array of only ten elements?) you get something more like this:

irb(main):009:0> a = (0..250).map
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 
19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 
37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 
55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 
73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 
91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 
107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 
121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 
135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 
149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 
163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 
177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 
191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 
205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 
219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 
233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 
247, 248, 249, 250]
irb(main):010:0> Benchmark.bm do |b|
irb(main):011:1*     b.report { new_array = a.inject([]) { |array,item| 
array << item * 100 } }
irb(main):012:1>   end
      user     system      total        real
  0.000000   0.000000   0.000000 (  0.000442)
=> true
irb(main):013:0> Benchmark.bm do |b|
irb(main):014:1*     b.report { new_array = a.map { |item| item * 100 } 
}
irb(main):015:1>   end
      user     system      total        real
  0.000000   0.000000   0.000000 (  0.000165)
=> true
irb(main):016:0>

So you can see there's some substantial difference with map. Not to 
mention, "map" just looks cleaner and creates an array by default (where 
inject can do many different things).

You can get more background on why inject takes longer than map by 
reading the documentation:

Map: http://ruby-doc.org/core/classes/Array.html#M002212
Inject: http://ruby-doc.org/core/classes/Enumerable.html#M003160

-- Josh
http://iammrjoshua.com

David A. Black wrote:
> Hi --
> 
> On Wed, 8 Oct 2008, Bilyk, Alex wrote:
> 
>> converted_array = original_array.inject([]) {|a, line| a << (line.to_f * 100)}
> 
> I'd definitely favor map over inject for this. It's much more
> straightforward for this particular operation.
> 
> 
> David

-- 
Posted via http://www.ruby-forum.com/.