Ruby是一種解釋型、面向對象、動態類型的語言。Ruby采取的策略是在靈活性和運行時安全之間尋找平衡點。隨著Rails框架的出現，Ruby也在2006年前后一鳴驚人，同時也指引人們重新找回編程樂趣。盡管從執行速度上說，Ruby談不上有多高效，但它卻能讓程序員的編程效率大幅提高。本文將講述Ruby語言的基礎語言特性，包括基本的語法及代碼塊和類的定義。

1. 基礎
在Ruby交互命令行中輸入以下命令（>>為命令行提示符，=>為返回值；下文將把=>符號和語句寫在一行內表明其返回值）：

>> puts 'hello, world'
hello, world
=> nil

>> language = 'Ruby'
=> "Ruby"

>> puts "hello, #{language}"
hello, Ruby
=> nil

以上代碼使用puts輸出，給變量賦值，并用#{}的語法實現字符串替換。這表明Ruby是解釋執行的；變量無需聲明即可直接初始化和賦值；每條Ruby代碼都會返回某個值；單引號包含的字符串表示它將直接被解釋，雙引號包含的字符串會引發字符串替換。

1.1 編程模型

Ruby是一門純面向對象語言，在Ruby中一切皆為對象，可以用“.”調用對象具有的方法，可以通過class和methods方法查看對象的類型及支持的方法，如4.class => Fixnum，7.methods => ["inspect", "%", "", "numerator", ...]，false.class => FalseClass（方括號表示數組）。

1.2 流程控制

條件判斷有正常的塊形式，也有簡單明了的單行形式；除了常見的if語句外，還有unless語句（等價于if not，但可讀性更強）。同理，循環也有正常的塊形式和單行形式。注意：除了nil和false之外，其他值都代表true，包括0！

# 塊形式
if x == 4
 puts 'This is 4.'
end
# 單行形式
puts 'This is false.' unless true
x = x + 1 while x  10 # x的結果為10
x = x - 1 until x == 1 # x的結果為1

和其他C家族的語言差不多，Ruby的邏輯運算符and（）、or（||）都自帶短路功能，若想執行整個表達式，可以用或|

1.3 鴨子類型

執行4 + 'four'會出現TypeError的錯誤，說明Ruby是強類型語言，在發生類型沖突時，將得到一個錯誤。如果把個語句放在def...end函數定義中，則只有在調用函數時才會報錯，說明Ruby在運行時而非編譯時進行類型檢查，這稱為動態類型。Ruby的類型系統有自己的潛在優勢，即多個類不必繼承自相同的父類就能以“多態”的方式使用：

a = ['100', 100.0]
puts a[0].to_i # => 100
puts a[1].to_i # => 100

這就是所謂的“鴨子類型”（duck typing）。數組的第一個元素是String類型，第二個元素是Float類型，但轉換成整數用的都是to_i。鴨子類型并不在乎其內在類型是什么，只要一個對象像鴨子一樣走路，像鴨子一樣嘎嘎叫，那它就是只鴨子。在面向對象設計思想中，有一個重要原則：對接口編碼，不對實現編碼。如果利用鴨子類型，實現這一原則只需極少的額外工作，就能輕松完成。

1.4 函數

def tell_the_truth
 true
end

每個函數都會返回結果，如果沒有顯式指定返回值，函數就將退出函數前最后處理的表達式的值返回。函數也是個對象，可以作為參數傳給其他函數。

1.5 數組

和Python一樣，Ruby的數組也是用中括號來定義，如animals = ['lion', 'tiger', 'bear']；負數下標可以返回倒數的元素，如animals[-1] => "bear"；通過指定一個Range對象來獲取一個區段的元素，如animals[1..2] => ['tiger', 'bear']。此外，數組元素可以互不相同，多為數組也不過是數組的數組。數組擁有極其豐富的API，可用其實現隊列、鏈表、棧、集合等等。

1.6 散列表

numbers = {2 => 'two', 5 => 'five'}
stuff = {:array => [1, 2, 3], :string => 'Hi, mom!'}
# stuff[:string] => "Hi, mom!"

散列表可以帶任何類型的鍵，上述代碼的stuff的鍵較為特殊——它是一個符號（symbol），前面帶有冒號標識符。符號在給事物和概念命名時很好用，例如兩個同值字符串在物理上不同，但相同的符號卻是同一物理對象，可以通過反復調用'i am string'.object_id和:symbol.object_id來觀察。另外，當散列表用作函數最后一個參數時，大括號可有可無，如tell_the_truth :profession => :lawyer。

2. 面向對象
2.1 代碼塊

代碼塊是沒有名字的函數（匿名函數），可以用作參數傳遞給函數。代碼塊只占一行時用大括號包起來，占多行是用do/end包起來，可以帶若干個參數。

3.times {puts 'hehe'} # 輸出3行hehe
['lion', 'tiger', 'bear'].each {|animal| puts animal} # 輸出列表的內容

上面的times實際上是Fixnum類型的方法，要自己實現這樣一個方法非常容易：

class Fixnum
 def my_times
  i = self
   while i > 0
    i = i - 1
    yield
  end
 end
end

3.my_times {puts 'hehe'} # 輸出3行hehe

這段代碼打開一個現有的類，向其中添加一個自定義的my_times方法，并用yield調用代碼塊。在Ruby中，代碼塊不僅可用于循環，還可用于延遲執行，即代碼塊中的行為只有等到調用相關的yield時才會執行。代碼塊充斥于Ruby的各種庫，小到文件的每一行，大到在集合上進行各種復雜操作，都是由代碼塊來完成的。

2.2 類

調用一個對象的class方法可以查看其類型，調用superclass可以查看這個類型的父類。下圖展示了數字的繼承鏈，其中橫向箭頭表示右邊是左邊實例化的對象，縱向箭頭表示下邊繼承于上邊。Ruby的一切事物都有一個共同的祖先Object。

最后通過一個完整的實例——定義一棵樹，來看下Ruby的類如何定義和使用，該注意的點都寫在注釋里面了。

class Tree
 # 定義實例變量，使用attr或attr_accessor關鍵字，前者定義變量和訪問變量的同名getter方法（即只讀），后者定義的變量多了同名setter方法（注意這里使用了符號）
 attr_accessor :children, :node_name

 # 構造方法（構造方法必須命名為initialize）
 def initialize(name, children=[])
  @node_name = name
  @children = children
 end

 # 遍歷所有節點并執行代碼塊block，注意參數前加一個表示將代碼塊作為閉包傳遞給函數
 def visit_all(block)
  visit block
  children.each {|c| c.visit_all block}
 end

 # 訪問一個節點并執行代碼塊block
 def visit(block)
  block.call self
 end
end

ruby_tree = Tree.new("Ruby", 
 [Tree.new("Reia"),
  Tree.new("MacRuby")])
# 訪問一個節點
ruby_tree.visit {|node| puts node.node_name}
# 訪問整棵樹
ruby_tree.visit_all {|node| puts "Node: #{node.node_name}"}

再提一下Ruby的命名規范：

（1）類采用CamelCase命名法
（2）實例變量（一個對象有一個值）前必須加上@，類變量（一個類有一個值）前必須加上@@
（3）變量和方法名全小寫用下劃線命名法，如underscore_style
（4）常量采用全大寫下劃線命名法，如ALL_CAPS_STYLE
（5）用于邏輯測試的函數和方法一般要加上問號，如if test?

3. 模塊與混入（Mixin）
面向對象語言利用繼承，將行為傳播到相似的對象上。若一個對象像繼承多種行為，一種做法是用多繼承，如C++；Java采用接口解決這一問題，Ruby采用模塊Mixin。模塊是函數和常量的集合，若在類中包含一個模塊，那么該模塊的行為和常量也會成為類的一部分。

# 定義模塊ToFile
module ToFile
 # 獲取文件名
 def filename
  "object_name.txt"
 end

 # 創建文件
 def to_f
  File.open(filename, 'w') {|f| f.write(to_s)} # 注意這里to_s在其他地方定義！
 end
end

# 定義用戶類
class Person
 include ToFile
 attr_accessor :name

 def initialize(name)
  @name = name
 end

 def to_s
  name
 end
end

Person.new('matz').to_f # 創建了一個文件object_name.txt，里面包含內容matz

上面的代碼很好理解，只是有一點要注意：to_s在模塊中使用，在類中實現，但定義模塊的時候，實現它的類甚至還沒有定義。這正是鴨子類型的精髓所在。寫入文件的能力，和Person這個類沒有一點關系（一個類就應該做屬于它自己的事情），但實際開發又需要把Person類寫入文件這種額外功能，這時候mixin就可以輕松勝任這種要求。

Ruby有兩個重要的mixin：枚舉（enumerable）和比較（comparable）。若想讓類可枚舉，必須實現each方法；若想讓類可比較，必須實現=>（太空船）操作符（比較a,b兩操作數，返回1、0或-1）。Ruby的字符串可以這樣比較：'begin' => 'end => -1。數組有很多好用的方法：

a = [5, 3, 4, 1]
a.sort => [1, 3, 4, 5] # 整數已通過Fixnum類實現太空船操作符，因此可比較可排序
a.any? {|i| i > 4} => true
a.all? {|i| i > 0} => true
a.collect {|i| i * 2} => [10, 6, 8, 2]
a.select {|i| i % 2 == 0} => [4]
a.member?(2) => false
a.inject {|product, i| product * i} => 60 # 第一個參數是代碼塊上一次執行的結果，若不設初始值，則使用列表第一個值作為初始值

4. 元編程（metaprogramming）
所謂元編程，說白了就是“寫能寫程序的程序”，這說起來有點拗口，下面會通過實例來講解。

4.1 開放類

可以重定義Ruby中的任何類，并給它們擴充任何你想要的方法，甚至能讓Ruby完全癱瘓，比如重定義Class.new方法。對于開發類來說，這種權衡主要考慮了自由，有這種重定義任何類或對象的自由，就能寫出即為通俗易懂的代碼，但也要明白，自由越大、能力越強，擔負的責任也越重。

