blocks|key|1391795|text|根据实现的不同，这当然是可能的，但是解释器的扫描部分应该只查看每个字符一次。它只需要一个额外的状态(或可能的状态集)和转换来处理#{}块。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1391796|在基于表的扫描器中，这将是一个单一的查找来确定转换，并且无论如何都会发生在每个字符上。|1391797|当解析器获得扫描器输出时，就已经知道它必须对块中的代码求值。因此，开销实际上只是扫描器/解析器中处理#{}块的内存开销，无论哪种方式，您都要为此买单。|1391798|除非我遗漏了什么(或者记错了编译器构造细节)，这当然也是有可能的:)|1391799|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

It's certainly possible depending on the implementation, but the scanning portion of the interpreter should only look at each character once. It will need just an additional state (or possible set of states) and transitions to handle #{} blocks. In a table based scanner thats going to be a single lookup to determine transition, and will be happening for each character anyways. When the parser gets the scanner output, it's already known that it will have to eval code in the block. So the overhead is only really the memory overhead in the scanner/parser to handle the #{} block, which you pay for either way. 
Unless I'm missing something (or misremembering compiler construction details), which is also certainly possible :)

blocks|key|1176348|text|$+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+%7Cx%7C
++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+'+%2B+'b+string';+end}
++x.report("concat+double")+{+n.times+do;+"a+string+"+%2B+"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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1176349|注意:我已经对其进行了更新，使其适用于较新的Ruby版本，并清理了头文件，并在速度更快的系统上运行基准测试。|unstyled|1176350|这个答案省略了一些关键点。请特别参阅这些关于interpolation的其他答案，以及使用单引号和双引号时使用there+is+no+significant+difference+in+performance的原因。|offset|length|1176351|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2121512/17410|1|https://stackoverflow.com/a/1836838/17410^0|0|0|M|D|0|1J|1D|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@]|9|@$I|X|J|Y|1|Z]|$I|10|J|11|1|12]]|A|$]]|$1|K|3|-4|5|F|7|13|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

<pre><code>$ 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)
</code></pre>

Note: I've updated this to make it work with newer Ruby versions, and cleaned up the header, and run the benchmark on a faster system. 

This answer omits some key points. See especially these other answers concerning <a href="https://stackoverflow.com/a/2121512/17410">interpolation</a> and the reason <a href="https://stackoverflow.com/a/1836838/17410">there is no significant difference in performance</a> when using single vs. double quotes.

blocks|key|1176413|text|没有区别--除非你使用的是#{some_var}风格的字符串插值。但是只有当你真的这么做的时候，你才能得到性能上的提升。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1176414|由Zetetic's示例修改而来：|1176415|require+'benchmark'
n+=+1000000
Benchmark.bm+do+%7Cx%7C
++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+'+%2B+'b+string';+end}
++x.report("concat+double")+{+n.times+do;+"a+string+"+%2B+"b+string";+end}
++x.report("concat+interp")+{+n.times+do;+"a+#{n}+string+"+%2B+"b+#{n}+string";+end}
end|code-block|syntax|javascript|1176416|输出|1176417|+++++++++++++++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)|1176418|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1836467/is-there-a-performance-gain-in-using-single-quotes-vs-double-quotes-in-ruby/1837604#1837604^0|D|B|0|1|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|I|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|17|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

No difference - unless you're using <code>#{some_var}</code> style string interpolation. But you only get the performance hit if you actually do that.

Modified from <a href="https://stackoverflow.com/questions/1836467/is-there-a-performance-gain-in-using-single-quotes-vs-double-quotes-in-ruby/1837604#1837604">Zetetic's</a> example:

<pre><code>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
</code></pre>

output

<pre><code> 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)
</code></pre>

blocks|key|1392014|text|然而，没有人碰巧测量拼接和插值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1392015|$+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+%7Cx%7C
++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+'+%2B+'b+string';+end}
++x.report("concat+double")+{+n.times+do;+"a+string+"+%2B+"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)|code-block|syntax|javascript|1392016|具体来说，请注意assign+interp+=+2.62与concat+single+=+3.76。锦上添花的是，我还发现插值比'a'+%2B+var+%2B+'b'更具可读性，特别是在空格方面。|offset|length|style|CODE|1392017|entityMap^0|0|0|8|K|T|K|1S|F|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

No one happened to measure concatenation vs interpolation though:

<pre><code>$ 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)
</code></pre>

Specifically, note <code>assign interp = 2.62</code> vs <code>concat single = 3.76</code>.
As icing on the cake, I also find interpolation to be more readable than <code>'a' + var + 'b'</code> especially with regard to spaces.

