Ruby'de tek tırnaklarla çift tırnaklar arasında bir performans artışı var mı?

Ruby'de tek tırnak yerine çift tırnak kullanmanın ruby ​​1.8 ve 1.9'da performansı anlamlı bir şekilde düşürüp düşürmediğini biliyor musunuz?

öyleyse yazarsam

question = 'my question'

daha hızlı mı

question = "my question"

Ruby'nin çift tırnaklarla karşılaştığında bir şeyin değerlendirilmesi gerekip gerekmediğini anlamaya çalıştığını ve muhtemelen bunu yaparak bazı döngüleri harcadığını hayal ediyorum.

$ ruby -v
ruby 1.9.3p0 (2011-10-30 revision 33570) [x86_64-darwin11.0.0]

$ cat benchmark_quotes.rb
# As of Ruby 1.9 Benchmark must be required
require 'benchmark'

n = 1000000
Benchmark.bm(15) do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
end

$ ruby benchmark_quotes.rb 

                      user     system      total        real
assign single     0.110000   0.000000   0.110000 (  0.116867)
assign double     0.120000   0.000000   0.120000 (  0.116761)
concat single     0.280000   0.000000   0.280000 (  0.276964)
concat double     0.270000   0.000000   0.270000 (  0.278146)

Not: Daha yeni Ruby sürümleriyle çalışmasını sağlamak için bunu güncelledim, başlığı temizledim ve karşılaştırmayı daha hızlı bir sistemde çalıştırdım.

Bu cevap bazı önemli noktaları atlamaktadır. Özellikle enterpolasyonla ilgili bu diğer cevaplara ve tek ve çift tırnak kullanırken performansta önemli bir fark olmaması nedenine bakın .

Özet: hız farkı yok; bu harika işbirlikçi Ruby stili kılavuzu tutarlı olmayı önerir. Şimdi 'string'enterpolasyon gerekmedikçe (kılavuzdaki A seçeneği) ve beğenmedikçe kullanıyorum, ancak genellikle ile daha fazla kod göreceksiniz "string".

Detaylar:

Teorik olarak, kodunuz ayrıştırıldığında bir fark yaratabilir , ancak genel olarak ayrıştırma süresini önemsememeniz (yürütme süresine kıyasla ihmal edilebilir), bu durumda önemli bir fark bulamayacaksınız.

Önemli olan alır zaman ki idam öyle olacak tam olarak aynı .

Bunu kıyaslamak sadece Ruby'nin nasıl çalıştığını anlamadığımızı gösterir. Her iki durumda da dizeler a olarak çözümlenir tSTRING_CONTENT( kaynağa bakınparse.y ). Diğer bir deyişle, CPU 'string'veya oluştururken aynı işlemlerden geçecektir "string". Tam olarak aynı bitler, aynı şekilde dönecektir. Bunun kıyaslanması, yalnızca önemli olmayan ve diğer faktörlerden (GC başlaması, vb.) Kaynaklanan farklılıkları gösterecektir; unutmayın, bu durumda herhangi bir fark olamaz! Bunun gibi mikro kıyaslamaların doğru yapılması zordur. Bunun fruityiçin iyi bir araç için mücevherime bakın .

Formun enterpolasyonu varsa "...#{...}...", bunun a tSTRING_DBEG, tSTRING_DVARiçindeki her ifade için bir demet #{...}ve bir final olarak ayrıştırıldığına dikkat edin tSTRING_DEND. Bu sadece enterpolasyon varsa, bu OP'nin konusu değil.

