blocks|key|1666719|text|因为这是一个路径，所以我可能会使用array和join：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1666720|source+=+[ROOT_DIR,+project,+'App.config']+*+'/'|code-block|syntax|javascript|1666721|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|$]]

Since this is a path I'd probably use array and join:

<pre><code>source = [ROOT_DIR, project, 'App.config'] * '/'
</code></pre>

blocks|key|1451731|text|如果只是连接路径，可以使用Ruby自己的File.join方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1451732|source+=+File.join(ROOT_DIR,+project,+'App.config')|code-block|syntax|javascript|1451733|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|$]]

If you are just concatenating paths you can use Ruby's own File.join method.

<pre><code>source = File.join(ROOT_DIR, project, 'App.config')
</code></pre>

blocks|key|1666801|text|%2B运算符是正常的连接选择，并且可能是连接字符串的最快方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1666802|%2B和<<之间的不同之处在于，<<会更改其左侧的对象，而%2B不会。|1666803|irb(main):001:0>+s+=+'a'
=>+"a"
irb(main):002:0>+s+%2B+'b'
=>+"ab"
irb(main):003:0>+s
=>+"a"
irb(main):004:0>+s+<<+'b'
=>+"ab"
irb(main):005:0>+s
=>+"ab"|code-block|syntax|javascript|1666804|entityMap^0|0|1|0|0|1|2|2|E|2|R|1|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

The <code>+</code> operator is the normal concatenation choice, and is probably the fastest way to concatenate strings.

The difference between <code>+</code> and <code>&lt;&lt;</code> is that <code>&lt;&lt;</code> changes the object on its left hand side, and <code>+</code> doesn't.

<pre><code>irb(main):001:0&gt; s = 'a'
=&gt; "a"
irb(main):002:0&gt; s + 'b'
=&gt; "ab"
irb(main):003:0&gt; s
=&gt; "a"
irb(main):004:0&gt; s &lt;&lt; 'b'
=&gt; "ab"
irb(main):005:0&gt; s
=&gt; "ab"
</code></pre>

blocks|key|1451870|text|让我向你展示我所有的经验。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1451871|我有一个返回32k记录的查询，对于每个记录，我调用一个方法将该数据库记录格式化为格式化的字符串，然后将其连接成一个字符串，在此过程结束时将其转换为磁盘中的一个文件。|1451872|我的问题是，根据记录，大约在24k左右，连接字符串的过程变得痛苦。|1451873|我正在使用常规的'%2B‘运算符执行此操作。|1451874|当我换成“<<”的时候就像变魔术一样。真的很快。|1451875|因此，我想起了我的旧时光--大概是1998年--当时我使用Java语言，使用'%2B‘连接字符串，并将字符串从String改为StringBuffer+(现在我们Java+developer有了StringBuilder)。|1451876|我相信Ruby世界中%2B/+<<的过程与Java世界中%2B/+StringBuilder.append的过程是一样的。|1451877|第一个重新分配内存中的整个对象，另一个只指向一个新地址。|1451878|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

Let me show to you all my experience with that.

I had an query that returned 32k of records, for each record I called a method to format that database record into a formated string and than concatenate that into a String that at the end of all this process wil turn into a file in disk.

My problem was that by the record goes, around 24k, the process of concatenating the String turned on a pain.

I was doing that using the regular '+' operator.

When I changed to the '&lt;&lt;' was like magic. Was really fast.

So, I remembered my old times - sort of 1998 - when I was using Java and concatenating String using '+' and changed from String to StringBuffer (and now we, Java developer have the StringBuilder). 

I believe that the process of + / &lt;&lt; in Ruby world is the same as + / StringBuilder.append in the Java world. 

The first reallocate the entire object in memory and the other just point to a new address.

blocks|key|1666897|text|这里有更多的方法可以做到这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1666898|"String1"+%2B+"String2"

"#{String1}+#{String2}"