blocks|key|1176594|text|单引号可以比双引号稍微快一些，因为词法分析器不必检查#{}插值标记。请注意，这是一个解析时开销，而不是运行时开销。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1176595|也就是说，实际的问题是使用双引号字符串是否“以任何有意义的方式降低了性能”，答案是决定性的“否”。性能上的差异是如此之小，以至于与任何真正的性能问题相比都是微不足道的。不要浪费你的时间。|1176596|当然，实际的插值是另一回事。'foo'几乎恰好比"#{sleep+1;+nil}foo"快1秒。|1176597|entityMap^0|Q|3|0|0|E|5|O|K|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

Single quotes can be very slightly faster than double quotes because the lexer doesn't have to check for <code>#{}</code> interpolation markers. Depending on implementation, etc. Note that this is a parse-time cost, not a run-time cost.

That said, the actual question was whether using double quoted strings "decreases performance in any meaningful way", to which the answer is a decisive "no". The difference in performance is so incredibly small that it is completely insignificant compared to any real performance concerns. Don't waste your time.

Actual interpolation is a different story, of course. <code>'foo'</code> will be almost exactly 1 second faster than <code>"#{sleep 1; nil}foo"</code>.

blocks|key|1176601|text|~+>+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+%7Cx%7C
++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+'+%2B+'b+string';+end}
++x.report("concat+double")+{+n.times+do;+"a+string+"+%2B+"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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1176602|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>~ &gt; 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]
~ &gt; 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
~ &gt; 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)
</code></pre>

blocks|key|1176652|text|双引号所需的击键次数是单引号的两倍。我总是很匆忙。我使用单引号。:)是的，我认为这是一种“性能提升”。:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1176653|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Double quotes take twice as many key strikes to type than single quotes. I'm always in a hurry. I use single quotes. :) And yes, I consider that a "performance gain". :)

blocks|key|1176672|text|有一点你们都漏掉了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1176673|在这里文档|1176674|尝尝这个|1176675|require+'benchmark'
mark+=+<<EOS
a+string
EOS
n+=+1000000
Benchmark.bm+do+%7Cx%7C
++x.report("assign+here+doc")+{n.times+do;++mark;+end}
end|code-block|syntax|javascript|1176676|它给了我|1176677|`asign+here+doc++0.141000+++0.000000+++0.141000+(++0.140625)`|1176678|和|1176679|'concat+single+quotes++1.813000+++0.000000+++1.813000+(++1.843750)'
'concat+double+quotes++1.812000+++0.000000+++1.812000+(++1.828125)'|1176680|因此，它肯定比concat和编写所有这些puts要好。|1176681|我希望看到Ruby更多地沿着文档操作语言的路线进行教学。|1176682|毕竟，我们不是真的在Rails、Sinatra和运行测试中做到这一点吗？|1176683|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

There's one you all missed.

HERE doc

try this

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

It gave me

<pre><code>`asign here doc 0.141000 0.000000 0.141000 ( 0.140625)`
</code></pre>

and

<pre><code>'concat single quotes 1.813000 0.000000 1.813000 ( 1.843750)'
'concat double quotes 1.812000 0.000000 1.812000 ( 1.828125)'
</code></pre>

so it's certainly better than concat and writing all those puts.

I would like to see Ruby taught more along the lines of a document manipulation language.

After all, don't we really do that in Rails, Sinatra, and running tests?

blocks|key|1176723|text|我模仿了蒂姆·斯诺怀特的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1176724|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+%7Cx%7C
++++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+'+%2B+'b+string';+end}
++++x.report('concat+double+++++++')+{+n.times+do;+"a+string+"+%2B+"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|code-block|syntax|javascript|1176725|结果：|1176726|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)|1176727|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I modded Tim Snowhite's answer.

<pre><code>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 &lt;&lt; single') { c =''; n.times do; c &lt;&lt; '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 &lt;&lt; ') { n.times do; @a_str_single &lt;&lt; @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 &lt;&lt; ') { n.times do; @a_str_double &lt;&lt; @b_str_double; end}
end
</code></pre>

Results:

<pre><code>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 &lt;&lt; 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 &lt;&lt; 0.100000 0.000000 0.100000 ( 0.076000)
concat double interp 0.160000 0.000000 0.160000 ( 0.108000)
concat double &lt;&lt; 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 &lt;&lt; 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 &lt;&lt; 0.120000 0.000000 0.120000 ( 0.126582)
concat double interp 0.180000 0.000000 0.180000 ( 0.181035)
concat double &lt;&lt; 0.130000 0.010000 0.140000 ( 0.128731)
</code></pre>

