Why is "#{String}" a common idiom in Ruby

Question

A Ruby dev I know asked this; my answer is below... Are there other, better reasons?

Why do so many Ruby programmers do

"#{string}"

rather than

string

since the second form is simpler and more efficient?

Answer 1

Smaller changes when you later need to do more than simply get the value of the string, but also prepend/append to it at the point of use seems to be the best motivation I can find for that idiom.

Answer 2

Is this a common idiom for Ruby developers? I don't see it that much.

Answer 3

maybe it is easy way to convert any to string? Because it is the same as call to_s method. But it is quite strange way :).

a = [1,2,3]
"#{a}"
#=> "123"
a.to_s
#=> "123"

Answer 4

What's the broader context of some of the usages? The only thing I can come up with beyond what's already been mentioned is as a loose attempt at type safety; that is, you may receive anything as an argument, and this could ensure that whatever you pass in walks like a duck..or, well, a string (though string.to_s would arguably be clearer).

In general though, this is probably a code smell that someone along the way thought was Best Practices.

Answer 5

Interesting answers, everyone. I'm the developer who asked the original question. To give some more context, I see this occasionally at my current job, and also sometimes in sample code on the Rails list, with variables that are known in advance to contain strings. I could sort of understand it as a substitute for to_s, but I don't think that's what's going on here; I think people just forget that you don't need the interpolation syntax if you're just passing a string variable.

If anyone tried to tell me this was a best practice, I'd run away at top speed.

Answer 6

There is only one case where this is a recommended idiom :

fname = 'john'
lname  = 'doe' 
name = "#{fname} #{lname}"

The code above is more efficient than :

name = fname + ' ' + lname

or

name = [fname, lname].join(' ')