String1<<String2|code-block|syntax|javascript|1666899|以此类推。|1666900|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here are more ways to do this:

<pre><code>"String1" + "String2"

"#{String1} #{String2}"

String1&lt;&lt;String2
</code></pre>

And so on ...

blocks|key|1451942|text|你说的是串联？那么#concat方法呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1451943|a+=+'foo'
a.object_id+#=>+some+number
a.concat+'bar'+#=>+foobar
a.object_id+#=>+same+as+before+--+string+a+remains+the+same+object|code-block|syntax|javascript|1451944|公平地说，concat别名为<<。|1451945|entityMap^0|9|7|0|0|5|6|E|2|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

Concatenation you say? How about <code>#concat</code> method then?

<pre><code>a = 'foo'
a.object_id #=&gt; some number
a.concat 'bar' #=&gt; foobar
a.object_id #=&gt; same as before -- string a remains the same object
</code></pre>

In all fairness, <code>concat</code> is aliased as <code>&lt;&lt;</code>.

blocks|key|1666997|text|来自http://greyblake.com/blog/2012/09/02/ruby-perfomance-tricks/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1666998|使用<<又称concat要比%2B=高效得多，因为后者创建了一个时态对象，并用新对象覆盖了第一个对象。|style|CODE|1666999|require+'benchmark'

N+=+1000
BASIC_LENGTH+=+10

5.times+do+%7Cfactor%7C
++length+=+BASIC_LENGTH+*+(10+**+factor)
++puts+"_"+*+60+%2B+"\nLENGTH:+#{length}"

++Benchmark.bm(10,+'%2B=+VS+<<')+do+%7Cx%7C
++++concat_report+=+x.report("%2B=")++do
++++++str1+=+""
++++++str2+=+"s"+*+length
++++++N.times+{+str1+%2B=+str2+}
++++end

++++modify_report+=+x.report("<<")++do
++++++str1+=+"s"
++++++str2+=+"s"+*+length
++++++N.times+{+str1+<<+str2+}
++++end

++++[concat_report+/+modify_report]
++end
end|code-block|syntax|javascript|1667000|输出：|1667001|____________________________________________________________
LENGTH:+10
+++++++++++++++++user+++++system++++++total++++++++real
%2B=+++++++++++0.000000+++0.000000+++0.000000+(++0.004671)
<<+++++++++++0.000000+++0.000000+++0.000000+(++0.000176)
%2B=+VS+<<++++++++++NaN++++++++NaN++++++++NaN+(+26.508796)
____________________________________________________________
LENGTH:+100
+++++++++++++++++user+++++system++++++total++++++++real
%2B=+++++++++++0.020000+++0.000000+++0.020000+(++0.022995)
<<+++++++++++0.000000+++0.000000+++0.000000+(++0.000226)
%2B=+VS+<<++++++++++Inf++++++++NaN++++++++NaN+(101.845829)
____________________________________________________________
LENGTH:+1000
+++++++++++++++++user+++++system++++++total++++++++real
%2B=+++++++++++0.270000+++0.120000+++0.390000+(++0.390888)
<<+++++++++++0.000000+++0.000000+++0.000000+(++0.001730)
%2B=+VS+<<++++++++++Inf++++++++Inf++++++++NaN+(225.920077)
____________________________________________________________
LENGTH:+10000
+++++++++++++++++user+++++system++++++total++++++++real
%2B=+++++++++++3.660000+++1.570000+++5.230000+(++5.233861)
<<+++++++++++0.000000+++0.010000+++0.010000+(++0.015099)
%2B=+VS+<<++++++++++Inf+157.000000++++++++NaN+(346.629692)
____________________________________________________________
LENGTH:+100000
+++++++++++++++++user+++++system++++++total++++++++real
%2B=++++++++++31.270000++16.990000++48.260000+(+48.328511)
<<+++++++++++0.050000+++0.050000+++0.100000+(++0.105993)
%2B=+VS+<<+++625.400000+339.800000++++++++NaN+(455.961373)|1667002|entityMap|0|LINK|mutability|MUTABLE|url|http://greyblake.com/blog/2012/09/02/ruby-perfomance-tricks/^0|2|1O|0|0|2|2|6|6|E|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]|$A|15|B|16|F|G]|$A|17|B|18|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|19|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1B|8|@]|9|@]|C|$K|L]]|$1|Q|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

