Been working on Ruby for a few weeks now and am well on my way. I've
been working on tutorials and something came up that is never (or hasn't
been explained.
I've seen this used interchangeably so I need to know what this is:
"print x" versus "print "#{x}" ......what the heck is "#{x}"?
If the hash tag wasn't used so much in these languages, my guess would
be "convert x to a number" but that can't be right........though I think
it has some effect like "?" and"!" do
I've seen this used interchangeably so I need to know what this is:
"print
You really don't see print() too much in ruby. Instead, you more often
see puts() or p(), which is shorthand for inspect(). Here is one
difference between puts() and p():
"print x" will convert whatever object x refers to a string and print it
to the console.
Seems confusing.
x = 7
"print x"
#=>print x
print x
#=>7
print 'x'
#=>x
print "x"
#=>x
print '#{x}'
#=>#{x}
print "#{x}"
#=>7
Simple quotes means literal.
With double quotes Ruby make some more work than simple quotes, it
evaluate whatever code inside #{} giving a result, also transform this
kind of things:
\b \c \n \s #backspaces, reverses, newline, etc.
Well hope that this will help you to understand the difference.
"print x" will convert whatever object x refers to a string and print it to
the console. If x is already referring to a string, no conversion is done.
'print "#{x}"' will create a new string and interpolate into it the object
to which x refers converted into a string. This always creates a new
string, even if x is already referring to a string.
If you see 'print "#{x}"', it might be a code smell, especially if x is
referring to a string, because might be creating a useless copy of an
existing string just to print it out.
Interpolation is better used when you really do need to create a new
string, for example:
print "My variable is '#{x}'"
There are various complex rules on how objects get converted to strings
which you should read up on.
-Doug
···
On Sat, Sep 29, 2012 at 1:41 PM, Justin T. <lists@ruby-forum.com> wrote:
Put simply:
"print x" will print just the letter x.
"print #{x}" parses out whatever the variable x is.
This will print out the number 6, which is the current value of x. To
get the letter x, you want
print "x"
. That being said, #{} simply is a so-called string interpolation. These
two statements are basically equal:
str = "x is " + x.to_s + "!"
str = "x is #{x}!"
There are some subtle differences between them, namely regarding the
number of string objects created. It is generally considered good
coding practive using string interpolation if you don’t have a reason
to do otherwise. Note that #{} can perfectly contain any valid Ruby
expression; if you want to push it to its limits, you can even define a
class inside it. Whatever the expression returns, will be converted to
a string using the #to_s method (which in the case of strings happens
to return the string itself). In contrast to this, the plus expression
wants to use its argument as-is and won’t try to call #to_s on it.
Compare:
x = 6
str = "x is #{x}"
str = "x is " + x
While the former will work as expected (calling Fixnum#to_s, which
returns the string "6"), the latter crashes with a TypeError, because
you tried to combine a number with a string. Chaining is not the same
as interpolation.
Vale,
Marvin
···
Am Sun, 30 Sep 2012 05:44:58 +0900 schrieb George Spak <lists@ruby-forum.com>:
Justin T. wrote in post #1078043:
> Put simply:
>
> "print x" will print just the letter x.
> "print #{x}" parses out whatever the variable x is.
Ah that makes sense. Much appreciate the help. Unfortunately, the
docs are of little halp. This must be buried deep in them.