(轉)理解 Ruby Symbol－互聯網 - 大數據

Symbol 是什么

　　Ruby 是一個強大的面向對象腳本語言（本文所用 Ruby 版本為1.8.6），在 Ruby 中 Symbol 表示“名字”，比如字符串的名字，標識符的名字。創建一個 Symbol 對象的方法是在名字或者字符串前面加上冒號：

創建 symbol 對象

:foo
:test

:”abc”

:"I am a boy”

　　你可能會問，字符串就是字符串，干嗎還有字符串的名字？這是因為在 Ruby 中字符串也是一種對象，即 String 對象。無論其結構還是操作和 Symbol 對象都是不同的。在 Ruby 中每一個對象都有唯一的對象標識符（Object Identifier），可以通過 object_id 方法來得到一個對象的標識符。我們來看看 Symbol 對象和 String 對象的差別：

Ruby 對象標識符

irb(main):001:0> puts :foo.object_id
327458
=> nil
irb(main):002:0> puts :foo.object_id
327458
=> nil
irb(main):003:0> puts :"foo".object_id
327458
=> nil
irb(main):004:0> puts "foo".object_id
24303850
=> nil
irb(main):005:0> puts "foo".object_id
24300010
=> nil
irb(main):006:0> puts "foo".object_id
24296170
=> nil

　　可以看到，前三行語句中的 :foo （或者 :"foo"）都是同一個 Symbol 對象，其 object id 為327458，而后三行中的字符串”foo”都是不同的對象，其 object id 依次為24303850、24300010、24296170。

　　可見，每個 String 對象都是不同的，即便他們包含了相同的字符串內容；而對于 Symbol 對象，一個名字（字符串內容）唯一確定一個 Symbol 對象。

值得注意的是創建 Symbol 對象的字符串中不能含有’\0’字符，而 String 對象是可以的。

非法 Symbol 字符串

irb(main):001:0>  :"fo\0o"
SyntaxError: compile error
(irb):1: symbol cannot contain '\0'
        from (irb):1
irb(main):002:0> :"foo\0"
SyntaxError: compile error
(irb):2: symbol cannot contain '\0'
        from (irb):2
irb(main):003:0> puts "foo\0".object_id
24305140
=> nil
irb(main):004:0> puts "fo\0o".object_id
24301000
=> nil
irb(main):005:0>

　　除了可以采用一般的字符串，還可以使用操作符（例如+, -, *, /），變量，常量，方法甚至類的名字來創建 Symbol 對象，例如:+就是一個合法的 Symbol 。實際上，在 Ruby 內部操作符、變量等名字本身就是作為 Symbol 處理的，例如當你定義一個實例變量時， Ruby 會自動創建一個 Symbol 對象，例如 @test 對應為 :@test 。

實例變量的 Symbol

class Test  			
 attr_accessor :test
end

　　這個類定義了一個具有讀寫方法的實例變量 @test 。實際上 Ruby 創建了兩個 Symbol ，一個是實例變量的 symbol :@test ，另一個是 :test 。那如果使用字符串對象 ”test” 作為參數呢？也可以，仍然會創建兩個 symbol ，:test 和 :@test ，為什么還會創建 :test 呢？這是和Ruby的實現相關的（至少Ruby1.8.6里是這樣）。

注意，類變量 @@test 和實例變量 @test 對應的 Symbol 顯然是不同的。記住：名字相同，則Symbol 相同。

名字相同， Symbol 相同

class Test  			
  puts :Test.object_id
  Test = 10
  puts :Test.object_id
  
  def Test  					
    puts :Test.object_id
  end  
end 

Test.new.Test

運行結果

224298
224298
224298

名字不同， Symbol 不同

class Test  			
  puts :Test.object_id

  @@test = 10
  puts :@@test.object_id
  def test  					
    puts :test.object_id
    @test = 10  				
    puts :@test.object_id

  end  
end 

t =Test.new  
t.test

運行結果

　　第一個例子里，類名、常量名和方法名都是 Test ，因此相應的 Symbol 對象都是 :Test 。不用擔心， Ruby 可以很好區分它在不同上下文中到底表示什么。當然這并不是一個好的編程風格，但對于理解 Ruby 的 Symbol 還是有幫助的： Symbol 表示一個名字，僅此而已。

　　Symbol 對象一旦定義將一直存在，直到程序執行退出。所有 Symbol 對象存放在 Ruby 內部的符號表中，可以通過類方法 Symbol.all_symbols 得到當前 Ruby 程序中定義的所有 Symbol 對象，該方法返回一個 Symbol 對象數組。由于 Symbol 比較多，你可以 dump 到文件中來查看。

all_symbols 方法

irb(main):001:0> Symbol.all_symbols.size
=> 4047
irb(main):002:0> Symbol.all_symbols[0..9]
=> [:@level_notifier, :ppx, :msg_dn, :version, :secs, :@user, :pos, :socketpair,
 :TkENSURE, :HTTPAccepted]
irb(main):003:0> File.open("sym", "w") do |file| file.puts Symbol.all_symbols end
=> nil

Symbol 和 String