from <a href="http://greyblake.com/blog/2012/09/02/ruby-perfomance-tricks/" rel="noreferrer">http://greyblake.com/blog/2012/09/02/ruby-perfomance-tricks/</a>

Using <code>&lt;&lt;</code> aka <code>concat</code> is far more efficient than <code>+=</code>, as the latter creates a temporal object and overrides the first object with the new object.

<pre><code>require 'benchmark'

N = 1000
BASIC_LENGTH = 10

5.times do |factor|
 length = BASIC_LENGTH * (10 ** factor)
 puts "_" * 60 + "\nLENGTH: #{length}"

 Benchmark.bm(10, '+= VS &lt;&lt;') do |x|
 concat_report = x.report("+=") do
 str1 = ""
 str2 = "s" * length
 N.times { str1 += str2 }
 end

 modify_report = x.report("&lt;&lt;") do
 str1 = "s"
 str2 = "s" * length
 N.times { str1 &lt;&lt; str2 }
 end

 [concat_report / modify_report]
 end
end
</code></pre>

output:

<pre><code>____________________________________________________________
LENGTH: 10
 user system total real
+= 0.000000 0.000000 0.000000 ( 0.004671)
&lt;&lt; 0.000000 0.000000 0.000000 ( 0.000176)
+= VS &lt;&lt; NaN NaN NaN ( 26.508796)
____________________________________________________________
LENGTH: 100
 user system total real
+= 0.020000 0.000000 0.020000 ( 0.022995)
&lt;&lt; 0.000000 0.000000 0.000000 ( 0.000226)
+= VS &lt;&lt; Inf NaN NaN (101.845829)
____________________________________________________________
LENGTH: 1000
 user system total real
+= 0.270000 0.120000 0.390000 ( 0.390888)
&lt;&lt; 0.000000 0.000000 0.000000 ( 0.001730)
+= VS &lt;&lt; Inf Inf NaN (225.920077)
____________________________________________________________
LENGTH: 10000
 user system total real
+= 3.660000 1.570000 5.230000 ( 5.233861)
&lt;&lt; 0.000000 0.010000 0.010000 ( 0.015099)
+= VS &lt;&lt; Inf 157.000000 NaN (346.629692)
____________________________________________________________
LENGTH: 100000
 user system total real
+= 31.270000 16.990000 48.260000 ( 48.328511)
&lt;&lt; 0.050000 0.050000 0.100000 ( 0.105993)
+= VS &lt;&lt; 625.400000 339.800000 NaN (455.961373)
</code></pre>

