Ho allora ripetuto il benchmark delle stringhe aggiungendo altri due metodi di concatenzione, ossia

%(#{stringa1} #{stringa2})

e

a = []; a << stringa1; a << stringa2; a.join(" ")

e facendo la prova anche con stringhe lunghe, da 500 caratteri l'una.

Innanzitutto ho notato che ripetendo un po' di volte il test << #{} e %() risultano praticamente identici. Qualche volta vince uno e qualche volta vince un altro.

Per stringhe di un carattere il metodo dell'array è un po' più lento mentre per stringhe lunghe si pareggia agli altri. Per stringhe lunghe + diventa estremamente più lento di tutti gli altri metodi.

Questo è il risultato di un'instanza del test, sperando che la formattazione sopravviva al post.

user system total real
Concat 1.000.000:
+ 2.370000 0.130000 2.500000 ( 2.532409)
<< 2.310000 0.150000 2.460000 ( 2.493730)
#{} 2.410000 0.180000 2.590000 ( 2.582961)
%() 2.420000 0.150000 2.570000 ( 2.588971)
Array 4.250000 0.170000 4.420000 ( 4.445646)
big + 14.360000 0.240000 14.600000 ( 14.635854)
big #{} 6.210000 0.170000 6.380000 ( 6.401311)
big %() 6.330000 0.180000 6.510000 ( 6.522818)
big Array 6.500000 0.440000 6.940000 ( 6.956503)

Portando le stringhe da concatenare da 500 a 1000 caratteri la concatenazione con Array rimane al livello degli altri. A 2000 inizia ad essere leggermente più veloce e a 4000 è decisamente più rapida.

big + 86.840000 0.270000 87.110000 ( 87.336664)
big #{} 30.950000 0.190000 31.140000 ( 31.217629)
big %() 31.100000 0.270000 31.370000 ( 31.472801)
big Array 26.140000 6.470000 32.610000 ( 32.672105)

I test sono stati eseguiti su un Intel Core Duo 2 T7200 (dual core 2.0 GHz), ruby 1.8.7 (2008-08-11 patchlevel 72) [x86_64-linux] 3.4 GB RAM.

Il codice in più è

t1 = b.report("big +") do
sa="%04000d" % 1; sb="%04000d" % 2; sc="%04000d" % 3;
sd="%04000d" % 4; se="%04000d" % 5
n.times { sa + " " + sb + " " + sc + " " + sd + " " + se; sb + " " + sc }
end
t1 += b.report("big \#\{\}") do
sa="%04000d" % 1; sb="%04000d" % 2; sc="%04000d" % 3;
sd="%04000d" % 4; se="%04000d" % 5
n.times { "#{sa} #{sb} #{sc} #{sd} #{se}"; "#{sb} #{sc}" }
end
t1 += b.report("big \%\(\)") do
sa="%04000d" % 1; sb="%04000d" % 2; sc="%04000d" % 3;
sd="%04000d" % 4; se="%04000d" % 5
n.times { %(#{sa} #{sb} #{sc} #{sd} #{se}); %(#{sb} #{sc}) }
end
t1 += b.report("big Array") do
sa="%04000d" % 1; sb="%04000d" % 2; sc="%04000d" % 3;
sd="%04000d" % 4; se="%04000d" % 5
n.times { a = []; a << sa; a << sb; a << sc; a << sd; a << se; a.join(" ");
a = []; a << sb; a << sc; a.join(" ") }
end

Il test big << manca perché l'operatore << modifica il suo argomento di sinistra e non avevo voglia di includere dei literal da 4000 caratteri nel programma.