Eskiden her yerde çift tırnak kullanmanızı öneririm (bunu daha #{some_var}sonra eklemeyi kolaylaştırır ), ancak artık enterpolasyona ihtiyaç duymadıkça tek tırnak kullanıyorum \n, vb ... Görsel olarak seviyorum ve biraz daha açık, çünkü yok herhangi bir ifade içerip içermediğini görmek için dizeyi ayrıştırmanız gerekir.

Yine de bitiştirmeyi ve enterpolasyonu ölçen kimse olmadı:

$ ruby -v
ruby 1.8.7 (2008-08-11 patchlevel 72) [i686-darwin9.6.2]
$ cat benchmark_quotes.rb
require 'benchmark'
n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("assign interp") { n.times do; c = "a string #{'b string'}"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
end

$ ruby -w benchmark_quotes.rb 
      user     system      total        real
assign single  2.600000   1.060000   3.660000 (  3.720909)
assign double  2.590000   1.050000   3.640000 (  3.675082)
assign interp  2.620000   1.050000   3.670000 (  3.704218)
concat single  3.760000   1.080000   4.840000 (  4.888394)
concat double  3.700000   1.070000   4.770000 (  4.818794)

Özellikle, not assign interp = 2.62vs concat single = 3.76. Pastanın üzerine krema olarak, enterpolasyonu da 'a' + var + 'b'özellikle boşluklara göre daha okunaklı buluyorum .

#{some_var}Stil dizesi enterpolasyonu kullanmıyorsanız fark yok . Ancak gerçekten bunu yaparsanız performansın yükselmesini sağlarsınız.

Dan Modifiye Zetetic en Örneğin:

require 'benchmark'
n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("assign interp") { n.times do; c = "a #{n} string"; end}  
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
  x.report("concat interp") { n.times do; "a #{n} string " + "b #{n} string"; end}
end

çıktı

               user       system     total    real
assign single  0.370000   0.000000   0.370000 (  0.374599)
assign double  0.360000   0.000000   0.360000 (  0.366636)
assign interp  1.540000   0.010000   1.550000 (  1.577638)
concat single  1.100000   0.010000   1.110000 (  1.119720)
concat double  1.090000   0.000000   1.090000 (  1.116240)
concat interp  3.460000   0.020000   3.480000 (  3.535724)

Tek tırnaklar, çift tırnaklardan çok az daha hızlı olabilir çünkü lexer'ın #{}enterpolasyon işaretlerini kontrol etmesi gerekmez . Uygulamaya, vb. Bağlıdır. Bunun bir çalışma zamanı maliyeti değil, ayrıştırma zamanı maliyeti olduğunu unutmayın.

Bununla birlikte, asıl soru, çift tırnaklı dizeleri kullanmanın "performansı anlamlı bir şekilde düşürüp düşürmediğidir", cevabın kesin bir "hayır" olduğu. Performanstaki fark o kadar küçük ki, gerçek performans endişeleriyle karşılaştırıldığında tamamen önemsiz. Zamanınızı boşa harcamayın.

Elbette gerçek enterpolasyon farklı bir hikaye. 'foo'neredeyse tam olarak 1 saniye daha hızlı olacak "#{sleep 1; nil}foo".

Çift tırnak, tek tırnak işaretine göre iki kat daha fazla tuş vuruşu gerektirir. Her zaman acelem vardır. Tek tırnak kullanıyorum. :) Ve evet, bunu bir "performans kazancı" olarak görüyorum. :)

1.8.7 ve 1.9.2 karşılaştırmasını ekleyeceğimi düşündüm. Onları birkaç kez çalıştırdım. Varyans + -0.01 civarındaydı.