　　Symbol 對象和 String 對象是完全不同的東西，對象標識符很明確的說明了這一點。除此之外，我們還可以從兩種對象的方法上區分。查看 Ruby 庫參考，你會發現 String 類有非常多的方法，包括 Mixed-in 方法（Ruby中一個類通過 include 其他模塊而得到的方法，實現多重繼承的效果）、類方法和實例方法；而 Symbol 類只有一個類方法 all_symbols 和7個實例方法。例如，可以通過 []= 方法改變 string 的內容，而 symbol 則不行：

[]= 方法比較

irb(main):001:0> s="test"
=> "test"
irb(main):002:0> s[0]='1'
=> "1"
irb(main):003:0> puts s
1est
=> nil
irb(main):004:0> sym=:test
=> :test
irb(main):005:0> sym[0]=1
NoMethodError: undefined method `[]=' for :test:Symbol
        from (irb):5
irb(main):006:0>

　　雖然 Symbol 和 String 是不同的對象，但它們之間關系很密切。 Ruby 提供了方法在 Symbol和 String 之間轉換。Symbol 轉化為 String,使用 to_s 或 id2name 方法將 Symbol 轉化為一個 String 對象：

Symbol 到 String

irb(main):001:0> :test.id2name
=> "test"
irb(main):002:0> :test.to_s
=> "test"
irb(main):003:0> :"I am a boy".to_s
=> "I am a boy"

　　注意，每個 String 對象都是唯一的，因此對一個 Symbol 調用多次將產生多個 String 對象。

　　String 轉化為 Symbol,除了在字符串前面加冒號，還可以使用 to_sym 或 intern 方法將 String 轉化為 Symbol ，如果該 Symbol 已經存在，則直接返回。

String 到 Symbol

irb(main):001:0> var1 = "test".to_sym
=> :test
irb(main):002:0> var2 = "test".intern
=> :test
irb(main):003:0> var1 == var2
=> true
irb(main):004:0>

使用 Symbol

　　正如前邊提到的， Ruby 內部一直在使用 Symbol ，比如 Ruby 程序中的各種名字，Symbol本質上是 Ruby 符號表中的東西。使用 Symbol 處理名字可以降低 Ruby 內存消耗，提高執行速度，這點我們在下一篇文章中會看到。

　　那么 Symbol 對我們有什么用呢？當然也是內存。使用 String 的開銷太大了，因為每一個String 都是一個對象。想想前邊的例子，一個字符串每出現一次 Ruby 就會創建一個 String 對象。

　　通常來講，當你面臨 String 還是 Symbol 的選擇時，可以參考以下標準：

如果使用字符串的內容，這個內容可能會變化，使用 String

如果使用固定的名字或者說是標識符，使用 Symbol

　　那么什么時候我們會用到名字呢？很多時候都會，比如枚舉值、關鍵字（哈希表關鍵字、方法的參數）等等;作為哈希表的 key,哈希表是 Symbol 應用最為廣泛的地方。

在ruby中，哈希和數組類似，一個哈希表是一系列 key/value 對的集合，只不過它的 key 取值范圍更廣泛，可以是任何對象，比如正則表達式。但通常我們都會取有意義的 key ，比如 String、Symbol 。

下面這個哈希表表示按城市分類的一些機器的集合。

一個哈希表例子

hosts{
       'beijing' => 'machine1',
       'shanghai'  => 'machine2',
       'guangzhou' => 'machine3',
       'tianjin' =>  'machine4',
       'shenzhen' =>　'machine5'
}

　　如果要引用 beijing 的機器，使用 hosts['beijing'] 。但如果我們程序中要頻繁引用哈希表中 value ，這樣就不大好了，因為 Ruby 對每一次字符串引用都會生成一個 String 對象，累積下來這個開銷是相當大的。

我們完全可以使用 Symbol ，因為對于這些 key 來講，我們用的就是名字而已，例如下面hosts[:beijing]

使用 Symbol 作為 key

hosts　=　{
　:beijing　=>　'machine1',
　:shanghai　=>　'machine2',
　:guangzhou　=>　'machine3',
　:tianjin 　=>　'machine4',
　:shenzhen　=>　'machine5'
}

哈希參數

　　通常我們定義的函數的參數的個數和順序是寫死的，調用函數的時候要確保參數的個數、順序匹配，有時候這樣很不方便，使用哈希參數可以解決這個問題。ROR 中就大量地運用這種方式，也許你已經看到了，到處都是 Symbol 和哈希。比如：

使用哈希參數的方法調用

link_to 'Show', :action => 'show', :id => product

add_column :products, :price, :decimal, 
:precision => 8, :scale => 2, :default => 0

使用哈希參數的方法可以如下定義，前半部分為固定參數，后面為可變參數，或者干脆全采用哈希參數：

哈希參數

def my_method(para1, …, options={})
#your code
end

def my_method(options={})
#your code
end

　　如果你希望設定一些默認參數，并允許調用者更改這些參數，可以使用哈希對象的 merge! 方法, hsh.merge!( other_hash )。該方法將 other_hash 里內容加到 hsh 中，如果other_hash 與 hsh 有重復的 key ，則 key 在 other_hash 中的 value 覆蓋 hsh 中對應 key 的 value 。

方法定義-使用默認參數

class Test
 def my_method(opts={})
  default_opts={:arg1 => 10, :arg2 => "abc"}
  default_opts.merge!(opts)
  default_opts.each{|key,value| puts "#{key} is #{value}"}
 end
end

t = Test.new
t.my_method :arg1=>5, :arg3=>"def"

運行結果