blocks|key|2998249|text|因为它更快/不会创建字符串的副本，<->垃圾收集器不需要运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2998250|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|$]]

Because it's faster / does not create a copy of the string &lt;-> garbage collector does not need to run.

blocks|key|282342|text|证明：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|282343|a+=+'foo'
a.object_id+#=>+2154889340
a+<<+'bar'
a.object_id+#=>+2154889340
a+%2B=+'quux'
a.object_id+#=>+2154742560|code-block|syntax|javascript|282344|因此，<<会更改原始字符串，而不是创建新的字符串。原因是在ruby中，a+%2B=+b是a+=+a+%2B+b的语法简写(其他<op>=操作符也是如此)，这是一种赋值。另一方面，<<是concat()的别名，它可以就地更改接收器。|offset|length|style|CODE|282345|entityMap^0|0|0|3|2|Z|6|16|9|1N|5|2D|2|2G|8|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]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|N|$]]

Proof:

<pre><code>a = 'foo'
a.object_id #=&gt; 2154889340
a &lt;&lt; 'bar'
a.object_id #=&gt; 2154889340
a += 'quux'
a.object_id #=&gt; 2154742560
</code></pre>

So <code>&lt;&lt;</code> alters the original string rather than creating a new one. The reason for this is that in ruby <code>a += b</code> is syntactic shorthand for <code>a = a + b</code> (the same goes for the other <code>&lt;op&gt;=</code> operators) which is an assignment. On the other hand <code>&lt;&lt;</code> is an alias of <code>concat()</code> which alters the receiver in-place.

blocks|key|3211549|text|性能证明：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3211550|#!/usr/bin/env+ruby

require+'benchmark'

Benchmark.bmbm+do+%7Cx%7C
++x.report('%2B=+:')+do
++++s+=+""
++++10000.times+{+s+%2B=+"something+"+}
++end
++x.report('<<+:')+do
++++s+=+""
++++10000.times+{+s+<<+"something+"+}
++end
end

#+Rehearsal+----------------------------------------
#+%2B=+:+++0.450000+++0.010000+++0.460000+(++0.465936)
#+<<+:+++0.010000+++0.000000+++0.010000+(++0.009451)
#+-------------------------------+total:+0.470000sec
#+
#++++++++++++user+++++system++++++total++++++++real
#+%2B=+:+++0.270000+++0.010000+++0.280000+(++0.277945)
#+<<+:+++0.000000+++0.000000+++0.000000+(++0.003043)|code-block|syntax|javascript|3211551|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Performance proof:

<pre><code>#!/usr/bin/env ruby

require 'benchmark'

Benchmark.bmbm do |x|
 x.report('+= :') do
 s = ""
 10000.times { s += "something " }
 end
 x.report('&lt;&lt; :') do
 s = ""
 10000.times { s &lt;&lt; "something " }
 end
end

# Rehearsal ----------------------------------------
# += : 0.450000 0.010000 0.460000 ( 0.465936)
# &lt;&lt; : 0.010000 0.000000 0.010000 ( 0.009451)
# ------------------------------- total: 0.470000sec
# 
# user system total real
# += : 0.270000 0.010000 0.280000 ( 0.277945)
# &lt;&lt; : 0.000000 0.000000 0.000000 ( 0.003043)
</code></pre>

blocks|key|2998310|text|虽然不能直接回答你的问题，但为什么The+Fully+Upturned+Bin一直是我最喜欢的Ruby文章之一。它还包含一些与垃圾收集相关的字符串信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2998311|entityMap|0|LINK|mutability|MUTABLE|url|http://viewsourcecode.org/why/hacking/theFullyUpturnedBin.html^0|H|M|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

While not a direct answer to your question, why's <a href="http://viewsourcecode.org/why/hacking/theFullyUpturnedBin.html" rel="nofollow">The Fully Upturned Bin</a> always has been one of my favorite Ruby articles. It also contains some info on strings in regards to garbage collection.

blocks|key|3211670|text|一个朋友正在学习Ruby作为他的第一种编程语言，他在Ruby+Koans系列中学习Ruby中的Strings时也问了我同样的问题。我用下面的类比向他解释；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3211671|你有一杯水是半满的，你需要再倒满一杯。|3211672|第一种方法是拿一个新的玻璃杯，把水龙头里的水装满一半，然后用第二个半满的玻璃杯重新装满你的饮水杯。每次你需要续杯时，你都会这样做。|3211673|第二种方法是把你的半杯水直接从水龙头里倒满。|3211674|在一天结束的时候，如果你每次需要续杯时都选择换一个新的玻璃杯，你会有更多的玻璃杯需要清洗。|3211675|同样的道理也适用于铁铲运算符和加号相等运算符。另外，equal操作员每次需要重新装满它的杯子时都会选择一个新的‘玻璃杯’，而铲子操作员只是拿着相同的玻璃杯重新装满它。在一天结束的时候，Plus+equal运算符有更多的“玻璃”集合。|3211676|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

A friend who is learning Ruby as his first programming language asked me this same question while going through Strings in Ruby on the Ruby Koans series. I explained it to him using the following analogy;

You have a glass of water that is half full and you need to refill your glass.

First way you do it by taking a new glass, filling it halfway with water from a tap and then using this second half-full glass to refill your drinking glass. You do this every time you need to refill your glass.

The second way you take your half full glass and just refill it with water straight from the tap.

At the end of the day, you would have more glasses to clean if you choose to pick a new glass every time you needed to refill your glass.