require 'benchmark'
n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("assign interp") { n.times do; c = "a #{n} string"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
  x.report("concat interp") { n.times do; "a #{n} string " + "b #{n} string"; end}
end

ruby 1.8.7 (2010-08-16 yama seviyesi 302) [x86_64-linux]

assign single  0.180000   0.000000   0.180000 (  0.187233)
assign double  0.180000   0.000000   0.180000 (  0.187566)
assign interp  0.880000   0.000000   0.880000 (  0.877584)
concat single  0.550000   0.020000   0.570000 (  0.567285)
concat double  0.570000   0.000000   0.570000 (  0.570644)
concat interp  1.800000   0.010000   1.810000 (  1.816955)

ruby 1.9.2p0 (2010-08-18 revizyon 29036) [x86_64-linux]

  user          system      total      real
assign single  0.140000   0.000000   0.140000 (  0.144076)
assign double  0.130000   0.000000   0.130000 (  0.142316)
assign interp  0.650000   0.000000   0.650000 (  0.656088)
concat single  0.370000   0.000000   0.370000 (  0.370663)
concat double  0.370000   0.000000   0.370000 (  0.370076)
concat interp  1.420000   0.000000   1.420000 (  1.412210)

Her iki yönde de önemli bir fark yoktur. Önemli olması için çok büyük olması gerekir.

Zamanlamayla ilgili gerçek bir sorun olduğundan emin olduğunuz zamanlar dışında, programcı sürdürülebilirliği için optimize edin.

Makine zamanının maliyeti çok çok azdır. Programcı zamanının kodu yazma ve sürdürme maliyeti çok büyüktür.

Kodun bakımının daha zor olduğu anlamına geliyorsa, binlerce çalıştırmada saniye, hatta dakika çalışma süresinden tasarruf etmenin ne faydası var?

Bununla bir stil ve sopayla seçin ama yok değil çalışma zamanı istatistiksel açıdan anlamlı olmayan milisaniye dayalı bu stili seçin.

Ben de tek alıntılanan dizelerin Ruby için daha hızlı ayrıştırılabileceğini düşündüm. Durum öyle görünmüyor.

Her neyse, sanırım yukarıdaki kriter yanlış şeyi ölçüyor. Her iki sürümün de aynı dahili dize temsillerine ayrıştırılacağı mantıklıdır, bu nedenle hangisinin daha hızlı ayrıştırılacağına dair cevabı elde etmek için performansı dizge değişkenleriyle değil, Ruby'nin dizeleri çözümleme hızını ölçmemiz gerekir.

generate.rb: 
10000.times do
  ('a'..'z').to_a.each {|v| print "#{v}='This is a test string.'\n" }
end

#Generate sample ruby code with lots of strings to parse
$ ruby generate.rb > single_q.rb
#Get the double quote version
$ tr \' \" < single_q.rb > double_q.rb

#Compare execution times
$ time ruby single_q.rb 

real    0m0.978s
user    0m0.920s
sys     0m0.048s
$ time ruby double_q.rb 

real    0m0.994s
user    0m0.940s
sys     0m0.044s

Tekrarlanan koşular pek bir fark yaratmıyor gibi görünüyor. Dizenin herhangi bir sürümünü ayrıştırmak hala hemen hemen aynı zamanı alıyor.

Uygulamaya bağlı olarak kesinlikle mümkündür, ancak yorumlayıcının tarama kısmı her karaktere yalnızca bir kez bakmalıdır. # {} Bloğu işlemek için yalnızca ek bir duruma (veya olası durumlar kümesine) ve geçişlere ihtiyaç duyacaktır.

Tablo tabanlı bir tarayıcıda, geçişi belirlemek için tek bir arama olacak ve yine de her karakter için gerçekleşecek.

Ayrıştırıcı tarayıcı çıktısını aldığında, bloktaki kodu değerlendirmesi gerekeceği zaten bilinmektedir. Dolayısıyla ek yük, her iki şekilde de ödediğiniz # {} bloğunu işlemek için tarayıcıda / ayrıştırıcıda yalnızca bellek ek yüküdür.

Bir şeyi kaçırmıyorsam (veya derleyicinin yapım detaylarını yanlış hatırlamıyorsam), ki bu da kesinlikle mümkündür :)

~ > ruby -v   
jruby 1.6.7 (ruby-1.8.7-p357) (2012-02-22 3e82bc8) (Java HotSpot(TM) 64-Bit Server VM 1.6.0_37) [darwin-x86_64-java]
~ > cat qu.rb 
require 'benchmark'

n = 1000000
Benchmark.bm do |x|
  x.report("assign single") { n.times do; c = 'a string'; end}
  x.report("assign double") { n.times do; c = "a string"; end}
  x.report("concat single") { n.times do; 'a string ' + 'b string'; end}
  x.report("concat double") { n.times do; "a string " + "b string"; end}
end
~ > ruby qu.rb
      user     system      total        real