blocks|key|1392264|text|我也认为单引号字符串解析Ruby可能会更快。情况似乎并非如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1392265|无论如何，我认为上面的基准测试是错误的。不言而喻，这两个版本都会被解析成相同的内部字符串表示，所以为了得到解析速度更快的答案，我们不应该用字符串变量来衡量性能，而应该衡量Ruby解析字符串的速度。|1392266|generate.rb:+
10000.times+do
++('a'..'z').to_a.each+{%7Cv%7C+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|code-block|syntax|javascript|1392267|重复运行似乎没有太大的区别。解析这两个版本的字符串仍然需要几乎相同的时间。|1392268|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I too thought that single quoted strings might be quicker to parse for Ruby. It doesn't seem to be the case. 

Anyway, I think the above benchmark are measuring the wrong thing, though.
It stands to reason that either versions will be parsed into the same internal string representations so to get the answer as to which is quicker to parse, we shouldn't be measuring performance with string variables, but rather Ruby's speed of parsing strings.

<pre><code>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 &gt; single_q.rb
#Get the double quote version
$ tr \' \" &lt; single_q.rb &gt; 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
</code></pre>

Repeated runs don't seem to make much difference. It still takes pretty much the same time to parse either version of the string.

blocks|key|1392317|text|我尝试了以下几种方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1392318|def+measure(t)
++single_measures+=+[]
++double_measures+=+[]
++double_quoted_string+=+""
++single_quoted_string+=+''
++single_quoted+=+0
++double_quoted+=+0

++t.times+do+%7Ci%7C
++++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+%2B=+1
++++else
++++++double_quoted+%2B=+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{+%7Csum,+el%7C+sum+%2B+el+}.to_f+/+t
++double_measures_avg+=+double_measures.inject{+%7Csum,+el%7C+sum+%2B+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+%7Ci%7C
++measure(1000000)
end|code-block|syntax|javascript|1392319|以下是输出：|1392320|1.|1392321|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|1392322|2.|1392323|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|1392324|3.|1392325|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|1392326|4.|1392327|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|1392328|5.|1392329|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|1392330|6.|1392331|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|1392332|7.|1392333|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|1392334|8.|1392335|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|1392336|9.|1392337|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|1392338|10.|1392339|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|1392340|如果我没有弄错的话，在我看来，这两种方法所需的时间大致相同，尽管在大多数情况下，单引号的速度稍快一些。|1392341|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|1V|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1W|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1X|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1Y|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|20|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|21|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|22|8|@]|9|@]|A|$E|F]]|$1|12|3|13|5|6|7|23|8|@]|9|@]|A|$]]|$1|14|3|15|5|D|7|24|8|@]|9|@]|A|$E|F]]|$1|16|3|17|5|6|7|25|8|@]|9|@]|A|$]]|$1|18|3|19|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|1A|3|1B|5|6|7|27|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|D|7|28|8|@]|9|@]|A|$E|F]]|$1|1E|3|1F|5|6|7|29|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|D|7|2A|8|@]|9|@]|A|$E|F]]|$1|1I|3|1J|5|6|7|2B|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|D|7|2C|8|@]|9|@]|A|$E|F]]|$1|1M|3|1N|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1O|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1P|$]]

I tried the following:

<pre><code>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 &lt;&lt; 'a'
 t1 = Time.now - t1
 single_measures &lt;&lt; t1

 t2 = Time.now
 double_quoted_string &lt;&lt; "a"
 t2 = Time.now - t2
 double_measures &lt;&lt; t2

 if t1 &gt; 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
</code></pre>

And these are the outputs:

1.

<pre><code>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
</code></pre>

2.

<pre><code>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
</code></pre>

3.

<pre><code>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
</code></pre>

4.

<pre><code>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
</code></pre>

5.

<pre><code>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
</code></pre>

6.

<pre><code>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
</code></pre>

7.

<pre><code>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
</code></pre>

8.

<pre><code>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
</code></pre>

9.

<pre><code>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
</code></pre>

10.

<pre><code>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
</code></pre>

If I made no mistake, it seems to me that both take approximately the same time, even though single quoted is slightly faster in most cases.

Do you know if using double quotes instead of single quotes in ruby decreases performance in any meaningful way in ruby 1.8 and 1.9.

so if I type 

<pre><code>question = 'my question'
</code></pre>

is it faster than 

<pre><code>question = "my question"
</code></pre>

I imagine that ruby tries to figure out if something needs to be evaluated when it encounters double quotes and probably spends some cycles doing just that.

Is there a performance gain in using single quotes vs double quotes in ruby?

编译器

解释器

Java

你知道在ruby 1.8和1.9中使用双引号而不是单引号是否会降低性能吗？所以如果我输入question = 'my question'它是不是比question = "my question"我想象一下，当ruby遇到双引号时，它会尝试找出某些东西是否需要求值，并且可能会花费一些周期来做这件事。

问在ruby中使用单引号比使用双引号有性能上的提升吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在ruby中使用单引号比使用双引号有性能上的提升吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在ruby中使用单引号比使用双引号有性能上的提升吗？
EN