Ruby 語法放大鏡之「有的變數變前面有一個冒號(例如 :name)，是什麼意思?」

Apr 25th, 2016 8:09 am

「Ruby 語法放大鏡」系列短文主要是針對在大家學習 Ruby 或 Rails 時看到一些神奇但不知道用途的語法介紹，希望可以藉由這一系列的短文幫大家更容易的了解到底 Ruby 或 Rails 是怎麼回事。

隨便打開一個 Rails 專案，應該都看過類似像這樣的內容：

class User < ActiveRecord::Base
  has_many :products
  validates :name, presence: true
end

class Product < ActiveRecord::Base
  belongs_to :user
end

或是

class ProductController < ApplicationControl
  before_action :find_product

  # .. 中略

  private
  def find_product
    @product = Product.find_by(id: params[:id])
  end
end

這在 Rails 專案裡是很常見的寫法，但這裡 :products、:user、:name 以及 :find_product 是什麼意思呢? 用一般的字串或變數不行嗎?

這可能是在大部份的人在學習 Ruby / Rails 的時候覺得困擾的問題。這東西在 Ruby 裡稱之 Symbol，中文翻譯做符號，它的寫法是在前面加上個冒號。

常見的 Symbol 的命名規則跟一般的變數差不多，是以用英文字母或數字的組合，例如 :name 或 :title，非英文也可以，像是 :姓名、:おはよう也行，甚至要在中間加上空白也沒問題，如果要使用空白字元的話，會需要用引號包起來，例如 :"hello world"。不過以使用頻率來說，大多還是以英文字母的組合為主。

Symbol 是什麼

Symbol 其實是有點玄的東西，有些人認為它就是的變數，或就是只是個名字，但事實上它不就是變數或名字這麼簡單，你可以想像它是一個「帶有名字的物件」：

>> :name.class
=> Symbol

Symbol 就是一個 Symbol 類別的實體(廢話)，它可用來表示某個狀態，例如我在 Objective-C 如果想要比對訂單的狀態，可能會這樣寫：

#define OrderStatusPending    0
#define OrderStatusProcessing 1
#define OrderStatusComplete   2

或是寫成 Enum，像這樣：

enum OrderStatus {
    OrderStatusPending    = 0,
    OrderStatusProcessing = 1,
    OrderStatusComplete   = 2
};

然後可以用來比對：

if (order.status == OrderStatusPending) {
    NSLog(@"order is pending");
}

在 Ruby 也可以做類似的事，但不需要特別定義或宣告，因為 Symbol 本身就是一個「帶有名字的物件」，來一段簡單的範例：

class Order
  attr_reader :status

  def initialize(items, status = :pending)
    @items = items
    @status = status
  end

  def compete
    @status = :complete
  end
end

order = Order.new(["item A", "item B", "item C"])

if order.status == :pending
  puts "order is pending"
end

你也許會好奇這裡的 :pending 跟 :complete 是什麼? 其實它就是代表 pending 跟 complete 這兩個狀態，前面提到 Symbol 是一種「帶有名字的物件」，正如其名，Symbol 就是符號，這個符號表示「已完成」或「未完成」。

那.. 上面這個例子，把 Symbol 改用字串可以嗎? 當然是可以的。

Symbol 跟變數有什麼不同?

變數是一個指向某個物件的名字，例如：

greeting = "Hello Ruby"

上面這行語法，是指 greeting 這個名字指向 "Hello Ruby" 這個字串物件，但如果沒有 "Hello Ruby" 這個字串給它指，這個名字本身是沒辦法單獨存在的。

而 Symbol 是一個「帶有名字的物件」，本身不需要指向任何東西也可以拿來用，例如上面的 :pending 跟 :complete 的例子。

事實上，你也沒辦法直接拿 Symbol 來當變數，像這樣會出現語法錯誤：

>> :name = "見龍"
>> SyntaxError: (irb):27: syntax error, unexpected '=', expecting end-of-input :name = "見龍"

其實，當你宣告一個變數，例如：

my_name = "見龍"

Ruby 會偷偷的新增一個叫做 :my_name 的 Symbol，打開 irb 來試試：