class Numeric
 def inches
  self
 end
 def feet
  self * 12.inches
 end
 def miles
  self * 5280.feet
 end
 def back
  self * -1
 end
 def forward
  self
 end
end

上面的代碼通過開放Numeric類，就可以像這樣采用最簡單的語法實現用英寸表示距離：puts 10.miles.back，puts 2.feet.forward。

4.2 使用method_missing

Ruby找不到某個方法時，會調用一個特殊的回調方法method_missing顯示診斷信息。通過覆蓋這個特殊方法，可以實現一些非常有趣且強大的功能。下面這個示例展示了如何用簡潔的語法來實現羅馬數字。

class Roman
 # 覆蓋self.method_missing方法
 def self.method_missing name, *args
  roman = name.to_s
  roman.gsub!("IV", "IIII")
  roman.gsub!("IX", "VIIII")
  roman.gsub!("XL", "XXXX")
  roman.gsub!("XC", "LXXXX")

  (roman.count("I") +
   roman.count("V") * 5 +
   roman.count("X") * 10 +
   roman.count("L") * 50 +
   roman.count("C") * 100)
 end
end

puts Roman.III # => 3
puts Roman.XII # => 12

我們沒有給Roman類定義什么實際的方法，但已經可以Roman類來表示任何羅馬數字！其原理就是在沒有找到定義方法時，把方法名稱和參數傳給method_missing執行。首先調用to_s把方法名轉為字符串，然后將羅馬數字“左減”特殊形式轉換為“右加”形式（更容易計數），最后統計各個符號的個數和加權。

當然，如此強有力的工具也有其代價：類調試起來會更加困難，因為Ruby再也不會告訴你找不到某個方法。因此method_missing是一把雙刃劍，它確實可以讓語法大大簡化，但是要以人為地加強程序的健壯性為前提。

4.3 使用模塊

Ruby最流行的元編程方式，非模塊莫屬。下面的代碼講述如何用模塊的方式擴展一個可以讀取csv文件的類。

module ActsAsCsv

 # 只要某個模塊被另一模塊include，就會調用被include模塊的included方法
 def self.included(base)
  base.extend ClassMethods
 end

 module ClassMethods
  def acts_as_csv
   include InstanceMethods
  end
 end

 module InstanceMethods
  attr_accessor :headers, :csv_contents

  def initialize
   read
  end

  def read
   @csv_contents = []
   filename = self.class.to_s.downcase + '.txt'
   file = File.new(filename)
   @headers = file.gets.chomp.split(', ') # String的chomp方法去除字符串末尾的回車換行符
   file.each do |row|
    @csv_contents  row.chomp.split(', ')
   end
  end
 end

end # end of module ActsAsCsv

class RubyCsv  # 沒有繼承，可以自由添加
 include ActsAsCsv
 acts_as_csv
end

m = RubyCsv.new
puts m.headers.inspect
puts m.csv_contents.inspect

上述代碼中RubyCsv包含了ActsAsCsv，所以ActsAsCsv的included方法中，base就指RubyCsv，ActsAsCsv模塊給RubyCsv類添加了唯一一個類方法acts_as_csv，這個方法又打開RubyCsv類，并在類中包含了所有實例方法。如此這般，就寫了一個會寫程序的程序（通過模塊來動態添加類方法）。

一些出色的Ruby框架，如Builder和ActiveRecord，都會為了改善可讀性而特別依賴元編程。借助元編程的威力，可以做到盡量縮短正確的Ruby語法與日常用于之間的距離。注意一切都是為了提升代碼可讀性而服務。

5. 總結
Ruby的純面向對象可以讓你用一致的方式來處理對象。鴨子類型根據對象可提供的方法，而不是對象的繼承層次，實現了更切合實際的多態設計。Ruby的模塊和開放類，使程序員能把行為緊密結合到語法上，大大超越了類中定義的傳統方法和實例變量。
核心優勢：
（1）優雅的語法和強大的靈活性
（2）腳本：Ruby是一門夢幻般的腳本語言，可以出色地完成許多任務。Ruby許多語法糖可以大幅提高生產效率，各種各樣的庫和gem（Ruby包）可以滿足絕大多數日常需要。
（3）Web開發：很多人學Ruby最終就是為了用Ruby on Rails框架來進行Web開發。作為一個極其成功的MVC框架，其有著廣泛的社區支持及優雅的語法。Twitter最初就是用Ruby實現的，借助Ruby無比強大的生產力，可以快速地開發出一個可推向市場的合格產品。
不足之處：
（1）性能：這是Ruby的最大弱點。隨著時代的發展，Ruby的速度確實是越來越快。當然，Ruby是創建目的為了改善程序員的體驗，在對性能要求不高的應用場景下，性能換來生產效率的大幅提升無疑是值得的。
（2）并發和面向對象編程：面向對象是建立在狀態包裝一系列行為的基礎上，但通常狀態是會改變的。程序中存在并發時，這種編程策略就會引發嚴重問題。
（3）類型安全：靜態類型可提供一整套工具，可以更輕松地構造語法樹，也因此能實現各種IDE。對Ruby這種動態類型語言來說，實現IDE就困難得多。