Apakah ada keuntungan kinerja dalam menggunakan tanda kutip tunggal vs tanda kutip ganda di ruby?

Apakah Anda tahu jika menggunakan tanda kutip ganda sebagai ganti tanda kutip tunggal di ruby ​​mengurangi kinerja dengan cara apa pun yang berarti di ruby ​​1.8 dan 1.9.

jadi jika saya mengetik

question = 'my question'

apakah lebih cepat dari

question = "my question"

Saya membayangkan ruby ​​mencoba mencari tahu apakah sesuatu perlu dievaluasi ketika bertemu dengan tanda kutip ganda dan mungkin menghabiskan beberapa siklus melakukan hal itu.

$ 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)

Catatan: Saya telah memperbarui ini untuk membuatnya berfungsi dengan versi Ruby yang lebih baru, dan membersihkan header, dan menjalankan patokan pada sistem yang lebih cepat.

Jawaban ini menghilangkan beberapa poin penting. Lihat terutama jawaban-jawaban lain mengenai interpolasi ini dan alasannya tidak ada perbedaan kinerja yang signifikan ketika menggunakan tanda kutip tunggal vs ganda.

Ringkasan: tidak ada perbedaan kecepatan; panduan gaya Ruby kolaboratif yang hebat ini merekomendasikan untuk konsisten. Saya sekarang menggunakan 'string'kecuali interpolasi diperlukan (opsi A dalam panduan ini) dan menyukainya, tetapi Anda biasanya akan melihat lebih banyak kode "string".

Detail:

Secara teoritis, ini dapat membuat perbedaan ketika kode Anda diurai , tetapi tidak hanya jika Anda tidak peduli tentang waktu parse secara umum (diabaikan dibandingkan dengan waktu eksekusi), Anda tidak akan dapat menemukan perbedaan yang signifikan dalam kasus ini.

Yang penting adalah bahwa ketika dieksekusi akan persis sama .

Pembandingan ini hanya menunjukkan kurangnya pemahaman tentang cara kerja Ruby. Dalam kedua kasus, string akan diurai menjadi tSTRING_CONTENT(lihat sumber diparse.y ). Dengan kata lain, CPU akan melalui operasi yang sama persis saat membuat 'string'atau "string". Bit yang sama persis akan membalik dengan cara yang sama persis. Benchmarking ini hanya akan menunjukkan perbedaan yang tidak signifikan dan karena faktor lain (GC menendang, dll.); ingat, tidak ada perbedaan dalam hal ini! Tolok ukur mikro seperti ini sulit untuk diperbaiki. Lihat permata saya fruityuntuk alat yang layak untuk ini.

Perhatikan bahwa jika ada interpolasi formulir "...#{...}...", ini akan diuraikan ke a tSTRING_DBEG, banyak tSTRING_DVARuntuk setiap ekspresi #{...}dan final tSTRING_DEND. Itu hanya jika ada interpolasi, yang bukan tentang OP.

Saya dulu menyarankan Anda menggunakan tanda kutip ganda di mana-mana (membuatnya lebih mudah untuk benar-benar menambahkannya #{some_var}nanti), tetapi saya sekarang menggunakan tanda kutip tunggal kecuali saya perlu interpolasi \n,, dll. Saya suka secara visual dan itu sedikit lebih eksplisit, karena tidak ada perlu mengurai string untuk melihat apakah mengandung ekspresi apa pun.

Namun tidak ada yang mengukur konkatasi vs interpolasi:

$ 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)

Secara khusus, perhatikan assign interp = 2.62vs concat single = 3.76. Sebagai lapisan gula pada kue, saya juga menemukan interpolasi lebih mudah dibaca daripada 'a' + var + 'b'terutama berkaitan dengan spasi.

Tidak ada perbedaan - kecuali jika Anda menggunakan #{some_var}interpolasi string gaya. Tetapi Anda hanya mendapatkan kinerja yang baik jika Anda benar-benar melakukannya.

Dimodifikasi dari contoh Zetetic :

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

keluaran

               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)

Kutipan tunggal dapat menjadi sedikit lebih cepat daripada tanda kutip ganda karena lexer tidak harus memeriksa #{}penanda interpolasi. Bergantung pada implementasi, dll. Perhatikan bahwa ini adalah biaya waktu parse, bukan biaya waktu berjalan.