# 使用 all_symbols 方法可以列出目前共有幾個 symbol
# 隨著 Ruby 版本的不同以及載入的模組不同，算出來的數字會不同
>> Symbol.all_symbols.count
=> 3489

# 這裡定義了一個叫做 my_name 的區域變數
>> my_name = "見龍"
=> "見龍"

# 算一下，symbol 的數量多一個了
>> Symbol.all_symbols.count
=> 3490

# 檢查一下，發現它偷偷的出現在 symbol 列表裡了
>> Symbol.all_symbols.map(&:to_s).include?("my_name")
=> true

事實上，定義一個新的類別或是方法也都會產生新的 Symbol 喔 :)

Symbol 跟字串有什麼不同?

上課時候最常被問到的問題之一，就是「Symbol 跟字串有什麼不一樣?」

字串的內容可以變，但 Symbol 不行

簡單的說，Symbol 跟字串有點像，Symbol 也有一些跟字串長得很像的方法，例如 length、upcase、downcase 等等。不過 Symbol 本身是不能被修改的，但字串可以。一樣開 irb 來試試：

# 像字串一樣的操作
>> :hello.length
=> 5
>> :hello.upcase
=> :HELLO

# 假設有個 hello 字串，可以使用中括號 + 索引來取得其中某個字元
>> "hello"[0]
=> "h"
>> "hello"[3]
=> "l"

# Symbol 也行
>> :hello[0]
=> "h"
>> :hello[3]
=> "l"

# 這回來試著修改某個字母，例如想把 h 換成 k
>> "hello"[0] = "k"
=> "k"

# 但在 Symbol 上卻行不通，會發生錯誤 (因為 Symbol 類別並沒有 []= 這個方法)
>> :hello[0] = "k"
NoMethodError: undefined method `[]=' for :hello:Symbol'`

所以，其實你也可以把 Symbol 看做是一種「不可變(immutable)的字串」。

字串的效能稍微差一些

在 Ruby 裡，每次要產生一個新的字串的時候，它會都向去要一塊新的記憶體，來看看這個例子：

5.times do
  puts "hello".object_id
end

# => 70199659402580
# => 70199659366640
# => 70199659366560
# => 70199659366500
# => 70199659366420

object_id 方法會取得該物件在 Ruby 世界裡的唯一的數字編號，在不同的電腦或不同的 Ruby 版本所得到的結果可能會不太一樣。

相同的物件會有相同的 object id，不同的物件則會有不同的 object id。從上面這個例子可以發現，即使一樣都是 "hello" 字串，Ruby 每次在產生字串的時候都會產生一個新的 object id，表示它們是在記憶體裡其實是不同的 5 個物件。

但 Symbol 就不同了：

5.times do
  puts :hello.object_id
end

# => 899228
# => 899228
# => 899228
# => 899228
# => 899228

只要是一樣的 Symbol，就會有相同的 object id，表示他們是同一顆東西，當 Ruby 第二次要取用同一個 Symbol 的時候，它會直接從記憶體裡拿，而不用重新產生一份，所以 Symbol 相對的較節省記憶體。

雖然說相對的節省記憶體，但在 Ruby 2.2 之前，Symbol 所佔用的記憶體沒辦法被自動回收，要釋放掉 Symbol 所佔用的記憶體只能重新啟動應用程式，所以如果大量的產生 Symbol 的話有可能會造成 memory leak 的問題。Ruby 2.2 之後加入了 Symbol GC(Garbage Collection) ，那些動態用 to_sym 或 intern 等方法長出來的 Symbol 就可以跟一般物件一樣被回收了。

參考連結：Symbol GC

附帶一提，如果把字串給"冰凍"(freeze)起來，讓它變成不可修改的話，它的 object id 也會是同樣的。

5.times do
  puts "hello".freeze.object_id
end

# => 70314415546380
# => 70314415546380
# => 70314415546380
# => 70314415546380
# => 70314415546380

Symbol 的比較(Comparison)比字串快

直接寫一段 benchmark，讓它跑個 1 億次看看結果：

require 'benchmark'
loop_times = 100000000