The same applies to the shovel operator and the plus equal operator. Plus equal operator picks a new 'glass' every time it needs to refill its glass while the shovel operator just takes the same glass and refills it. At the end of the day more 'glass' collection for the Plus equal operator.

blocks|key|2998481|text|这是一个古老的问题，但我只是偶然遇到了它，我对现有的答案并不完全满意。与串联%2B=相比，shovel+<<有很多优点，但也有语义方面的考虑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2998482|来自@noodl的被接受的答案显示，<<就地修改现有对象，而%2B=创建一个新对象。因此，您需要考虑是希望对字符串的所有引用都反映新值，还是希望保留现有引用而创建一个新的字符串值以便在本地使用。如果您需要所有引用来反映更新后的值，则需要使用<<。如果你不想去管其他的引用，那么你需要使用%2B=。|2998483|一种非常常见的情况是，只有一个对字符串的引用。在这种情况下，语义差异并不重要，由于<<的速度，选择它是很自然的。|2998484|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

This is an old question, but I just ran across it and I'm not fully satisfied with the existing answers. There are lots of good points about the shovel &lt;&lt; being faster than concatenation +=, but there is also a semantic consideration.

The accepted answer from @noodl shows that &lt;&lt; modifies the existing object in place, whereas += creates a new object. So you need to consider if you want all references to the string to reflect the new value, or do you want to leave the existing references alone and create a new string value to use locally. If you need all references to reflect the updated value, then you need to use &lt;&lt;. If you want to leave other references alone, then you need to use +=.

A very common case is that there is only a single reference to the string. In this case, the semantic difference does not matter and it is natural to prefer &lt;&lt; because of its speed.

blocks|key|2998504|text|虽然大多数答案涵盖了%2B=较慢，因为它创建了一个新的副本，但重要的是要记住，%2B=和<<+不是可互换的！您希望在不同的情况下使用每种方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|2998505|使用<<还会更改指向b的所有变量。在这里，我们也可以在我们不想要的时候改变a。|2998506|2.3.1+:001+>+a+=+"hello"
+=>+"hello"
2.3.1+:002+>+b+=+a
+=>+"hello"
2.3.1+:003+>+b+<<+"+world"
+=>+"hello+world"
2.3.1+:004+>+a
+=>+"hello+world"|code-block|syntax|javascript|2998507|因为%2B=创建了一个新的副本，所以它也会保留指向它的所有变量不变。|2998508|2.3.1+:001+>+a+=+"hello"
+=>+"hello"
2.3.1+:002+>+b+=+a
+=>+"hello"
2.3.1+:003+>+b+%2B=+"+world"
+=>+"hello+world"
2.3.1+:004+>+a
+=>+"hello"|2998509|理解这种区别可以在处理循环时省去很多麻烦！|2998510|entityMap^0|A|2|11|2|14|2|17|2|0|2|2|A|1|11|1|0|0|2|2|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1B|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|E|@]|F|$]]|$1|P|3|Q|5|K|7|1F|8|@]|E|@]|F|$L|M]]|$1|R|3|S|5|6|7|1G|8|@]|E|@]|F|$]]|$1|T|3|-4|5|6|7|1H|8|@]|E|@]|F|$]]]|U|$]]

While a majority of answers cover <code>+=</code> is slower because it creates a new copy, it's important to keep in mind that <code>+=</code> and <code>&lt;&lt;</code> are not interchangeable! You want to use each in different cases.

Using <code>&lt;&lt;</code> will also alter any variables that are pointed to <code>b</code>. Here we also mutate <code>a</code> when we may not want to.

<pre><code>2.3.1 :001 &gt; a = "hello"
 =&gt; "hello"
2.3.1 :002 &gt; b = a
 =&gt; "hello"
2.3.1 :003 &gt; b &lt;&lt; " world"
 =&gt; "hello world"
2.3.1 :004 &gt; a
 =&gt; "hello world"
</code></pre>

Because <code>+=</code> makes a new copy, it also leaves any variables that are pointing to it unchanged.

<pre><code>2.3.1 :001 &gt; a = "hello"
 =&gt; "hello"
2.3.1 :002 &gt; b = a
 =&gt; "hello"
2.3.1 :003 &gt; b += " world"
 =&gt; "hello world"
2.3.1 :004 &gt; a
 =&gt; "hello"
</code></pre>

Understanding this distinction can save you a lot of headaches when you're dealing with loops!

I am working through Ruby Koans. 

The <code>test_the_shovel_operator_modifies_the_original_string</code> Koan in about_strings.rb includes the following comment:

<blockquote>
 Ruby programmers tend to favor the shovel operator (&lt;&lt;) over the plus
 equals operator (+=) when building up strings. Why?
</blockquote>

My guess is it involves speed, but I don't understand the action under the hood that would cause the shovel operator to be faster. 

Would someone be able to please explain the details behind this preference?

Why is the shovel operator (<<) preferred over plus-equals (+=) when building a string in Ruby?

我正在通过Ruby Koans工作。about_strings.rb中的test_the_shovel_operator_modifies_the_original_string Koan包含以下注释：RubyRubyRuby程序员在构建字符串时倾向于使用操作符(<<)而不是加号等于操作符(+=)。为什么？我的猜测是它...

问为什么在Ruby语言中构建字符串时，首选的是铲运算符(<<)而不是加号(+=)？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在Ruby语言中构建字符串时，首选的是铲运算符(<<)而不是加号(+=)？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在Ruby语言中构建字符串时，首选的是铲运算符(<<)而不是加号(+=)？
EN