Andrea Dallera wrote in post #969438:
> Ruby has both mutable and immutable strings. A mutable string is
> declared as "string". An immutable string is declared as :string and in
> ruby is called a 'symbol'. So, no, there is no way for "string" to
> behave as :string, since that's by design.

This is a very misleading description, so I'll bite.

Strings and Symbols are two completely different things in Ruby. In Ruby 
1.9, Symbols have gained some more string-like behaviour(*), but they're 
still fundamentally different.

Symbols are objects intended for labelling things (e.g. method names, 
hash keys). The main property of Symbols is that there only ever exists 
one Symbol object which represents the same label, i.e. the same 
sequence of characters.(**)

So when your program loads, and it uses the symbol :foo, which hasn't 
been used before, then a new symbol called :foo is created in the symbol 
table. But every other future use of :foo always returns the same 
object.

This makes symbols very cheap to test for equality, because:

* Two symbols are the same iff they have the same object_id
* Two symbols are different iff they have different object_id

So testing equality between :a_very_long_symbol_like_this and 
:another_very_long_symbol is only comparing their object_ids, basically 
two integers.

The property that any future :foo must return the same object_id means 
that the Symbol table is never garbage-collected. A Symbol is for life, 
not just for Christmas.

Strings are collections of bytes/characters. They can be mutated. There 
can be many String objects in the system which contain the same sequence 
of bytes/characters. Therefore, comparing two Strings always has to be 
done byte-by-byte.(***)

In general, what you want is a String. If you're reading data from a 
user (e.g. on STDIN or a web-page POST) then it comes in as a String. 
You can convert a String into a Symbol represented by the same set of 
characters:

   a = "foo"
   b = a.intern    # b = :foo

but this can be a dangerous thing to do if the string you are converting 
came from an untrusted source, because it can lead to a simple 
denial-of-service attack as the user floods your symbol table with 
garbage.

So to summarise, Symbols are used as method names:

  a = 1
  b = a.send(:+, 2)  # b = a + 2

and are often used as hash keys, because the lookup operations are 
cheaper.

  def doit(params)
    puts params[:foo]
    puts params[:bar]
  end

  doit(:foo=>123, :bar=>456)

If coming from a language like C, think of symbols more as enums rather 
than strings, where the programmer is using an easy-to-read label like 
:foo, but the underlying value is actually a number.

HTH,

Brian.


(*) Example from ruby 1.8:
>> :foo.size
NoMethodError: undefined method `size' for :foo:Symbol
  from (irb):2
  from :0

But:

1.9.2-p0 > :foo.size
 => 3

(**) Everything you say about Strings or Symbols in 1.9 has to be 
qualified, because it's such a complex area. Suffice to say, in 1.9 it's 
possible to have two distinct Symbols which are labelled by the same 
series of bytes but with different encodings.

Things are far simpler in ruby 1.8, where bytes are real bytes, and 
small furry creatures from Alpha Centuri are real small furry creates 
from Alpha Centuri.

(***) There are in fact some optimisations whereby two distinct string 
objects can share the same underlying data buffer, with copy-on-write. 
But in general comparing strings needs to compare the buffers.

And even though ruby 1.9 has strings of characters, the comparisons 
*are* done byte-by-byte, not character by character.

-- 
Posted via http://www.ruby-forum.com/.