str = Benchmark.measure do
  loop_times.times do
    "hello" == "hello"
  end
end.total

sym = Benchmark.measure do
  loop_times.times do
    :hello == :hello
  end
end.total

puts "Benchmark"
puts "String: #{str}"
puts "Symbol: #{sym}"

# => Benchmark
# => String: 12.299999999999999
# => Symbol: 5.750000000000002

Symbol 的處理速度明顯比字串快得多，那是因為 Symbol 在做比較的時候，是直接比對這兩顆物件的 object id 是不是相同，讓我們挖 Ruby 的原始碼出來看看。這是 Symbol 在處理比較時候的 function：

// 檔案：object.c

VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
  if (obj1 == obj2) return Qtrue;
  return Qfalse;
}

再讓我們挖看看字串是怎麼做比較的：

// 檔案：string.c

static VALUE
str_eql(const VALUE str1, const VALUE str2)
{
  const long len = RSTRING_LEN(str1);
  const char *ptr1, *ptr2;

  if (len != RSTRING_LEN(str2)) return Qfalse;
  if (!rb_str_comparable(str1, str2)) return Qfalse;
  if ((ptr1 = RSTRING_PTR(str1)) == (ptr2 = RSTRING_PTR(str2)))
    return Qtrue;
  if (memcmp(ptr1, ptr2, len) == 0)
    return Qtrue;
  return Qfalse;
}

猜得出來它的比較是一個字母一個字母逐一比對。

所以在效能上來說，字串在做比較的時間複雜度會隨著字母的數量(N)而增加，所以它的時間複雜度是 O(N)，但 Symbol 的比較因為只比較是不是同一顆物件，所以它的複雜度是固定的 O(1)。

字串跟 Symbol 是可以互相轉換的

字串及 Symbol 類別都有提供一些方法可以互相轉換，例如：

# 使用 to_sym 可把字串轉成 symbol
>> "name".to_sym
=> :name

# intern 方法比較不常看到其它人用(因為這個方法看起來不怎麼直覺)，但其實跟 to_sym 是一樣的效果
>> "name".intern
=> :name

# 另外也可用 %s 來做轉換
>> %s(name)
=> :name

# 用 to_s 方法可以把 symbol 轉成字串
>> :name.to_s
=> "name"

# 還有個不常用但功能跟 to_s 一樣的方法
>> :name.id2name
=> "name"

使用時機

講這麼多，那到底什麼時候該用 Symbol，什麼時候該用字串?

Hash 裡的 Key

>> profile = { name: "見龍", age: 18 }
=> {:name=>"見龍", :age=>18}

這裡的 :name 跟 :age 就是 Symbol，詳細內容可參考這篇。

因為 Symbol 不可變(immutable)的特性，以及它的查找、比較的速度比字串還快，它很適合用來當 Hash 的 Key。

字串的方法比較多、比較好用

雖然也是可以把 Symbol 當字串用，但畢竟 Symbol 類別內建的方法不像字串類別那麼豐富，所以如果你想要用字串那些好用的功能，就選擇用字串而不要選擇 Symbol。

又，如果你只是想在畫面上把內容印出來，那就選用字串，是因為 Symbol 被輸出的時候，還是會先轉型成字串，所以效能就又差了那麼一點點。

要怎麼知道那些方法的參數是要使用字串還是使用 Symbol?

先看個例子：

class Cat
  attr_accessor :name
end

kitty = Cat.new
kitty.name = "Nancy"
puts kitty.name       # => Nancy

如果把 attr_accessor :name 換成 attr_accessor "name" 一樣可以正常運轉。

有的方法的參數是用字串，有的是用 Symbol，有的是兩種都能用，那該怎麼知道該用哪一種?

答案很簡單，就是，看．手．冊!! 就是 RTFM 啦! 遇到不知道怎麼用的，去查它的 API 手冊最直接了

Ruby 黑魔法

最後來玩一點 Ruby 的黑魔法! 如果我想要挑出 1 到 100 之間所有的單數，可以這樣寫：

# 使用陣列的 select 方法搭配 block 可以輕鬆完成
>> [*1..100].select { |i| i.odd? }
=> [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, ... 97, 99]

