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

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

a += b

generates a new object, while

a << b

appends b to the existing object a.

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…

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.