Yang mengatakan, pertanyaan sebenarnya adalah apakah menggunakan string dikutip ganda "menurunkan kinerja dengan cara yang berarti", yang jawabannya adalah "tidak" yang menentukan. Perbedaan kinerja sangat kecil sehingga sama sekali tidak signifikan dibandingkan dengan masalah kinerja nyata. Jangan buang waktu Anda.

Interpolasi yang sebenarnya adalah cerita yang berbeda, tentu saja. 'foo'akan hampir tepat 1 detik lebih cepat daripada "#{sleep 1; nil}foo".

Kutipan ganda membutuhkan dua kali lebih banyak serangan kunci untuk diketik daripada kutipan tunggal. Saya selalu terburu-buru. Saya menggunakan tanda kutip tunggal. :) Dan ya, saya menganggap itu "peningkatan kinerja". :)

Saya pikir saya akan menambahkan perbandingan 1,8.7 dan 1.9.2. Saya berlari mereka beberapa kali. Varians sekitar + -0,01.

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 patchlevel 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 (revisi 2010-08-18 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)

Tidak ada perbedaan signifikan di kedua arah. Itu harus besar untuk itu penting.

Kecuali untuk saat-saat ketika Anda yakin ada masalah aktual dengan pengaturan waktu, optimalkan untuk pemeliharaan programmer.

Biaya waktu alat berat sangat kecil. Biaya waktu programmer untuk menulis kode dan memeliharanya sangat besar.

Apa gunanya pengoptimalan untuk menghemat detik, bahkan menit runtime selama ribuan berjalan jika itu berarti bahwa kode lebih sulit dipertahankan?

Memilih dengan gaya dan tongkat dengan itu tetapi tidak memilih gaya berdasarkan milidetik statistik tidak signifikan dari runtime.

Saya juga berpikir bahwa string yang dikutip tunggal mungkin lebih cepat untuk diuraikan untuk Ruby. Sepertinya tidak demikian.

Bagaimanapun, saya pikir tolok ukur di atas mengukur hal yang salah. Masuk akal bahwa kedua versi akan diuraikan ke dalam representasi string internal yang sama sehingga untuk mendapatkan jawaban yang lebih cepat diurai, kita tidak seharusnya mengukur kinerja dengan variabel string, melainkan kecepatan string penguraian Ruby.

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

Menjalankan berulang tampaknya tidak membuat banyak perbedaan. Masih membutuhkan waktu yang hampir bersamaan untuk mengurai kedua versi string.

Ini tentu mungkin tergantung pada implementasinya, tetapi bagian pemindaian juru bahasa hanya boleh melihat setiap karakter sekali saja. Ini akan membutuhkan hanya status tambahan (atau kemungkinan serangkaian kondisi) dan transisi untuk menangani blok # {}.

Dalam pemindai berbasis tabel, itu akan menjadi pencarian tunggal untuk menentukan transisi, dan akan terjadi untuk setiap karakter.

Ketika parser mendapatkan hasil pemindai, sudah diketahui bahwa ia harus eval kode di blok. Jadi overhead hanya benar-benar overhead memori dalam pemindai / pengurai untuk menangani blok # {}, yang Anda bayar dengan cara apa pun.

Kecuali jika saya melewatkan sesuatu (atau salah mengingat detail konstruksi kompiler), yang tentunya juga mungkin :)

~ > 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)

Ada satu yang kalian semua lewatkan.

DI SINI doc

coba ini

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

Itu memberi saya

`asign here doc  0.141000   0.000000   0.141000 (  0.140625)`

dan

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

jadi tentu saja lebih baik daripada concat dan menulis semua put itu.

Saya ingin melihat Ruby mengajar lebih banyak di sepanjang garis bahasa manipulasi dokumen.

Lagipula, bukankah kita benar-benar melakukannya di Rails, Sinatra, dan menjalankan tes?

Saya mengubah jawaban Tim Snowhite.

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

Hasil:

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)

Saya mencoba yang berikut ini:

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

Dan ini adalah outputnya:

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

Jika saya tidak membuat kesalahan, menurut saya keduanya membutuhkan waktu yang kira-kira sama, walaupun single quotes sedikit lebih cepat dalam kebanyakan kasus.