# 但後面那個 block 也可再簡寫成這樣
>> [*1..100].select(&:odd?)
=> [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, ... 97, 99]

那個 :odd? 也是個 Symbol 喔! 為什麼可以這樣寫.. 嗯，這又是 Ruby 的黑魔法之一，不過離本次主題有點遠，我們有機會再另外寫一篇來解釋。

小結

Symbol 可以說是個簡單但又不太簡單的東西，希望這篇文章可以稍微幫大家稍微釐清一些觀念。如果上述內容有誤，或是還有不清楚的地方，歡迎在底下留言、指教。

Ruby 語法放大鏡之「為什麼 Hash 好像有不同的寫法?」

Apr 23rd, 2016 1:09 pm

在 Ruby 裡的 Hash 的寫法，是用一個大括號，裡面是一堆 key 跟 value 的配對組合，一個蘿蔔一個坑，就像這樣：

profile = { :name => "見龍", :age => 18, :title => "紅寶石鑑定商" }

在 Ruby 1.9 之後，Ruby 提供了另一款類似 JSON 格式的 Hash 寫法，上面這行可以改寫成這樣：

profile = { name: "見龍", age: 18, title: "紅寶石鑑定商" }

少了 =>，改用 : 並且把 key 前面的冒號也移掉了，看起來好像比較清爽一點。但不管是舊式或是新式的 Hash 寫法，本質上並沒有改變，新式寫法其實只是語法糖衣而已，不信可試著把它印出來看看：

puts profile       # => {:name=>"見龍", :age=>18, :title=>"紅寶石鑑定商"}

會得到跟舊式寫法一樣的結果。所以，如果想要取得 profile 這個 Hash 的內容，還是得用 Symbol 來存取，使用字串會取得不正確結果：

puts profile[:name]      # => 見龍
puts profile["name"]     # => nil

puts profile[:title]     # => 紅寶石鑑定商
puts profile["title"]    # => nil

但我在寫 Rails 的時候好像都可以耶…

隨便打開一個 Rails 專案的 Controller，你可能會看過像這樣的程式碼：

class ProductionController < ApplicationController
  def show
    @product = Product.find(params[:id])
  end
end

這裡不管你是用 params[:id] 或是 params["id"]，都可以拿到你要的結果。

怎麼辦到的? 我們直接在 show action 裡放個中斷點看看，順便來練習怎麼追程式碼：

[9, 19] in /private/tmp/blog/app/controllers/products_controller.rb
    9:
   10:  # GET /products/1
   11:  # GET /products/1.json
   12:  def show
   13:    @product = Product.find(params[:id])
=> 14:    debugger
   15:  end
   16:
   17:  # GET /products/new
   18:  def new
   19:    @product = Product.new

# 先看一下 params 的內容
(byebug) params
<ActionController::Parameters {"controller"=>"products", "action"=>"show", "id"=>"1"} permitted: false>

 # 很好，這個 params 看起來像是一個 Hash
 # 而且它是用字串當做 key，讓我們試著用字串來取值...
(byebug) params["id"]
"1"

# 用 Symbol 也可以
(byebug) params[:id]
"1"

# 來看看這個 params 是什麼東西...
(byebug) params.class
ActionController::Parameters

# 繼續來挖看看這個取值的 [] 方法放在哪兒...
(byebug) params.method("[]".to_sym)
#<Method: ActionController::Parameters#[]>

(byebug) params.method("[]".to_sym).source_location
["/Users/user/.rvm/gems/ruby-2.3.0/gems/actionpack-5.0.0.beta3/lib/action_controller/metal/strong_parameters.rb", 400]

抓到了! 就讓我們打開這個 strong_parameters.rb 檔案的第 400 行，繼續追：

def [](key)
  convert_hashes_to_parameters(key, @parameters[key])
end

嗯…這個 @parameters 是怎麼來的? 發現在 initialize 方法裡有寫到：

def initialize(parameters = {})
  @parameters = parameters.with_indifferent_access
  @permitted = self.class.permit_all_parameters
end

