Comments on: Appending to a string

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#

By: Gregory

Gregory — Wed, 04 Apr 2007 22:40:59 +0000

String#
>> a = “foo”
=> “foo”
>> a “foobar”
>> a = “foo”
=> “foo”
>> a.object_id
=> 1686724
>> a “foobar”
>> a.object_id
=> 1686724
>> b = “foo”
=> “foo”
>> b.object_id
=> 1668094
>> b += “bar”
=> “foobar”
>> b.object_id
=> 1657194
>> a == b
=> true

So actually, the two have different behaviors and should be used where appropriate, rather than preferring one over the other.

Use String#= b is equivalent to a = a b