Adding elements of one array to another

I can’t remember who asked this a while ago, but while I was
stumbling through my Programming Ruby book, I found a nice method in
array that will instantly do the trick: Array#concat

a = [1, 2]
b = [3, 4]
a.concat(b) #=> [1, 2, 3, 4]

I can’t remember if someone already posted this solution, but if not,
here it is.

Ari
-------------------------------------------|
Nietzsche is my copilot

On 8/29/07, Ari B. [email protected] wrote:

I can’t remember who asked this a while ago, but while I was
stumbling through my Programming Ruby book, I found a nice method in
array that will instantly do the trick: Array#concat

a = [1, 2]
b = [3, 4]
a.concat(b) #=> [1, 2, 3, 4]

There’s also a+=b. I’m not sure if there’s a difference.

Todd

On 8/29/07, Todd B. [email protected] wrote:

There’s also a+=b. I’m not sure if there’s a difference.

There is. a += b --> a = a + b, and a + b will always allocate a new
array. a.concat(b) will try to use any space already allocated in a,
and only if there is not enough will it regrow a.

array that will instantly do the trick: Array#concat

a = [1, 2]
b = [3, 4]
a.concat(b) #=> [1, 2, 3, 4]

There’s also a+=b. I’m not sure if there’s a difference.

Todd

There’s a considerable performance difference:

$ cat test.rb
require ‘benchmark’

n = 50_000
Benchmark.bm do |x|
a = [1,2]
b = [3,4]
x.report { n.times { a += b } }
x.report { n.times { a.concat b } }
end
$ ruby test.rb
user system total real
5.370000 1.260000 6.630000 ( 6.664451)
0.030000 0.020000 0.050000 ( 0.051235)

As concat acts directly on self, whereas + creates a third object.

HTH,

Felix

On Aug 30, 1:50 am, Joel VanderWerf [email protected] wrote:

There’s also a+=b. I’m not sure if there’s a difference.
=> [3, 4]
irb(main):008:0> c = a
=> [1, 2]
irb(main):009:0> a.concat(b)
=> [1, 2, 3, 4]
irb(main):010:0> c
=> [1, 2, 3, 4]


vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407

You can also use OR to uniquely concat those arrays.
irb(main):003:0> [1,2] | [3,4]
=> [1, 2, 3, 4]
irb(main):004:0> [1,2] | [2,3,4]
=> [1, 2, 3, 4]
irb(main):005:0>

Logan C. wrote:

There’s also a+=b. I’m not sure if there’s a difference.

There is. a += b --> a = a + b, and a + b will always allocate a new
array. a.concat(b) will try to use any space already allocated in a,
and only if there is not enough will it regrow a.

And note that concat has side effects:

irb(main):001:0> a = [1,2]
=> [1, 2]
irb(main):002:0> b = [3,4]
=> [3, 4]
irb(main):003:0> c = a
=> [1, 2]
irb(main):004:0> a += b
=> [1, 2, 3, 4]
irb(main):005:0> c
=> [1, 2]
irb(main):006:0> a = [1,2]
=> [1, 2]
irb(main):007:0> b = [3,4]
=> [3, 4]
irb(main):008:0> c = a
=> [1, 2]
irb(main):009:0> a.concat(b)
=> [1, 2, 3, 4]
irb(main):010:0> c
=> [1, 2, 3, 4]

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs