好的物件導向設計很難，我們都很同意何謂好的設計原則：高內聚力(cohesion)、低耦合(loose coupling)、不重複程式(Don’t Repeat Yourselp)、封裝(encapsulation)、可測試性、易閱讀性等等，但是實際寫的時候卻不容易化身為一行行的程式碼。這篇作者列了九條規則，並建議你練習寫個千行程式嚴格遵守看看，用以改善你的OO實作能力。

初次看到這九條絕得有點誇張，但其實濃縮了不少OO想法在裡面，如果有閱讀過重構或物件導向設計原則等概念，應該能夠聯想到很多東西，挺有趣的。

1. 每個函式裡面只能有一層縮排，如果需要多一層，請多寫一個 method 去呼叫。

這個規則其實就是要求嚴格遵守 Compose Method：將邏輯操作轉換為細目等級相同的步驟，避免過深的邏輯而無法迅速了解，相信大家應該都有看(寫)過M型程式吧 :p

2. 不要使用到 else 這個關鍵字。

避免寫出複雜的 nested conditional 程式。不論是”重構“或是”重構－向範式前進“這兩本書，都有很多篇幅花在討論如何簡化條件邏輯，作法包括

a. 重構一書提到的 Replace Nested Conditional with Guard Clauses 方式，直接使用 return 返回，不要再 else 了。

b. 請愛用 Ternary Operator：也就是 boolean-expression ? expr1 : expr2。很多簡單的 if else 都可以用 Ternary Operator 簡化到一行一目了然。舉個 Ruby code 例子：


if ( is_something )
"foo"
else
"bar"
end

如果改成三重操作子就俐落多了：

( is_something )? "foo" : "bar"


另外初心者也常寫出根本不需要 if else 的情況：

def is_foobar
if ( a > 0 )
return true
else
return false
end
end

其實只需要這樣就可以了：

def is_foobar
( a > 0 )
end


c. 第三招要先念點書，請善用物件導向的多型(polymorphism)能力，請參考設計模式的 Strategy pattern 或重構的 Replace Conditional with Polymorphism

3. 所有基本型別都包裝成物件

如果你要用到 integer 或 string 等基本型別，請多用一層帶有意義 Class 包裝起來。例如在傳遞 “年” 跟 “月” 的參數時，不要只用 integer 傳遞哪一年哪一個月，而是用個 Date 物件包裝起來。

為什麼呢? 透過這種小型物件，我們可以寫出較容易維護的程式，一看就懂那個 integer 代表的意義是什麼。而且只用基本型別，編譯器也無法幫助(偵測)你寫出你真正想要的正確”語意”。另外一個小型物件好處是提供了很好的放 method 的地方，例如在這方面 Ruby 就做的很好，因為所有東西都是物件，所以甚至是 integer 或 string 都可以直接有自己的基本操作，例如：

-123456.abs # 123456
"FOObar".downcase # "foobar"。
Time.now.year # 2008


4. 每一行只能出現 dot 一次(即每行只能呼叫一次 method)

這規則對 Ruby 可能太嚴格了…XD 規則的目的是要減少耦合，避免破壞封裝原則：你只能玩你的玩具，而不是玩具的玩具。細節請找 The Law of Demeter (“只對你的朋友說話”)，引用 Qing 長輩的漫談程式碼的相依性：”在遵守所謂的Law of Demeter時，在某一物件的某一函式中所能呼叫函式的對象是受限制的，它只能是：該物件本身、傳入該函式的引數、在該函式中所產生的物件、以及該物件的資料成員。很明顯的，你不能在此函式中呼叫其他函式所回傳物件的函式，因為其他函式所回傳的物件，並不在上述的對象之中。

5. 不要縮寫名稱

我超愛這個規則，每次看到有人用縮寫亂取 method name 或 variable name，就覺得很抓狂。即使用 full name 會長了點，但是我寧願一看就懂而不是玩猜謎(例 what’s sm? short_message? smart_phone? single_machine?)。即使用暫時變數我也覺得應該好好命名，而不是只用一個 “t”。我自己在 Textmate 的經驗是只要按 Esc 就可以自動比對出你要的 full name，從來都不覺得打完整名稱會很辛苦。

如果你真的覺得太長，就應該好好重新思考：是不是這個 method 放錯 class 了? (放到別的 class 之下也許不需要這麼長就可以知道作用)。另一個取名常犯的錯誤是不需要重複 context (語境)：例如一個叫 Order Class，它的 method name 就不需要命名為 ship_order (即@order.ship_order)，只需要取名 ship (即@order.ship)就好了。

6. 保持東西輕薄

class 不超過50行，每個 package 不超過10個檔案。50行的程式不會超過一個螢幕，這樣螢幕不用捲就可以一掃而過。這個挑戰在於你要努力去 grouping 有共通 logical sense 的東西。

7. 不要用任何一個含超過兩個 instance 變數的 class

這大概是最難的練習了，作者認為當一個 Class 處理超過一個 state variable 時，就應該另建一個新的 class 分解及包裝起來。實際的作法我想可以參考重構的 Extract Class 方法。

8. 使用第一級 collections

任何包含 collection 的類別就不應該再含有別的變數，也就是你應該把 collection 當做一個很基本的類別來使用。

9. 不要使用任何 getters/setters/properties

目標是要練習 “Tell, don’t ask” 原則，你應該盡量告訴物件你想要什麼(tell)，而不是去問(ask)物件的狀態，然後做決定，再告訴物件做什麼。更詳細可以看看 The Pragmatic Bookshelf 的 Tell, Don’t Ask 一文 (這篇也有提到Law of Demeter)。

要看 AciveRecord 產生的 SQL 是什麼，除了可以直接 tail -f log/development.log 之外，也可以在 script/console 的情況下透過以下指令直接把 log 直接顯示出來：

ActiveRecord::Base.logger = Logger.new(STDOUT)
ActiveRecord::Base.clear_active_connections!

如此便可以好好在 console 的環境下實驗 ActiveRecord 囉。

我看到關於 ActiveRecord SQL 查詢最佳化方式有這幾種：

1. 使用 :select

只撈需要用到的欄位，特別是如果不需要用到的 text 或 binary 欄位請排除。

Event.find(:all, :select => "id, title, description")


搭配 named_scope 我們可以把常用的 :select 預先設定好，例如：

class User < ActiveRecord::Base
named_scope :short, :select => "id, name, email"
end

User.short.find(:all)


2. 使用 :include

使用 :include 避免 N+1 次 queries 的問題。


@events = Event.find(:all, :include => [:group] )



@events.each do |e|
e.group.title
end


如果沒有加 :include 把相關的 groups 一起載入，在迴圈中就會產生 @event.size 次對 group 的個別 SQL 查詢，會非常傷。加了 :include 之後總共只需查詢兩次。

另外一個比較少人知道的是，在設定 Model associations 時，如果有很明顯的情境一定會順道載入二階 association model，可以設定 :include 在 has_many, belongs_to, has_one 上面，例如：


class User < ActiveRecord::Base
has_one :foo, :include => [:bar]
end


如此便會在載入 @user.foo 的同時，也會提早載入 @user.foo.bar。

3. 資料庫索引

針對 foreign key 要加上資料庫索引 index。在 migration 上透過 add_index 就可以加上去了。

4. 特定情況下可用 :joins 取代 :include

在只需要用到 :conditions 而不需要載入該 model 的情況下，可以用 :joins 取代 :include。

Group.find(:all, :include => [ :group_memberships ], :conditions => [ "group_memberships.created_at > ?", Time.now - 30.days ] )

因為其中會載入 group_memberships model 只是為了加條件式，而沒有要撈出裡面的資料，所以可以改用 :joins，這其中的差異你看產生出的SQL就知道了 :)


Group.find(:all, :joins => [ :group_memberships ], :conditions => [ "group_memberships.created_at > ?", Time.now - 30.days ] )


5. 自己寫 SQL

ActiveRecord 可以直接寫 find_by_sql。

6. denormalization 逆正規化

當資料非常多，又要常常查詢其中計算的結果，這時可以考慮使用逆正規化的手法，將計算的結果也當做資料存起來。

一個最常見最基本的用法就是計算總數了，例如以下的例子可以解決需要常常查詢 @topic.posts.size 該篇主題有多少文章的情境：


