Symbol

在Ruby中symbol是Symbol类的实例。symbol的语法为一个冒号后面接一个标识符。

symbol就像一个字符串，它表示了一个字符序列。它不像字符串，每个symbol只有一个实例(和Fixnum一样)。因此，有一个内存或
性能问题需要弄清楚。例如，在下面的代码中，"foo"字符串以三个单独的对象存储在内存中，但是symbol :foo作为一个单独的对
象存储(被引用了多次):

Java代码

1. array = ["foo", "foo", "foo", :foo, :foo, :foo]  

array = ["foo", "foo", "foo", :foo, :foo, :foo]

有些人被symbol前面的冒号弄糊涂了。其实没有必要糊涂；这只是一个简单的语法形式。字符串，数组和哈希都有开始和结束界定
符；而symbol只有一个开始界定符。把它当成一个单界定符而不是二元界定符即可。开始时你可能认为这个语法很奇怪，但事实上
没有什么神秘的。

值得注意的是在老版本的Ruby(1.6之前)中，symbol常量不是第一类对象而是转换成Fixnum来存储。现在在内核中这仍然是对的；
symbol对应于一个数字并作为一个immediate value来存储。这个值可以使用to_i来得到，但是没有必要。

根据Jim Weirich，symbol是"有名字的对象"。Austin Ziegler更喜欢说"an object that is a name"。无论怎样，在symbol和名字
间始终有一个一对一的对应。什么样的东西我们需要使用名字？例如变量，方法和任意的常量。

一个常见的symbol使用场景是表示变量或方法的名字。例如，我们知道如果我们想添加一个读/写属性到类中，我们可以这样做:

Java代码

1. class SomeClass  
2.   attr_accessor :whatever  
3. end  

class SomeClass
  attr_accessor :whatever
end

这等价于:

Java代码

1. class SomeClass  
2.   def whatever  
3.     @whatever  
4.   end  
5.   def whatever=(val)  
6.     @whatever = val  
7.   end  
8. end  

class SomeClass
  def whatever
    @whatever
  end
  def whatever=(val)
    @whatever = val
  end
end

换句话说，:whatever这个symbol告诉attr_accessor方法"getter"和"setter(以及实例变量)都将根据该symbol来给予名字。

你可能想问为什么我们不能使用一个字符串来替代。我们可以。大部分希望使用symbol的核心方法都可以使用字符串来替代。

Java代码

1. attr_reader :alpha  
2. attr_reader "beta"   # This is also legal  

attr_reader :alpha
attr_reader "beta"   # This is also legal

事实上，symbol就"像"一个字符串，它对应于一个字符序列。这导致有些人说"a symbol is just an immutalbe string"。
但是，Symbol类并不是继承于String，并且对于字符串典型的操作并不适合symbol。

另一个误解是认为symbol没必要直接对应于标识符。这导致有些人说"the symbol table"(as they would in referring to
an assembled object program)。但是这不是一个真正有用的概念；尽管在内部symbol存储在一种table里，Ruby并没有将
这个table作为一个实体暴露给我们访问，而我们作为编程者也不关心它的存在。

而且，symbol不需要看起来像标识符。虽然它们像标识符，但是它们也可以包含标点，如果它们被引号包围的话。如下也是
合法的Ruby symbol:

Java代码

1. sym1 = :"This is a symbol"  
2. sym2 = :"This is, too1"  
3. sym3 = :")(*&^%$"             # and even this  

sym1 = :"This is a symbol"
sym2 = :"This is, too1"
sym3 = :")(*&^%$"             # and even this

你甚至可以使用这些symbol来定义实例变量和方法，但是这样的话你需要send和instance_variable_get技术来引用它们。
一般来说不推荐使用字符串形式的symbol。

Symbols As Enumerations
Pascal以及后期版本的C等语言有一个enumerated type的概念。Ruby没有这样的东西；Ruby没有类型检查。但是symbol
非常有用；我可以用:north，:south，:east和:west来表示方向。

将这些symbol存储为常量可能更清晰。

Java代码

1. North, South, East, West = :north, :south, :east, :west  

North, South, East, West = :north, :south, :east, :west

如果它们是字符串而不是symbol，将它们定义为常量会节省内存，但无论如何每个symbol都只在对象空间里存在一次。
(像Fixnum一样Symbol存储为immediate value)

Symbols As Metavalues
我们经常使用异常来作为避免返回代码的方式。但是如果你宁愿使用返回代码的话也可以。RUby的方法不限于单返回类型，
这让传回"out of band"值成为可能。

我们经常需要这样的值。ASCII NUL字符被认为根本就不是一个字符。C有NULL指针，Pascal有nil指针，SQL有NULL等等。
Ruby当然也有nil。

这些metavalue的问题是它们成为合法的值。现在每个人都认为NUL是一个ASCII字符。在Ruby中，nil不是真的non-object；
它可以被存储和操作。这样我们有了如hash[key]返回nil这样的小烦恼；是因为key没有找到而返回nil，还是由于这个key
真的指向nil?