原來，@parameters 是呼叫了 Hash 類別的 with_indifferent_access 方法所做出來的。但這個方法並不是 Ruby 內建的，而是 Rails 幫 Hash 做的擴充功能。

Rails 幫 Ruby 的 Hash 加了一個 ActiveSupport::HashWithIndifferentAccess 類別，讓開發者在取存 Hash 的時候可以使用 Symbol (例如：params[:id]) 也可以使用字串 (例如：params[“id”])，畢竟在其它程式語言不見得有 Symbol 的設計，這樣的擴充可以讓從別的程式語言轉過來的新朋友比較能習慣。

如果對 ActiveSupport::HashWithIndifferentAccess 的內容有興趣，可以點這裡看看它是怎麼做到的。

我們開 irb 來玩一下：

>> require "active_support/core_ext/hash/indifferent_access"
=> true

# profile 是一般的 Hash
>> profile = {name: "見龍", age: 18, title: "紅寶石鑑定商"}
=> {:name=>"見龍", :age=>18, :title=>"紅寶石鑑定商"}

# 用字串拿不到
>> profile["name"]
=> nil

# 要用 Symbol 才可以
>> profile[:name]
=> "見龍"

# 用 with_indifferent_access 做一個新的 new_profile
>> new_profile = profile.with_indifferent_access
=> {"name"=>"見龍", "age"=>18, "title"=>"紅寶石鑑定商"}

# 用字串可以
>> new_profile["name"]
=> "見龍"

# 用 Symbol 也可以
>> new_profile[:name]
=> "見龍"

所以，下回在存取 Hash 裡的東西的時候，要記得要拿正確的 key 喔 :)

新網址，連載再開!

Apr 23rd, 2016 3:00 am

好可怕，時間過得好快，一年一下子就過去了。這一年來忙公司、社群、校園推廣的事，結果一整年都沒更新 Blog! (藉口)

給自己買了個新的 domain，重新繼續連載，希望不會再富堅了!

Ruby 語法放大鏡之「有時候會看到有兩個冒號寫法是什麼意思?」

Apr 19th, 2015 6:09 pm

隨便打開你 Rails 專案裡的 model 檔案，它可能會長得像這樣：

class Post < ActiveRecord::Base
  belongs_to :user
  belongs_to :category
end

第一行後面那個 ActiveRecord::Base 裡面的 2 個冒號 ::，各位知道是什麼意思嗎?

菜市場名

也許你也叫金城武(或自己覺得自己長得像金城武)，然後我也剛好也很巧叫金城武，這樣在大街上大叫一聲帥哥就一堆人回頭了，不太好。

寫程式偶爾也會遇到這樣的狀況，舉例來說，如果大家剛好都有一個叫做 Animal 的類別或是 Flyable 的模組，放在同一個專案裡就會打架了。所以 Ruby 有設計 namespace 來解決這個問題。

在 Ruby 裡，因為 module 或 class 可以有巢狀結構(類別裡可以包模組，模組裡面可以包類別，就是大腸包小腸的概念啦)，剛好可以拿來做 namespace 的包裝，例如：

module Utility
  module Flyable
    def fly
      # ....
    end
  end
end

這樣一來，如果要使用 Flyable 這個類別的話：

class Cat
  include Utility::Flyable
end

要 include 那個 Flyable 模組，就必須連名帶姓的 include，也就是「樹林::金城武」、「三重::劉德華」的概念。

除此之外，其實你也可把常數包在 namespace 裡：

module Utility
  TaxRate = 10
  module Flyable
    Speed = 20
    def fly
      # ....
    end
  end
end

puts Utility::TaxRate          # => 10
puts Utility::Flyable::Speed   # => 20

要使用這些常數，也是一樣要提供完整的路徑給才行。(如果你知道的話，其實不管是類別或模組，它們的名字基本上也就是常數而已)

所以，原來這段程式範例：

class Post < ActiveRecord::Base
  belongs_to :user
  belongs_to :category
end

它的意思就是說有一個叫做 Post 的類別，它是繼承自某個放在 ActiveRecord 的模組(或類別)裡的 Base 類別。如果去 github 上翻 Rails 的原始碼的話(連結)，應該可以看到這段：

