Adding elements of one array to another

Ruby
1

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

2

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

3

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.

4

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

5

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>

6

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]