assign single  0.186000   0.000000   0.186000 (  0.151000)
assign double  0.062000   0.000000   0.062000 (  0.062000)
concat single  0.156000   0.000000   0.156000 (  0.156000)
concat double  0.124000   0.000000   0.124000 (  0.124000)

Hepinizin kaçırdığı bir tane var.

HERE doc

bunu dene

require 'benchmark'
mark = <<EOS
a string
EOS
n = 1000000
Benchmark.bm do |x|
  x.report("assign here doc") {n.times do;  mark; end}
end

Bana verdi

`asign here doc  0.141000   0.000000   0.141000 (  0.140625)`

ve

'concat single quotes  1.813000   0.000000   1.813000 (  1.843750)'
'concat double quotes  1.812000   0.000000   1.812000 (  1.828125)'

bu yüzden kesinlikle concat ve tüm bunları yazmaktan daha iyidir.

Ruby'nin bir belge işleme dili doğrultusunda daha fazlasını öğrettiğini görmek isterim.

Ne de olsa bunu Rails, Sinatra ve koşu testlerinde gerçekten yapmıyor muyuz?

Tim Snowhite'ın cevabını değiştirdim.

require 'benchmark'
n = 1000000
attr_accessor = :a_str_single, :b_str_single, :a_str_double, :b_str_double
@a_str_single = 'a string'
@b_str_single = 'b string'
@a_str_double = "a string"
@b_str_double = "b string"
@did_print = false
def reset!
    @a_str_single = 'a string'
    @b_str_single = 'b string'
    @a_str_double = "a string"
    @b_str_double = "b string"
end
Benchmark.bm do |x|
    x.report('assign single       ') { n.times do; c = 'a string'; end}
    x.report('assign via << single') { c =''; n.times do; c << 'a string'; end}
    x.report('assign double       ') { n.times do; c = "a string"; end}
    x.report('assing interp       ') { n.times do; c = "a string #{'b string'}"; end}
    x.report('concat single       ') { n.times do; 'a string ' + 'b string'; end}
    x.report('concat double       ') { n.times do; "a string " + "b string"; end}
    x.report('concat single interp') { n.times do; "#{@a_str_single}#{@b_str_single}"; end}
    x.report('concat single <<    ') { n.times do; @a_str_single << @b_str_single; end}
    reset!
    # unless @did_print
    #   @did_print = true
    #   puts @a_str_single.length 
    #   puts " a_str_single: #{@a_str_single} , b_str_single: #{@b_str_single} !!"
    # end
    x.report('concat double interp') { n.times do; "#{@a_str_double}#{@b_str_double}"; end}
    x.report('concat double <<    ') { n.times do; @a_str_double << @b_str_double; end}
end

Sonuçlar:

jruby 1.7.4 (1.9.3p392) 2013-05-16 2390d3b on Java HotSpot(TM) 64-Bit Server VM 1.7.0_10-b18 [darwin-x86_64]
       user     system      total        real
assign single         0.220000   0.010000   0.230000 (  0.108000)
assign via << single  0.280000   0.010000   0.290000 (  0.138000)
assign double         0.050000   0.000000   0.050000 (  0.047000)
assing interp         0.100000   0.010000   0.110000 (  0.056000)
concat single         0.230000   0.010000   0.240000 (  0.159000)
concat double         0.150000   0.010000   0.160000 (  0.101000)
concat single interp  0.170000   0.000000   0.170000 (  0.121000)
concat single <<      0.100000   0.000000   0.100000 (  0.076000)
concat double interp  0.160000   0.000000   0.160000 (  0.108000)
concat double <<      0.100000   0.000000   0.100000 (  0.074000)

ruby 1.9.3p429 (2013-05-15 revision 40747) [x86_64-darwin12.4.0]
       user     system      total        real
assign single         0.100000   0.000000   0.100000 (  0.103326)
assign via << single  0.160000   0.000000   0.160000 (  0.163442)
assign double         0.100000   0.000000   0.100000 (  0.102212)
assing interp         0.110000   0.000000   0.110000 (  0.104671)
concat single         0.240000   0.000000   0.240000 (  0.242592)
concat double         0.250000   0.000000   0.250000 (  0.244666)
concat single interp  0.180000   0.000000   0.180000 (  0.182263)
concat single <<      0.120000   0.000000   0.120000 (  0.126582)
concat double interp  0.180000   0.000000   0.180000 (  0.181035)
concat double <<      0.130000   0.010000   0.140000 (  0.128731)