module ActiveRecord
  # .....
  # 中略
  # .....
  class Base
    extend ActiveModel::Naming
    extend ActiveSupport::Benchmarkable
    extend ActiveSupport::DescendantsTracker

    extend ConnectionHandling
    extend QueryCache::ClassMethods
    # ... 略
  end
end

的確是有一個 ActiveRecord 的模組，裡面包了一個 Base 的類別沒錯 :)

Ruby 語法放大鏡之「類別跟模組有什麼不一樣?」

Mar 24th, 2015 12:09 pm

在網路上常看到一些介紹 Ruby 裡類別(class)跟模組(module)的差別，有人說他們兩個差別很大，是完全不同的東西。事實上，類別跟模組是很像的。可能很多人不知道，類別跟模組是有血緣關係的，如果你試著這樣做：

puts Class.superclass

你會得到 Module 這個類別。也就是說，在 Ruby 裡，「類別」其實就是「模組」的後代，類別根本就是繼承自模組來的。既然是同一個體系，自然沒有太多的差異。

那差別是什麼?

最明顯的差別，當然就是一個是用 class 來定義，一個是用 module 來定義。至於前、後代功能上的差別，我們只要寫幾行簡單的程式就可以看得出來：

# 前、後代的類別方法差異：
p Class.methods - Module.methods

# 或直接這樣寫：
p Class.methods(false)

上面這段會得到 [] (空陣列)，表示他們在類別方法上並沒有差別。再來看看實體方法的差別：

# 前、後代的實體方法差異：
p Class.instance_methods - Module.instance_methods

# 或直接這樣寫：
p Class.instance_methods(false)

會得到以下結果：

[:allocate, :new, :superclass]

其中，allocate 跟 new 跟產生實體(instance)有關，superclass 跟繼承有關。

也就是說，類別比模組多了可以「產生實體」的能力以及「繼承」的能力。

那用途上有什麼差別?

請大家先思考一個問題：「如果我有一個小貓類別，我希望這個小貓會飛，你會怎麼做?」

直接寫一個有飛行功能的小鳥類別，然後再叫小貓類別去繼承它?
直接把飛行功能寫在小貓類別裡?

第 1 種做法的設計有點怪怪的，好好的貓不當，為什麼要去當鳥? 為了想要有飛行功能就去當別人家的小孩…

第 2 種做法看來似乎可行，但如果之後又有個「我希望我的這個小狗類別也會飛!」的需求，那這樣又得在小狗類別裡寫一段飛行功能，程式碼沒辦法共同。

這時候，模組就可以派上用場了。

module Flyable
  def fly
    puts "I can fly!"
  end
end

class Cat
  include Flyable
end

kitty = Cat.new
kitty.fly        # => I can fly!

在上面這段範例中，我做了一個飛行模組(Flyable)，然後小貓類別不用特別寫什麼功能，就只要把這個飛行模組掛上去(include)就搞定了。

如果之後小狗類別也想要會飛的話，只要這樣：

class Dog
  include Flyable
end

小狗也會飛了。

要用繼承還是要用模組?

基本上，如果你發現你要做的這個功能，它可能在很多不同體系的類別裡都會用得到，那你可以考慮把功能包在模組裡，然後在必要的時候再 include 進來即可。

如果你還是不知道到底類別跟模組有什麼差別，我再舉二個例子。

不知道大家有沒看過火影忍者這部漫畫，漫畫裡的主人公之一，宇智波佐助，因為他們家族血統的關係，他寫輪眼這個功能是天生就有的，這個功能是從他的家族「繼承」來的。而佐助的老師，旗木卡卡西，他雖然也有寫輪眼功能，但他的寫輪眼並非繼承來的，事實上是他在年輕時候 include 了某個寫輪眼模組，所以才有這個效果。

另一個例子，海賊王漫畫裡，魯夫本來是普通人，但在偶然的機會下，他 include 了橡膠果實之後，他就有了橡膠人的能力了，並不是因為他老爸是橡膠人所以他才是橡膠人。

以上，希望能讓大家在使用類別跟模組時有更進一步的認識 :)