class Topic < ActiveRecord::Base
has_many :posts
end

class Posts < ActiveRecord::Base
belongs_to :topic, :counter_cache => true
end


我們會在 Topic model 新增一個欄位 posts_count，然後 :counter_cache 就會幫我們在新增刪除 Post 時，自動更新所屬 Topic 的 posts_count 欄位資料。這時只要打 @topic.posts.size 就會直接回傳 posts_count，而無需每次都再發一個 SQL query 去 count 有多少筆 posts。

其他逆正規化的方式也包括了統計結算報表等，我們把需要複雜計算的的結果(可以透過非同步的機制如 cron 定期去觸發) 存到 Report model，這樣使用者直接撈 Report 的結果即可。

ActiveSupport 是 Rails 的工具箱。最近在看 Advanced Rails, O’Reilly 一書，有幾樣東西值得記上一筆：

JSON

我們有 Object#to_json，物件如 array,hash 等都可以呼叫 to_json 轉 JSON 格式，非常方便與 JavaScript 做銜接。

Blank

所有的物件都加上了 blank? 這個函式，回傳 true 如果是 1. 空字串 2. 只含空白的字串 3. false 4. nil 5. empty array [] 6. empty hash {}。所以別再寫 ( s.nil? || s.empty? ) 啦。

Class Attribute Accessors

可用宣告的方式定義 Class Attribute，如

  class Foo
     cattr_accessor :bar
     self.bar = ""
  end

這樣會定義出來的 C.bar 即 @@bar

Class Inheritable Attributes

Class Attribute 是整個類別繼承體系共用，這在我們寫 ActiveRecord 相關 plugin 時非常不適用，因為所有的 model 都繼承自 ActiveRecord，但是各自又要有不同的 Class Attributes 值。最常見的使用狀況就是 plugin 了，model A 和 model B 都 include 某個 plugin，但是這個 plugin 的設定值要不一樣。拿大家都在用的 attactment_fu 舉例：

class UploadImage < ActiveRecord::Base
  has_attachment :content_type => :image, :storage => :file_system
end

翻出 has_attachment 的 source code 你就看到這招了：

def has_attachment(options = {})
      ......
     class_inheritable_accessor :attachment_options
     self.attachment_options = options    # 這裡的 self 指的是 UploadImage
      ......
end

除了 class_inheritable_accessor(*syms) ，還有 class_inheritable_array(*syms) 和class_inheritable_hash(*syms) 等。

Class Attribute Accessors 的原理可以請參考 class instance variables 這篇。

Date and Time conversions

不需要每次寫 Helper 用 strftime，我們可在 environment.rb 新增自訂的 format，例如

 ActiveSupport::CoreExtensions::Time::Conversions::DATE_FORMATS.merge!( :foo => '%m/%d %l:%M %p')

這樣就可以對 Time 物件呼叫 to_s(:foo)，內建還有 :default, :short, :long, :db 等等。

alias_method_chain

在 Rails source code 十分常見：

  alias_method_chain :target, :feature

等同於

  alias_method :target_without_feature, :target
  alias_method :target, :target_with_feature

Delegation

將 methods 傳給另一個 object

  class Account < ActiveRecord::Base
      has_one :foo
      delegate :free?, :to => :foo
  end

這樣 account.free? 就會呼叫 account.foo.free? 考慮 foo 可能 nil，我們可以多一個檢查：

  delegate :free?, :to => "something.nil? ? false : something"

甚至兩層，假設 foo 有 bar：

  delegate :free?, :to => "foo.bar"

這樣 account.free? 就會呼叫 account.foo.bar.free?

#Object#returning

讓你執行一些操作然後傳回：

 returning(User.new) do |u|
   u.name = "Foo"
 end

#Object#with_options

最常用在 routes.rb，不過其實任意物件都可以用，他會將參數自動 merge 到 method call 的 hash 參數：

 map.with_options( :controller => "people" ) do |p|
   p.root :action => "index"
   p.about :action => "about"
 end

1. 下載 jQuery (建議你可以考慮用 jRails 完全換掉 Prototype library)
2. 下載 facebox
3. 把 facebox js file 放到 /public/javascripts/
4. 把 facebox css file 放到 /public/styleshees/
5. 把 facebox all image files 放到 /public/facebox/
6. 設定好 layout 的 stylesheet_link_tag 和 javascript_include_tag 加入這些 js,css 檔案

facebox-render 目前放在 github，請下載後放到 vender/plugins/facebox_render

然後在你要使用的 Controller 加入以下程式碼

 include FaceboxRender

或是你直接放到 /app/controllers/application.rb 裡面也是可以。

回到 view code，當你要叫出一個 lightbox :

 facebox_link_to "Login", :url => login_url

或是你也可以用 remote_link_to, remote_form_tag 等Rails內建的 Ajax Helper，差別在於 facebox_link_to 會先秀出一個 Loading lightbox，然後再送 Ajax request。

重頭戲是 action :

def new
 # do some thing you want
 respond_to do |format|
  format.html
  format.js { render_to_facebox }
 end
end

這裡巧妙的運用了 respond_to 來處理 ajax request，預設的 render_facebox 會 render 不帶 layout 的HTML(即 new.html.erb)。當然我們也支援傳入 :action, :template, :partial 等常見的Rails參數，或是乾脆傳入 :html 也可以。

傳入 :msg 的話，會插入一段 <div class=”message”>your msg</div> 到裡面去，方便你做一些提示或警告訊息。

除了 render_facebox，也有 close_facebox 可以關掉 lightbox。也可以用 redirect_from_lightbox 重新讀取另一頁。

實際的應用非常方便，你可以在網頁中用 remote link 或是 remote form submit 叫出 facebox。在 facebox 中也還可以再放 remote link 或 remote form submit，接收處理的 action 可用 render_facebox 或關掉 close_facebox 抑或重新讀取頁面 redirect_from_facebox。

FaceboxRender 的隨附文件請見 README 。

P.S. 這篇文的英文版在 Handlino’s blog

   From:  Nathaniel Borenstein <nsb@bellcore.com>
   To: Ned Freed <ned@innosoft.com>
   Subject: Formatted text mail
   MIME-Version: 1.0
   Content-Type: multipart/alternative; boundary=boundary42

   --boundary42

   Content-Type: text/plain; charset=utf-8

   ...plain text version of message goes here....

   --boundary42
   Content-Type: text/html; charset=utf-8

   .... html version of same message goes here ...

   --boundary42--

一個方法來自 Rails Recipes(for Rails 1.1) 書上的作法:

  def signup_notification(user)
    @from        = EXTERNAL_MAIL_SENDER
    @subject     = "Please activate your new account"
    @sent_on     = Time.now
    @recipients  = user.email
    @body[:user] = user

    content_type "multipart/alternative"

    part :content_type => "text/plain",
       :body => render_message("signup_notification_plain", @body )
     part :content_type => "text/html",
       :body => render_message("signup_notification", @body )
  end

檔案則是 signup_notification_plain.rhtml 跟 signup_notification.rhtml

不過經過 IRC #elixus 的朋友反應，在 mutt 跟 thunderbird 上看不到正確的 encoding。這才仔細看了 raw email data，竟然出來了三段 part 且第一段少了 charset utf-8。試著幾種不同寫法仍得不到看起來正確的格式，Rails Wiki 上的作法出來的格式也很奇怪。

本來想棄守 console-based email client 了，只提供 HTML 就好，但是布丁大人堅持要有 Gracefully Degrading 啊。於是再去看 ActionMailer API 發現其實有更簡單厲害的作法:

  def signup_notification(user)
    @from        = EXTERNAL_MAIL_SENDER
    @subject     = "Please activate your new account"
    @sent_on     = Time.now
    @recipients  = user.email
    @body[:user] = user
  end

檔案則要命名成 signup_notification.text.plain.erb 跟 signup_notification.text.html.erb。嗯，Rails 依據副檔名慣例會自動合併成一封信，而無須寫明 content_type 跟使用 part。

我自己還有用Globalize plugin提供中英文不同版本，所以又還有 signup_notification.zh-TW.text.plain.erb 及 signup_notification.zh-TW.text.html.erb，真是長的副檔名啊 :>

"Hello, World!".t

我個人是蠻喜歡這種 method call 寫法。不過它也提供與 gettext 一樣的語法:

