Why Use Symbols?

Some methods in the Ruby class library specify symbols as arguments. Naturally, if you need to call those methods, you are obliged to pass symbols to them. Other than in those cases, however, there is no absolute requirement to use symbols in your own programming. For many Ruby programmers, the “conventional” data types such as strings and integers are perfectly sufficient. However, many Ruby programmers do like to use symbols as the keys into hashes. When you look at the Rails framework in Chapter 19, for example, you will see examples similar to the following:

{ :text => "Hello world" }

Symbols do have a special place in “dynamic” programming, however. For example, a Ruby program is able to create a new method at runtime by calling, within the scope of a certain class, define_method with a symbol representing the method to be defined and a block representing the code of the method:

add_method.rb

class Array
    define_method( :aNewMethod, lambda{
        |*args| puts( args.inspect)
    } )
end

After the previous code executes, the Array class will have gained a method named aNewMethod. You can verify this by calling method_defined? with a symbol representing the method name:

Array.method_defined?( :aNewMethod )   #=> true

And, of course, you can call the method itself:

[].aNewMethod( 1,2,3     #=> [1,2,3]

You can remove an existing method at runtime in a similar way by calling remove_method inside a class with a symbol providing the name of the method to be removed:

class Array
    remove_method( :aNewMethod )
end

Dynamic programming is invaluable in applications that need to modify the behavior of the Ruby program while that program is still executing. Dynamic programming is widely used in the Rails framework, for example, and it is discussed in depth in the final chapter of this book.

Digging Deeper

Symbols are fundamental to Ruby. Here you will learn why that is so and how you can display all the symbols available.

What Is a Symbol?

Previously, I said that a symbol is an identifier whose value is itself. That describes, in a broad sense, the way that symbols behave from the point of view of the Ruby programmer. But it doesn’t tell you what symbols are literally from the point of view of the Ruby interpreter. A symbol is, in fact, a pointer into the symbol table. The symbol table is Ruby’s internal list of known identifiers—such as variable and method names.

If you want to take a peek deep inside Ruby, you can display all the symbols that Ruby knows about like this:

allsymbols.rb

p( Symbol.all_symbols )

This will shows thousands of symbols including method names such as :to_s and :reverse, global variables such as :$/ and :$DEBUG, and class names such as :Array and :Symbol. You may restrict the number of symbols displayed using array indexes like this:

p( Symbol.all_symbols[0,10] )

In Ruby 1.8, you can’t sort symbols since symbols are not considered to be inherently sequential. In Ruby 1.9, sorting is possible, and the symbol characters are sorted as though they were strings:

# In Ruby 1.9
p [:a,:c,:b].sort       #=> [:a,:b,:c]

# In Ruby 1.8
p [:a,:c,:b].sort       #=> 'sort': undefined method '<=>' for :a:Symbol

The easiest way to display a sorted list of symbols in a way that avoids incompatibility problems related to Ruby versions is to convert the symbols to strings and sort those. In the following code, I pass all the symbols known to Ruby into a block, convert each symbol to a string, and collect the strings into a new array that is assigned to the str_array variable. Now I can sort this array and display the results:

str_arr = Symbol.all_symbols.collect{ |s| s.to_s }
puts( str_arr.sort )
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.145.12.156