blocks|key|1667051|text|这是另一个受this+gist启发的基准测试。它对动态字符串和预定义字符串的连接(%2B)、附加(<<)和插值(#{})进行了比较。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1667052|require+'benchmark'

#+we+will+need+the+CAPTION+and+FORMAT+constants:
include+Benchmark

count+=+100_000


puts+"Dynamic+strings"

Benchmark.benchmark(CAPTION,+7,+FORMAT)+do+%7Cbm%7C
++bm.report("concat")+{+count.times+{+11.to_s+%2B++'/'+%2B++12.to_s+}+}
++bm.report("append")+{+count.times+{+11.to_s+<<+'/'+<<+12.to_s+}+}
++bm.report("interp")+{+count.times+{+"#{11}/#{12}"+}+}
end


puts+"\nPredefined+strings"

s11+=+"11"
s12+=+"12"
Benchmark.benchmark(CAPTION,+7,+FORMAT)+do+%7Cbm%7C
++bm.report("concat")+{+count.times+{+s11+%2B++'/'+%2B++s12+}+}
++bm.report("append")+{+count.times+{+s11+<<+'/'+<<+s12+}+}
++bm.report("interp")+{+count.times+{+"#{s11}/#{s12}"+++}+}
end|code-block|syntax|javascript|1667053|输出：|1667054|Dynamic+strings
++++++++++++++user+++++system++++++total++++++++real
concat++++0.050000+++0.000000+++0.050000+(++0.047770)
append++++0.040000+++0.000000+++0.040000+(++0.042724)
interp++++0.050000+++0.000000+++0.050000+(++0.051736)

Predefined+strings
++++++++++++++user+++++system++++++total++++++++real
concat++++0.030000+++0.000000+++0.030000+(++0.024888)
append++++0.020000+++0.000000+++0.020000+(++0.023373)
interp++++3.160000+++0.160000+++3.320000+(++3.311253)|1667055|结论:+MRI插值较重。|1667056|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/alno/1704455^0|15|1|1B|2|1I|3|6|9|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1B|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

Here's another benchmark inspired by <a href="https://gist.github.com/alno/1704455" rel="noreferrer">this gist</a>. It compares concatenation (<code>+</code>), appending (<code>&lt;&lt;</code>) and interpolation (<code>#{}</code>) for dynamic and predefined strings.

<pre class="lang-rb prettyprint-override"><code>require 'benchmark'

# we will need the CAPTION and FORMAT constants:
include Benchmark

count = 100_000


puts "Dynamic strings"

Benchmark.benchmark(CAPTION, 7, FORMAT) do |bm|
 bm.report("concat") { count.times { 11.to_s + '/' + 12.to_s } }
 bm.report("append") { count.times { 11.to_s &lt;&lt; '/' &lt;&lt; 12.to_s } }
 bm.report("interp") { count.times { "#{11}/#{12}" } }
end


puts "\nPredefined strings"

s11 = "11"
s12 = "12"
Benchmark.benchmark(CAPTION, 7, FORMAT) do |bm|
 bm.report("concat") { count.times { s11 + '/' + s12 } }
 bm.report("append") { count.times { s11 &lt;&lt; '/' &lt;&lt; s12 } }
 bm.report("interp") { count.times { "#{s11}/#{s12}" } }
end
</code></pre>

output:

<pre class="lang-none prettyprint-override"><code>Dynamic strings
 user system total real
concat 0.050000 0.000000 0.050000 ( 0.047770)
append 0.040000 0.000000 0.040000 ( 0.042724)
interp 0.050000 0.000000 0.050000 ( 0.051736)

Predefined strings
 user system total real
concat 0.030000 0.000000 0.030000 ( 0.024888)
append 0.020000 0.000000 0.020000 ( 0.023373)
interp 3.160000 0.160000 3.320000 ( 3.311253)
</code></pre>

Conclusion: interpolation in MRI is heavy.

blocks|key|1667107|text|你可以使用%2B或<<运算符，但在ruby中.concat函数是最可取的，因为它比其他运算符要快得多。你可以像这样使用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1667108|source+=+"#{ROOT_DIR}/".concat(project.concat("/App.config"))|code-block|syntax|javascript|1667109|entityMap^0|5|1|7|2|K|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

You may use <code>+</code> or <code>&lt;&lt;</code> operator, but in ruby <code>.concat</code> function is the most preferable one, as it is much faster than other operators. You can use it like.

<pre><code>source = "#{ROOT_DIR}/".concat(project.concat("/App.config"))
</code></pre>

blocks|key|1452163|text|情况很重要，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452164|#+this+will+not+work
output+=+''

Users.all.each+do+%7Cuser%7C
++output+%2B+"#{user.email}\n"
end
#+the+output+will+be+''
puts+output

#+this+will+do+the+job
output+=+''

Users.all.each+do+%7Cuser%7C
++output+<<+"#{user.email}\n"
end
#+will+get+the+desired+output
puts+output|code-block|syntax|javascript|1452165|在第一个示例中，与%2B操作符连接不会更新output对象，但是在第二个示例中，<<操作符将在每次迭代中更新output对象。因此，对于上述类型的情况，<<更好。|offset|length|style|CODE|1452166|entityMap^0|0|0|9|1|J|6|12|2|1G|6|22|2|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]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$]]

