Adding elements of one array to another

[Ari Brown]

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

 

[Todd Benson]

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

 

[Logan Capaldo]

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.

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.

 

[Joel VanderWerf]

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.

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]

 

[Elad Meidar]

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.

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]

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>