_("Hello, World!")

下載請前往 Github。

另一個更簡單不需要資料庫的 plugin 是 Gibberish，它使用 key-value 方式跟 yml 檔案儲存，語法是

"Hello, World!"[:welcome]

如果不是要多國，而只是想要一國(如中文)，則可以考慮裝 Localization Simplified 跟 Localization Plugin，前者可以處理 Rails 預設的錯誤訊息跟日期格式等。後者則是因為我自己有個需求是 RHTML view code 可以用中文沒關係，但是我在 controller 或 model 裡蠻不想打中文的(一來是我不知道客戶要的確切文字，也不想讓人家直接去改 controller。二來是 Textmate 不支援中文)，所以需要一個最簡單的 L10n 機制來幫忙。

採用 Localization Simplified 後，發現還是碰到 Model attribute name 無法順利中文化，例如出現 “Password 不能是空白” 這樣的錯誤訊息。目前想到這樣 hacking:

#put this in /config/environment.rb
class String
  def humanize
      _( self.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize )
  end
end

於是就可以跟 Localization Plugin 接軌了 :>

define_method 讓函式名稱也可以參數化。

動態定義物件方法 drag.foo

#法一
Dragon.send(:define_method, :foo){ puts "bar" }

#法二
class Dragon
    define_method(:foo) { puts "bar" }

    ['a','b','c','d','e','f'].each do |x|
        define_method(x) { puts x }
     end
end

#法三
Dragon.class_eval do
    define_method(:foo) { puts "bar" }

    def foo2
        puts "bar2"
    end
end

#法四
class Dragon
    def new_method(name, &block)
        self.class.send(:define_method,name, &block)
        #或
        self.class.class_eval do
            define_method(name, &block)
        end
    end
end

drag.new_method(:foo) { puts "bar" }

動態定義類別方法 Dragon.foo

# 法一
class Dragon
    class << self
        define_method(:foo) { puts "bar" }
    end
end

# 法二
class Dragon; end

metaclass = (class << Dragon; self; end)
metaclass.instance_eval do # 用 class_eval 也可以
    define_method("foo") { puts "bar" }
end

假設目前有以下的程式碼:

 class Dragon
 end
 dran = Dragon.new

我想定義物件方法 dran.foo

#法一
class Dragon
    def n
        puts "nnn"
    end
end
#法二
Dragon.class_eval do
    def foo
        puts "bar"
    end
end

我想定義只有這個物件才有的方法 dran.foo (叫做 singleton method)

#法一
class << dran
    def foo
        puts "bar"
    end
end
drag.foo

#法二
drgn.instance_eval do
    def foo
        puts "bar"
    end
end

#法三
def dran.foo
    puts "bar"
end

我想定義類別方法 Dragon.foo (class methods)

#法一
class << Dragon
    def foo
        puts "bar"
    end
end

#法二
class Dragon
    def self.foo
        puts "bar"
    end
end

#法三
class Dragon
    class << self
        def foo
            puts "bar"
        end
     end
end

#法四
Dragon.instance_eval
    def foo
     puts "bar"
    end
end

#法五

Dragon.class_eval do # 這裡改用 instance_eval 也可以耶(why?)
  def self.foo
    puts "bar"
  end
end

A “Fancy” Constructor

class Foo
 attr_accessor :a,:b
 def initialize(&block)
  instance_eval &block
 end
end

於是可以傳入 block 來使用建構式

bar = Foo.new do
 self.a = 1
 self.b = 2
end

class instance variables

因為 Ruby 的 class 也是物件(即 Object 的 instance )，所以除了 class variable 跟 instance variable 之外，還有種變數叫做 class instance variables (即 class Class 的 instance variable 叫做 the class instance variable)。

class Foo
@@var =1 # 這是 class variable
@var = 2 # 這是 class instance variable
attr_accessor :var #這將定義出 instance variable

class << self
 attr_accessor :var2 #這將定義出 class instance variable
end

 def initialize
  @var,@var2 = 4,5 # 這是 instance variable
 end

 def mymethod1
  puts @@var # 1 這是 class variable
  puts @var # 4  這是 instance variable
  puts @var2 # 5  這是 instance variable
 end

 def Foo.classmethod
  puts @@var # 1 這是 class variable
  puts @var # 2 這是 class instance variable
  Foo.var2 = 6 # 這也是 class instance variable