Situation matters, for example:

<pre><code># this will not work
output = ''

Users.all.each do |user|
 output + "#{user.email}\n"
end
# the output will be ''
puts output

# this will do the job
output = ''

Users.all.each do |user|
 output &lt;&lt; "#{user.email}\n"
end
# will get the desired output
puts output
</code></pre>

In the first example, concatenating with <code>+</code> operator will not update the <code>output</code> object,however, in the second example, the <code>&lt;&lt;</code> operator will update the <code>output</code> object with each iteration. So, for the above type of situation, <code>&lt;&lt;</code> is better.

blocks|key|1452190|text|您还可以使用%25，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1452191|source+=+"#{ROOT_DIR}/%25s/App.config"+%25+project|code-block|syntax|javascript|1452192|这种方法也适用于'+(单)引号。|1452193|entityMap^0|6|1|0|0|8|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

You can also use <code>%</code> as follows:

<pre><code>source = "#{ROOT_DIR}/%s/App.config" % project
</code></pre>

This approach works with <code>'</code> (single) quotation mark as well.

blocks|key|1452228|text|您可以直接在字符串定义中连接：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452229|nombre_apellido+=+"#{customer['first_name']}+#{customer['last_name']}+#{order_id}"|code-block|syntax|javascript|1452230|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|$]]

You can concatenate in string definition directly:

<pre><code>nombre_apellido = "#{customer['first_name']} #{customer['last_name']} #{order_id}"
</code></pre>

blocks|key|1667286|text|对于您的特定情况，在构造字符串类型的文件路径时也可以使用Array#join：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1667287|string+=+[ROOT_DIR,+project,+'App.config'].join('/')]|code-block|syntax|javascript|1667288|这有一个令人愉快的副作用，即自动将不同的类型转换为字符串：|1667289|['foo',+:bar,+1].join('/')
=>"foo/bar/1"|1667290|entityMap^0|S|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

For your particular case you could also use <code>Array#join</code> when constructing file path type of string:

<pre><code>string = [ROOT_DIR, project, 'App.config'].join('/')]
</code></pre>

This has a pleasant side effect of automatically converting different types to string:

<pre><code>['foo', :bar, 1].join('/')
=&gt;"foo/bar/1"
</code></pre>

blocks|key|1452315|text|对于Puppet：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452316|$username+=+'lala'
notify+{+"Hello+${username.capitalize}":
++++withpath+=>+false,
}|code-block|syntax|javascript|1452317|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|$]]

For Puppet:

<pre><code>$username = 'lala'
notify { "Hello ${username.capitalize}":
 withpath =&gt; false,
}
</code></pre>

I am looking for a more elegant way of concatenating strings in Ruby.

I have the following line:

<pre><code>source = "#{ROOT_DIR}/" &lt;&lt; project &lt;&lt; "/App.config"
</code></pre>

Is there a nicer way of doing this?

And for that matter what is the difference between <code>&lt;&lt;</code> and <code>+</code>?

String concatenation in Ruby

数据库

Java

我正在寻找一种在Ruby中连接字符串的更优雅的方法。我有下面这行代码：source = "#{ROOT_DIR}/" << project << "/App.config"有没有更好的方法呢？就这一点而言，<<和+的区别是什么

问Ruby中的字符串连接
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的字符串连接EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的字符串连接
EN