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
There's also a+=b. I'm not sure if there's a difference.
Todd
On 8/29/07, Ari Brown <ari@aribrown.com> 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#concata = [1, 2]
b = [3, 4]
a.concat(b) #=> [1, 2, 3, 4]
> 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.
On 8/29/07, Todd Benson <caduceass@gmail.com> wrote:
On 8/29/07, Ari Brown <ari@aribrown.com> wrote:
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
-----Original Message-----
From: Todd Benson [mailto:caduceass@gmail.com]
Sent: Wednesday, August 29, 2007 3:38 PM
To: ruby-talk ML
Subject: Re: Adding elements of one array to anotherOn 8/29/07, Ari Brown <ari@aribrown.com> 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
Logan Capaldo 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#concata = [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]
On 8/29/07, Todd Benson <caduceass@gmail.com> wrote:
On 8/29/07, Ari Brown <ari@aribrown.com> wrote:
--
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>
On Aug 30, 1:50 am, Joel VanderWerf <vj...@path.berkeley.edu> wrote:
Logan Capaldo wrote:
> On 8/29/07, Todd Benson <caduce...@gmail.com> wrote:
>> On 8/29/07, Ari Brown <a...@aribrown.com> 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.> 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]--
vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407