Aşağıdakileri denedim:

def measure(t)
  single_measures = []
  double_measures = []
  double_quoted_string = ""
  single_quoted_string = ''
  single_quoted = 0
  double_quoted = 0

  t.times do |i|
    t1 = Time.now
    single_quoted_string << 'a'
    t1 = Time.now - t1
    single_measures << t1

    t2 = Time.now
    double_quoted_string << "a"
    t2 = Time.now - t2
    double_measures << t2

    if t1 > t2 
      single_quoted += 1
    else
      double_quoted += 1
    end
  end
  puts "Single quoted did took longer in #{((single_quoted.to_f/t.to_f) * 100).round(2)} percent of the cases"
  puts "Double quoted did took longer in #{((double_quoted.to_f/t.to_f) * 100).round(2)} percent of the cases"

  single_measures_avg = single_measures.inject{ |sum, el| sum + el }.to_f / t
  double_measures_avg = double_measures.inject{ |sum, el| sum + el }.to_f / t
  puts "Single did took an average of #{single_measures_avg} seconds"
  puts "Double did took an average of #{double_measures_avg} seconds"
    puts "\n"
end
both = 10.times do |i|
  measure(1000000)
end

Ve bunlar çıktılar:

1.

Single quoted did took longer in 32.33 percent of the cases
Double quoted did took longer in 67.67 percent of the cases
Single did took an average of 5.032084099982639e-07 seconds
Double did took an average of 5.171539549983464e-07 seconds

2.

Single quoted did took longer in 26.9 percent of the cases
Double quoted did took longer in 73.1 percent of the cases
Single did took an average of 4.998066229983696e-07 seconds
Double did took an average of 5.223457359986066e-07 seconds

3.

Single quoted did took longer in 26.44 percent of the cases
Double quoted did took longer in 73.56 percent of the cases
Single did took an average of 4.97640888998877e-07 seconds
Double did took an average of 5.132918459987151e-07 seconds

4.

Single quoted did took longer in 26.57 percent of the cases
Double quoted did took longer in 73.43 percent of the cases
Single did took an average of 5.017136069985988e-07 seconds
Double did took an average of 5.004514459988143e-07 seconds

5.

Single quoted did took longer in 26.03 percent of the cases
Double quoted did took longer in 73.97 percent of the cases
Single did took an average of 5.059069689983285e-07 seconds
Double did took an average of 5.028807639983705e-07 seconds

6.

Single quoted did took longer in 25.78 percent of the cases
Double quoted did took longer in 74.22 percent of the cases
Single did took an average of 5.107472039991399e-07 seconds
Double did took an average of 5.216212339990241e-07 seconds

7.

Single quoted did took longer in 26.48 percent of the cases
Double quoted did took longer in 73.52 percent of the cases
Single did took an average of 5.082368429989468e-07 seconds
Double did took an average of 5.076817109989933e-07 seconds

8.

Single quoted did took longer in 25.97 percent of the cases
Double quoted did took longer in 74.03 percent of the cases
Single did took an average of 5.077162969990005e-07 seconds
Double did took an average of 5.108381859991112e-07 seconds

9.

Single quoted did took longer in 26.28 percent of the cases
Double quoted did took longer in 73.72 percent of the cases
Single did took an average of 5.148080479983138e-07 seconds
Double did took an average of 5.165793929982176e-07 seconds

10.

Single quoted did took longer in 25.03 percent of the cases
Double quoted did took longer in 74.97 percent of the cases
Single did took an average of 5.227828659989748e-07 seconds
Double did took an average of 5.218296609988378e-07 seconds

Hiç hata yapmadıysam, çoğu durumda tek alıntı biraz daha hızlı olsa da, bana göre her ikisi de yaklaşık olarak aynı süreyi alıyor.