这里symbol可以用来作为好的metavalue。假设一个方法从忘了攫取一个字符串(可能通过http或其他类似的东西)。我们可以
返回非字符串值来表示出现异常。

Java代码

1. str = get_string  
2. case str  
3.   when String  
4.     # Proceed normally  
5.   when :eof  
6.     # end of file, socket closed, whatever  
7.   when :error  
8.     # I/O or network error  
9.   when :timeout  
10.     # didn't get a reply  
11. end  

str = get_string
case str
  when String
    # Proceed normally
  when :eof
    # end of file, socket closed, whatever
  when :error
    # I/O or network error
  when :timeout
    # didn't get a reply
end

这比使用异常更好或更清晰?没必要。但是记住，这是处理可能为"edge cases"但不一定是异常的条件时的一项技术。

Symbols, Variables, and Methods
可能使用symbol的最知名的地方是定义类的属性:

Java代码

1. class MyClass  
2.   attr_reader :alpha, :beta  
3.   attr_writer :gamma, :delta  
4.   attr_accessor :epsilon  
5.   # ...  
6. end  

class MyClass
  attr_reader :alpha, :beta
  attr_writer :gamma, :delta
  attr_accessor :epsilon
  # ...
end

attr_accessor使用symbol名字来觉得实例变量和读写方法的名字。这不代表symbol和实例变量名之间有绝对的关系。
例如，如果你使用instance_variable_set，我们必须指定变量的名字，包括@符号:

Java代码

1. sym1 = :@foo  
2. sym2 = :foo  
3. instance_variable_set(sym1, "str")   # Works  
4. instance_variable_set(sym2, "str")   # errors  

sym1 = :@foo
sym2 = :foo
instance_variable_set(sym1, "str")   # Works
instance_variable_set(sym2, "str")   # errors

简短来说，传递到attr系列方法的symbol只是一个参数，这些方法基于symbol的值创建需要的实例变量和方法。(writer方法
在结尾有一个=，而实例变量名字在前面有一个@。)换句话说，symbol必须与它引用的标识符相对应。

大部分情况下，希望使用symbol的方法也可以使用字符串。相反则不一定正确。

Converting to/from Symbols
字符串和symbol可以使用to_s和to_sym方法自由互换:

Java代码

1. a = "foobar"  
2. b = :foobar  
3. a == b.to_s   # true  
4. b == a.to_sym   # true  

a = "foobar"
b = :foobar
a == b.to_s   # true
b == a.to_sym   # true

如果你做元编程，如下方法有时候可能很有用。

Java代码

1. class Symbol  
2.   def +(other)  
3.     (self.to_s + other.to_s).to_sym  
4.   end  
5. end  

class Symbol
  def +(other)
    (self.to_s + other.to_s).to_sym
  end
end

上面的方法允许我们连接symbol(或者添加字符串到一个symbol)。下面是一个使用它的例子；这段微小的代码接收一个symbol并
尝试告诉我们它是否是一个accessor(即，读写方法都存在):

Java代码

1. class Object  
2.   def accessor?(sym)  
3.     return (self.respond_to?(sym) and self.respond_to?(sym+"="))  
4.   end  
5. end  

class Object
  def accessor?(sym)
    return (self.respond_to?(sym) and self.respond_to?(sym+"="))
  end
end

我这里要提到一个使用symbol的聪明的方式。当我们做map操作时，有时候一个复杂的block可能附加在后面。但是许多情况下，
我们对每个元素简单的调用一个方法:

Java代码

1. list = words.map { |x| x.capitalize }  

list = words.map { |x| x.capitalize }

在这里，似乎我们为完成工作做了太多事情。让我们打开Symbol类并定义to_proc方法。这保证任何symbol都可以强制转换成
一个proc对象。但是我们应该返回什么proc?显然应该根据对象context里的symbol本身。换句话说，proc应该将symbol本身作
为一个消息发送给对象。

Java代码

1. def to_proc  
2.   proc { |obj, *args| obj.send(self, *args) }  
3. end  

def to_proc
  proc { |obj, *args| obj.send(self, *args) }
end

顺便提一下，这段代码来自Gavin Sinclair的"Ruby Extensions"对象。有了这个方法，我们可以重写上面的代码:

Java代码

1. list = words.map(&:capitalize)  

list = words.map(&:capitalize)

值得花费一分钟来理解它怎样工作。map方法使用一个block作为参数。&符号允许我们传递一个proc而不是一个显式附加的
block。由于我们在一个非proc对象上使用&符号，解释器会尝试调用该对象的to_proc方法。返回的proc替代了显式的block，
map将会对每个元素调用它。为什么self作为一个消息传递给array元素有意义呢?这是因为proc是一个闭包，所以它会记住
它被创建在哪个context里。当它被创建时，self表示调用to_proc的symbol。