hash assignment [:x] vs ['x']

[Mk 27]

Being totally new to ruby, I just noticed that using

bob['phone']

which coming from perl is a style I'm used to, results in a separate key
than

bob[hone]

That seems slightly weird, I had assumed the :form is just a shorthand
like %w( ). So -- is there anything more that I need to understand
about this distinction?

 

[Tim Hunter]

Being totally new to ruby, I just noticed that using

bob['phone']

which coming from perl is a style I'm used to, results in a separate key
than

bob[hone]

That seems slightly weird, I had assumed the :form is just a shorthand
like %w( ). So -- is there anything more that I need to understand
about this distinction?

:x is a Symbol object. 'x' is a String. You can make a symbol from a
string with the intern method, and a string from a symbol with the to_s
method.

A symbol is a named number that Ruby guarantees will have the same value
throughout your program. You pick the name, Ruby picks the number.

 

[Ben Lovell]

[Note: parts of this message were removed to make it a legal post.]

Being totally new to ruby, I just noticed that using

bob['phone']

which coming from perl is a style I'm used to, results in a separate key
than

bob[hone]

That seems slightly weird, I had assumed the :form is just a shorthand
like %w( ). So -- is there anything more that I need to understand
about this distinction?

The first example is indexing via a string, the second is via a ruby symbol.
You can think of a symbol as essentially a (very) lightweight string usually
used for keying into hashes and general naming of things.

Rgds,
Ben

 

[Brian Candler]

Being totally new to ruby, I just noticed that using

bob['phone']

which coming from perl is a style I'm used to, results in a separate key
than

bob[hone]

That seems slightly weird, I had assumed the :form is just a shorthand
like %w( ). So -- is there anything more that I need to understand
about this distinction?

Yes. hone is a Symbol literal, whereas 'phone' is a String literal.

Symbols and Strings are two different types of object entirely. In
particular:

* Symbols are immutable

* a literal like :foo will always give exactly the same object instance
throughout the lifetime of the program, whereas a string literal like
'foo' will give a fresh object every time it is used

For this reason, symbols are somewhat more efficient for hash lookups.
Some libraries use them for passing hashes of options, although I
suspect this is more because they are one character shorter to type,
rather than any particular performance reason

 

[Bertram Scharpf]

Hi,

Am Dienstag, 26. Mai 2009, 02:19:29 +0900 schrieb Mk 27:

bob['phone']
bob[hone]

That seems slightly weird, I had assumed the :form is just a shorthand
like %w( ). So -- is there anything more that I need to understand
about this distinction?

$ irb
irb(main):001:0> hone.class
=> Symbol
irb(main):002:0> 'phone'.class
=> String

and

irb(main):003:0> hone.methods.sort - 'phone'.methods
=> ["id2name", "to_int"]
irb(main):004:0> String.instance_methods.sort - Symbol.instance_methods
=> [ ... (loads)]

hone.methods == Symbol.instance_methods

Bertram

 

[Rick DeNatale]

Hi,

Am Dienstag, 26. Mai 2009, 02:19:29 +0900 schrieb Mk 27:

bob['phone']
bob[hone]

That seems slightly weird, I had assumed the :form is just a shorthand
like %w( =A0). =A0So -- is there anything more that I need to understand
about this distinction?

=A0$ irb
=A0irb(main):001:0> hone.class
=A0=3D> Symbol
=A0irb(main):002:0> 'phone'.class
=A0=3D> String

and

=A0irb(main):003:0> hone.methods.sort - 'phone'.methods
=A0=3D> ["id2name", "to_int"]
=A0irb(main):004:0> String.instance_methods.sort - Symbol.instance_method= s
=A0=3D> [ ... (loads)]

hone.methods =A0=3D=3D =A0Symbol.instance_methods

Strings are mutable, Symbols are immutable.

There is only one instance of a Symbol with a given string 'value' so

(hash1 =3D=3D hash2) iff (hash1.object_id =3D=3D hash2.object_id)

This is the main property of a Symbol, it's used for keys in Hashes
where lookup performance is important (like the method hashes used
internally by Ruby), since it means that Hash#=3D=3D is O(1) and doesn't
depend on the 'length'

The downside is that Symbols can't be garbage collected (at least for
the MRI implementation) in order to preserve the id/value invariant a
list of all string values which have been 'interned' when a Hash has
been created needs to be kept.

In Rails, it's common to see Symbol and String keys used
'interchangeably', but this is only possible because Rails provides a
HashWithIndifferentAccess class which actually uses string keys
internally (because of the GC issue) but allows either to be used as
key arguments to methods.

--=20
Rick DeNatale

Blog: http://talklikeaduck.denhaven2.com/
Twitter: http://twitter.com/RickDeNatale
WWR: http://www.workingwithrails.com/person/9021-rick-denatale
LinkedIn: http://www.linkedin.com/in/rickdenatale

 

[Robert Klemme]

Strings are mutable, ...

Well, most of the time - but sometimes they aren't:

irb(main):001:0> "I am not".freeze.upcase!
RuntimeError: can't modify frozen string
from (irb):2:in `upcase!'
from (irb):2
from /usr/local/bin/irb19:12:in `<main>'
irb(main):002:0>

;-)

Kind regards

robert