end
end

class BarOne < Foo
  self.var2 = 7
end

class BarTwo < Foo
  self.var2 = 8
end

Foo.classmethod
puts Foo.var2 # 6
puts BarOne.var2 #7
puts BarTwo.var2 #8

class instance variable 跟 class variable 最大的不同在於，class variable 在整個 class 繼承體系都是指同一個，而 class instance variable 則是各個 class 皆不同，因為如此 class instance variable 很多時候比 class variable 好用，像是參數化的 classes。

const_get

const_get 可以從名稱拿到常數:

 str = "PI"
 Math.const_get(str) # 得到 Math::PI

而在 Ruby 裡面所有的 class 也都是 Object 裡的常數，所以要由名稱拿到 class 是這樣寫 :

 classname = "Array"
 klass = Object.const_get(classname) # 拿到 Array
 arr = klass.new(4,1) # [1,1,1,1]

binding

利用 eval 跟內建的 Binding 物件，我們可以把當下的 context 傳到函數裡面，建立出與本來的 scope 一樣的執行環境(因此這裡可以存取到 local variables )。

def print_var( var_name, binding )
 eval "puts #{var_name}", binding
end

foobar = 10
print_var( 'foobar' , binding )

spakit 目前放在 github，另外也包成 gem，安裝方式如下:

 gem install spakit
 cd /your_rails_app/vendor/plugin
 gem unpack spakit
 mv spakit-0.9.0 spakit

並且 rename 成 spakit。裝好之後，首先建立一個 Spakit 專用的 Layout，一個簡單的範例如下:

# /view/layouts/spakit.rhtml
<p><%= flash[:notice] %></p>
<%= yield %>

接著就可以使用 Spakit 專用的 helpers，目前有 spakit_link_to, spakit_form_for 和 spakit_form_tag 三種可以使用，用法如下:

spakit_link_to 'new person', :url => new_person_path
spakit_form_for @person, :url => people_path

如此按下連結或送出表單後，Spakit 就會送出 Ajax request(i.e. prototype’s Ajax.Updater )，然後將回傳的 HTML 結果更新到#content 區塊。

如果你想要支援 Ajax 的 Histroy Bookmarks，建議可以採用 Really Simple History(RSH) library 來處理瀏覽器的上一頁下一頁問題，這部份的範例程式附在 plugin 的 README (使用到 jquery library，好心人有空可以幫忙寫 prototype version)。

P.S. 這篇文的英文版在 Handlino’s blog

Ruby 是個很慢的語言，但有些作法應用得當，還是會有不錯的改善。不過要知道程式碼的可讀性跟執行效率有時候是衝突的，這點還需拿捏，尤其 software life cycle 一開始可讀性比較重要。有句最佳化的經典名言一定要引一下:

未成年就這麼優，是一切邪惡的根源
Premature optimization is the root of all evil

這裡紀錄一些看到有趣的事情，PDF 裡有更詳盡的 example code。

Instance Variables versus Accessors

@attrubute 比 self.attrbute 快(method call 比較貴)，如果你不需要 public method 或有 sub-class 的需求，請考慮不要用 attr_accessor 等方式來建立 read/write method。

Local Variables Are Cheap

method 中傳進來的參數若常用，可以先存成 Local Variables 再來多次使用。

Interpolated Strnges

方法一 s = “:#{a}.#{b}” 比方法二 s = “:” << a.to_s << “.” << b.to_s 快多囉!! 不需要多用 << method call。另外單引號跟雙引號沒有效率上的差別。

In-Place Updates

直接修改比複製一份快: gsub! 比 gsub 快，merge! 比 merge 快。例如這個範例 s.gsub().gsub!().gsub! 而不是 s.gsub.gsub.gsub

Set Versus Array

如果你只用到 Array 的 uniq, |, %, – 等群集操作，請考慮改用 Set 會比較快，像是 include? 就可以在 O(1) 做完。而 Hash 又比 Array 貴。

Make Decisions at Load Time

