Comments on: Appending to a string

By: Gib

Gib — Thu, 28 Jul 2011 08:12:16 +0000

tim, I found this page with a google search because I was trying to figure out why a string of mine (“base” in your example) was changing, apparently in parallel with the contents of another string (“a” in your example).

I was doing exactly what you describe there. Thanks for helping me understand what was going on.
I changed it to
base = ‘base string’
a = ”;
a << base;
a << " some additional stuff "
a << " more additional stuff "

which fixed my problem.

By: tim

tim — Wed, 16 Feb 2011 19:21:08 +0000

In general << can have unintended side effects and should be avoided. += will only modify the exact variable that you are working with.

Say you're building up a string from a base which you want to remain the same.
base = 'base string'
a = base
a << " some additional stuff "
a << " more additional stuff "

Unfortunately, you've also modified the value of base at this point.

By: RSL

RSL — Wed, 13 Jun 2007 13:05:16 +0000

And it didn’t. :(

By: RSL

RSL — Wed, 13 Jun 2007 13:04:39 +0000

If all you’re trying to do is print a concatenated string, though. I think I remember [from benchmarking] that puts “#{foo} #{bar}” is actually a bit faster than puts foo

By: Arne

Arne — Thu, 05 Apr 2007 10:57:22 +0000

Supose you write a method that returns its argument with ‘+++’ appended to it :

def m1(s); s + “+++”;end
def m2(s); s << “+++”; end

a=’abc’ #=> “abc”

m1(a) #=> “abc+++”
a #=> “abc”

m2(a) #=> “abc+++”
a #=> “abc+++”

The point is that with << you’re modifying the instance, but maybe somewhere else there exists a reference to the same instance where the string is not expected to change. In general it can be good practice not to modify the objects passed into a method. (I’m overgeneralizing ofcourse).

This is the reason that strings in Java (eww.. don’t mention the J-word…) are immutable. There’s a StringBuffer for when mutable strings are needed.

But if you know what you’re doing, why not. The nice thing is that your algorithm might work unchanged with arrays and possible other objects due to ruby’s lovely duck-typing philosophy.

By: Frank

Frank — Thu, 05 Apr 2007 10:24:29 +0000

Phew! I had a hard time to understand this… It’s true that my comment system is bad at keeping formatting. I’ll try to find some plugin that will fix the problem.

Thanks for the info Gregory, I have updated the original post. However, I can’t see a real reason to use += instead of << when appending to a string…

By: Anselm

Anselm — Thu, 05 Apr 2007 10:13:16 +0000

The point of Gregory’s comment is that

a += b

generates a new object, while

a << b

appends b to the existing object a.

By: Todd Werth

Todd Werth — Wed, 04 Apr 2007 22:58:36 +0000

It’s very true that you should use

By: Gregory

Gregory — Wed, 04 Apr 2007 22:45:29 +0000

Okay, your comment system sucks… hope you can reformat the above into a single comment. :)

By: Gregory

Gregory — Wed, 04 Apr 2007 22:44:28 +0000

Hmm… the above seems to lost formatting. :-/

I said it’s not precedence but the fact that String#+ and String#