Eloquent Ruby: Use Symbols to Stand for Something
- The Two Faces of Strings
- Not Quite a String
- Optimized to Stand for Something
- In the Wild
- Staying Out of Trouble
- Wrapping Up
I have to admit that I tend to be a bit anthropomorphic about the technologies I work with. I just can't help but think of all those complex piles of software as somehow alive, each with its own personality—sometimes friendly, sometimes not. Early in my career I imagined FORTRAN as a grouchy old camel—capable of carrying a huge load, but fairly ugly and not a creature you would want to turn your back on. Later on I had this mental image of the -> operator in the C programming language (it dereferences pointers) as an arrow in flight: also very powerful, also nothing to mess with. These days, the colon that precedes every Ruby symbol always makes me think of the eyes peering out from the tilted head of a confused but friendly dog. The key word here is confused—symbols probably have the dubious distinction of being the one bit of syntax that perplexes the greatest number of new Ruby programmers.
In this chapter I am going to try to stamp out all of that confusion and show symbols for what they really are: very simple, useful programming language constructs that are a key part of the Ruby programming style. So let's get started and see why symbols are such handy little mutts to have around.
The Two Faces of Strings
Sometimes a good way to explain a troublesome topic is to engage in a little creative fiction. You start out with an oversimplified explanation and, once that has sunk in a bit, you work your way from there back to the real world. In this spirit, let's start our exploration of symbols with a slight simplification: Symbols are really just strings. This is not as far fetched as it sounds: Think about the string "dog" and its closest symbolic cousin, :dog. The thing that hits you in the face about these two objects is that they both are essentially three characters: a "d", an "o", and a "g".
Strings and symbols are also reasonably interchangeable in real life code: Take this familiar example of some ActiveRecord code, which finds all of the records in the books table: 1
book = Book.find(:all)
The argument to the find method is simply a flag, there to tell find that we want all of the records in the books table—not just the first record, not just the last record, but all of them. The actual value that we pass into Book.find doesn't really matter very much. We might imagine that if we had the time and motivation, we could go into the guts of ActiveRecord and rewrite the code so that we could use a string to signal that we wanted all the books:
book = Book.find('all')
So there is my simplified explanation of symbols: Other than the fact that typing :all requires one less keystroke than typing 'all', there is not really a lot to distinguish a symbol from a string. So why does Ruby give us both?