注意到在 module 或 class 的 definition scope 也是可以執行程式的，而且只有第一次 require source code 時會執行編譯一次。

class Foo
if C=’somesetting’
def A
…version 1
end
else
def A
…version 2
end
end
end

Self-Modifying Code

避免寫出自己修改自己定義的程式(也不好讀code吧)，改用 singleton 方式來做 alias_method 跟 remove_method。

Test Most Frequent Case First

用 case 時把較常發生的放前面，若都差不多，把貴的操作的放後面。

Optimize Access to Global Constants

在 Constant 前面加上 namespace operator :: 會比較快，減少查詢時間

Caching Data in Instance Variables

例如在 controller 裡面 def captial_letters { (“A”..”Z”).to_a } end 請改用 def captial_letters { @captial_letters ||= (“A”..”Z”).to_a } end

Caching Data in Class Variables

承上，如果 data 較大又持續存在，可以改用 @@capital_letter = (“A”..”Z”).to_a 然後定 def captial_letters { @@captial_letters } end。在 ActiveRecord 中也可以先把 DB 的資料讀出來當作 CONSTANTS，就不需要每次都查資料庫了:

class State < ActiveRecord::Base
NAMES_ABBR = self.find(:all).map do { |s| [s.name,s.abbr] }
end

Coding Variable Caching Efficiently

愛用 @var ||= begin …expr… end 而不是 @var = begin …expr… end unless @var，這樣只需查 @var 一次。但如果 @var要能吃 nil 或 false 就只能多一個 boolean 變數來幫忙了。

Initializing Variables with nil

若沒有給值，就不需要初始成nil

Using .nil?

如果要測試的值已知不是 Boolean，那就不需要用 .nil 多一個 method call，直接 if x 就好了而不是 if x.nil?

nil? or empty? versus blank?

ActionPack 有提供 x.blank?，不需要用 x.nil? || x.empty?

Using return

雖然 Ruby 很聰明會自動回傳最後運算的值，但明確寫 return 會比較快 (Ruby 1.9有改善)

Using any?

用 empty? 來測試 string, array or hash 而不要用 any?，速度差個兩倍 (而且 Ruby 1.9 也拿掉 any?這個method了)

Block Local Variables

在 Ruby 1.8 裡面，在 Block 裡面存取 Block 外面的 local variable 竟然比裡面的 local variable 還快!! 不過 Ruby 1.9 修正這個奇怪的事實就是了。

Parallel Assignments

很方便沒錯，但 a,b=1,2 運算還丟出來 Array [1,2] 是垃圾。(Ruby 1.9 修正了，改丟 true)

Date Formatting

用 parse_date 把 String 變成 Date 是個非常昂貴的操作，建議你直接用字串操作(正規表示法)把 String(例如從DB撈出來的db_date) 變成你想要的格式，或是從中拆出你想要的年月日。(PDF 有 example code)

Temporary Data Structure Constants

如果用到一個暫時的資料結構(如Array)但接下來不會更改，可以改用 Constant 宣告，並避免複製。

ObjectSpace.each_object

DO NOT USE IT，你不會想在 per-request 下去執行的，很貴。

Unnecessary Block Parameters

def foo(bar, &block) 的 &block 若在函式內不需要用到(可以直接用 yield 使用的)，請不要加。轉成 Proc 比單純 yield 的慢5倍!!

Symbol.to_proc

ActiveSupport 提供的 @var.map(&:name) 語法，雖然方便，但是用 inline block 的方法 @var.map{ |a| a.name| } 執行效率比較快。

Requiring Files Dynamically

在 Rails 中若碰到一個未定義的常數，它會自動去 load source files 來載入定義。為了避免混淆 file-loading 機制，不需寫 require ‘client’ (這又是另一套 auto-loaded 機制)，只要單單一行寫 Client 就好了。

Including Modules versus Opening Classes

使用 module mix-in 會比打開 class 加入 method 還慢一些，如果你的 module 只針對一個 class 做 mix-in，那不如直接打開來加入 methods 就好了。

這一次依然由我來跟大家分享 Ruby/Rails testing，題目是 RSpec, a Behavior-driven development framework。

時間是晚上 8:00-10:00，地點在 opcafe 三代。