Actually, I’m trying to make Ruby natural, not simple. Ruby is simple in appearance, but is very complex inside, just like our human body. - Matz, Ruby 发明人
Ruby是个美丽、灵巧而且方便又实用的程式语言，而Ruby on Rails正是 Ruby 程式语言爆发成长的催化剂。在了解Ruby on Rails的程式之前，学习Ruby程式语言是最重要的基础功课之一，我们在这一章节将快速带过一些基本的语法，网络上也有Ruby Taiwan社群所翻译的文章可以一读：
免费的英文资源也很多，我推荐以下三个教学网站作为练习之用：
除了用C语言实作的官方版本Ruby(又叫做CRuby或MRI, Matz’s Ruby Interpreter)，也有其他不同实作的Ruby环境。这些实作都以RubySpec作为其语法的标准：
IRB是一个互动的Ruby环境，可以让我们练习和语法，做些简单的实验。请输入irb就会进入互动模式：
$ irb
irb: Interactive Ruby
irb(main):001:0>
irb(main):001:0> 1 + 1
=> 2在irb之中，每行执行完Ruby都会自动帮你puts输出结果。
不过，一旦程式稍微复杂一点，还是打开文字编辑器吧。让我们编辑一个档案hello.rb。Ruby脚本附档名的惯例是.rb，内容如下：
puts "Hello, World!!"存盘后，输入：
$ ruby hello.rb就会执行这个脚本了，它会在萤幕上输出Hello, World!!。
根据需不需要事先宣告变量型别，我们可以分类出静态分型(Static typing)与动态分型(Dynamic typing)程式语言，前者例如Java、C、C++，后者例如Ruby、Perl、Python和PHP。根据会不会隐性自动转换型别，又可以区分出不会自动转换型别的强分型(Strong typing)与自动转换型别的弱分型(Weak typing)，前者例如Ruby、Perl、Python、Java，后者例如PHP、C、C++是弱分型。让我们举个例吧：
/* PHP */
$i = 1;
echo "Value is " . $i ;
# Value is 1
/* C */
int a = 5;
float b = a;以上的PHP和C会隐性地自动转型，但是以下的Ruby程式会检查型别不相配而发生错误，这一点从PHP过来的朋友要特别注意。
# Ruby
i = 1
puts "Value is " + i
# TypeError: can't convert Fixnum into String
# from (irb):2:in `+'
# from (irb):2另外，通常动态分型的程式语言多半也是直译式(interpreted)程式语言，也就是不需要事先编译，透过直译器(interpreter)执行即可，当然Ruby也不例外。相对的，编译式(compiled)语言则是事先编译成执行档才行执行。总结以上，Ruby是个动态强分型的直译式程式语言。
任何整数都是Fixnum物件：
5
-205
9999999999
0完整的Fixnum API请参考Ruby doc文件。
中间带有点号的就是浮点数Float物件：
54.321
0.001
-12.312
0.0浮点数四则运算范例如下：
puts 1.0 + 2.0
puts 2.0 * 3.0
puts 5.0 - 8.0
puts 9.0 / 2.0
# 3.0
# 6.0
# -3.0
# 4.5要注意的是，整数四则运算结果，也会是整数：
puts 1 + 2
puts 2 * 3
puts 5 - 8
puts 9 / 2
# 3
# 6
# -3
# 4以下是一个更复杂的四则运算例子：
puts 5 * (12 - 8) + -15
puts 98 + (59872 / (13*8)) * -52完整的Float API请参考Ruby doc文件。
使用单引号或双引号括起来的是字串String物件：
puts 'Hello, world!'
puts ''
puts 'Good-bye.'字串相加可以使用加号，要注意的是字串不能直接跟数字相加，会发生例外错误：
puts 'I like ' + 'apple pie.'
puts 'You\'re smart!'
puts '12' + 12
#<TypeError: can't convert Fixnum into String>更多字串方法示范：
var1 = 'stop'
var2 = 'foobar'
var3 = "aAbBcC"
puts var1.reverse # pots
puts var2.length # 6
puts var3.upcase # AABBCC
puts var3.downcase # aabbcc为了方便字串的组合，Ruby也支持内插的方式：
verb = 'work'
where = 'office'
puts "I #{verb} at the #{where}" # 輸出 I work at the office注意到使用双引号(“)的字串才会进行内插处理。如果换成单引号(‘)：
puts 'I #{verb} at the #{where}' # 輸出 I #{verb} at the #{where}完整的String API请参考Ruby String API文件。
你可能已经注意到，在Ruby里每样东西都是物件，包括字串和数字。所有的方法都是对物件呼叫，你不会看到全域函式，例如PHP的strlen("test")用法，在Ruby中是"test".length。
# 輸出「UPPER」
puts "upper".upcase
# 輸出 -5 的絕對值
puts -5.abs
# 輸出 Fixnum 類別
puts 99.class
# 輸出五次「Ruby Rocks!」
5.times do
puts "Ruby Rocks!"
end区域变量使用小写开头，偏好单字之间以底线_来分隔。范例如下：
composer = 'Mozart'
puts composer + ' was "da bomb", in his day.'
my_composer = 'Beethoven'
puts 'But I prefer ' + my_composer + ', personally.'如果存取一个尚未初始过的区域变量，会得到以下错误：
NameError: undefined local variable or method `qwer' for main:Object
from (irb):1
from /Users/ihower/.rvm/rubies/ruby-2.1.5/bin/irb:11:in `<main>'刚刚提到数字和字串物件不能直接相加，你必须使用to_s(转成字串)、to_i(转成整数)或to_f(转成浮点数)来手动转型，范例如下：
var1 = 2
var2 = '5'
puts var1.to_s + var2 # 25
puts var1 + var2.to_i # 7
puts 9.to_f / 2 # 4.5大写开头的是为常数，范例如下：
Foo = 1
Foo = 2 # (irb):3: warning: already initialized constant Foo
RUBY_PLATFORM # => "x86_64-darwin10.7.0"
ENV # => { "PATH" => "....", "LC_ALL" => "zh_TW.UTF-8" }表示未设定值、未定义的状态：
nil # nil
nil.class # NilClass
nil.nil? # true
42.nil? # false
nil == nil # true
false == nil # falseRuby偏好一律使用单行注解：
# this is a comment line
# this is a comment line多行注解比较少见：
=begin
This is a comment line
This is a comment line
=endSymbol是唯一且不会变动的识别名称，用冒号开头：
:this_is_a_symbol为什么不就用字串呢？这是因为相同名称的Symbol不会再重复建构物件，所以使用Symbol可以执行的更有效率。范例如下：
puts "foobar".object_id # 輸出 2151854740
puts "foobar".object_id # 輸出 2151830100
puts :foobar.object_id # 輸出 577768
puts :foobar.object_id # 輸出 577768object_id方法会回传Ruby内部的内存配置编号。你会发现两个字串就算内容相同，也是不同的物件。但是Symbol只要内容相同，就是相同的物件。这种特性让Symbol的主要用途是作为杂凑Hash的键(Key)，一会就会介绍到。
使用中括号，索引从0开始。注意到阵列中的元素是不限同一类别，想放什么都可以：
a = [ 1, "cat", 3.14 ]
puts a[0] # 輸出 1
puts a.size # 輸出 3
a[2] = nil
puts a.inspect # 輸出 [1, "cat", nil]
a[99] # nil
inspect方法会将物件转成适合给人看的字串
如果读取一个没有设定的阵列元素，默认值是nil。更多阵列方法范例：
colors = ["red", "blue"]
colors.push("black")
colors << "white"
puts colors.join(", ") # red, blue, black, white
colors.pop
puts colors.last #black使用each方法走访阵列：
languages = ['Ruby', 'Javascript', 'Perl']
languages.each do |lang|
puts 'I love ' + lang + '!'
end
# I Love Ruby!
# I Love Javascript!
# I Love Perl!完整的Array API请参考[Ruby Array API(http://www.ruby-doc.org/core/classes/Array.html)文件。
Hash是一种键值对(Key-Value)的资料结构，虽然你可以使用任何物件当作Key，但是通常我们使用Symbol当作Key。例如：
config = { :foo => 123, :bar => 456 }
puts config[:foo] # 輸出 123
config["nothing"] # 是 nil在Ruby 1.9后支援新的语法，比较简约：
config = { foo: 123, bar: 456 } # 等同於 { :foo => 123, :bar => 456 }如果读取一个不存在的值，例如上述范例的nothing，默认值是nil。
使用each方法可以走访杂凑：
config = { :foo => 123, :bar => 456 }
config.each do |key, value|
puts "#{key} is #{value}"
end
# foo is 123
# bar is 456完整的Hash API请参考Ruby Hash API文件。
让我们来看看一些流程控制：
puts 1 > 2 # 大於
puts 1 < 2 # 小於
puts 5 >= 5 # 大於等於
puts 5 <= 4 # 小於等於
puts 1 == 1 # 等於
puts 2 != 1 # 不等於
puts ( 2 > 1 ) && ( 2 > 3 ) # 和
puts ( 2 > 1 ) || ( 2 > 3 ) # 或else if写成elsif：
total = 26000
if total > 100000
puts "large account"
elsif total > 25000
puts "medium account"
else
puts "small account"
end另外如果要执行的if程式只有一行，可以将if放到行末即可：
puts "greater than ten" if total > 10三元运算子expression ? true_expresion : false_expression可以让我们处理简易的if else条件，例如以下的程式：
x = 3
if x > 3
y = "foo"
else
y = "bar"
end改用三元运算子之后，可以缩减程式行数：
x = 3
y = ( x > 3 ) ? "foo" : "bar"case name
when "John"
puts "Howdy John!"
when "Ryan"
puts "Whatz up Ryan!"
else
puts "Hi #{name}!"
endwhile用法范例：
i=0
while ( i < 10 )
i += 1
next if i % 2 == 0 #跳過雙數
enduntil用法范例：
i = 0
i += 1 until i > 10
puts i
# 輸出 11loop用法范例：
i = 0
loop do
i += 1
break if i > 10 # 中斷迴圈
end不过你很快就会发现写Ruby很少用到while、until、loop，我们会使用迭代器。
记住，只有false和nil是假，其他都为真。
puts "not execute" if nil
puts "not execute" if false
puts "execute" if true # 輸出 execute
puts "execute" if “” # 輸出 execute (和JavaScript不同)
puts "execute" if 0 # 輸出 execute (和C不同)
puts "execute" if 1 # 輸出 execute
puts "execute" if "foo" # 輸出 execute
puts "execute" if Array.new # 輸出 execute与Perl类似的语法，使用=~：
# 抓出手機號碼
phone = "123-456-7890"
if phone =~ /(\d{3})-(\d{3})-(\d{4})/
ext = $1
city = $2
num = $3
end使用def开头end结尾来定义一个方法：
def say_hello(name)
result = "Hi, " + name
return result
end
puts say_hello('ihower')
# 輸出 Hi, ihower方法中的return是可以省略的，Ruby就会回传最后一行运算的值。上述方法可以改写成：
def say_hello(name)
"Hi, " + name
end呼叫方法时，括号也是可以省略的，例如：
say_hello 'ihower'不过，除了一些方法惯例不加之外(例如puts和Rails中的redirect_to、render方法)，绝大部分的情况加上括号比较无疑义。
我们也可以给参数默认值：
def say_hello(name = "nobody")
result = "Hi, " + name
return result
end
puts say_hello
# 輸出 Hi, nobody?与!的惯例方法名称可以用?或!结尾，前者表示会回传Boolean值，后者暗示会有某种副作用(side-effect)。范例如下：
array=[2,1,3]
array.empty? # false
array.sort # [1,2,3]
array.inspect # [2,1,3]
array.sort! # [1,2,3]
array.inspect # [1,2,3]物件导向(Object-Oriented Programming)一种将“资料”和“方法”封装到物件的设计方式，我们定义“类别 Class”，然后依此产生出“物件 Object”，类别可说是物件的样板。
Ruby的类别其实也是一种常数，所以也是大写开头，使用new方法可以建立出物件，例如之前所学的字串、阵列和杂凑，也可以用以下方式建立：
color_string = String.new
color_string = "" # 等同
color_array = Array.new
color_array = [] # 等同
color_hash = Hash.new
color_hash = {} # 等同
time = Time.new # 內建的時間類別
puts time来看看如何自定类别：
class Person # 大寫開頭的常數
def initialize(name) # 建構式
@name = name # 物件變數
end
def say(word)
puts "#{word}, #{@name}" # 字串相加
end
end
p1 = Person.new("ihower")
p2 = Person.new("ihover")
p1.say("Hello") # 輸出 Hello, ihower
p2.say("Hello") # 輸出 Hello, ihover注意到双引号里的字串可以使用
#{var}来做字串嵌入，相较起用加号+相加字串可以更有效率。
除了物件方法与物件变量，Ruby也有属于类别的方法和变量：
class Person
@@name = “ihower” # 類別變數
def self.say # 類別方法
puts @@name
end
end
Person.say # 輸出 ihower所有的物件变量(@开头)、类别变量(@@开头)，都是封装在类别内部的，类别外无法存取：
class Person
def initialize(name)
@name = name
end
end
p = Person.new('ihower')
p.name # 出現 NoMethodError 錯誤
p.name = 'peny' # 出現 NoMethodError 錯誤为了可以存取到@name，我们必须定义方法：
class Person
def initialize(name)
@name = name
end
def name
@name
end
def name=(name)
@name = name
end
end
p = Person.new('ihower')
=> #<Person:0x007fe9e408b8f0 @name="ihower">
p.name
=> "ihower"
p.name="peny"
=> "peny"
p.name
=> "peny"
p
=> #<Person:0x007fe9e408b8f0 @name="peny">Class定义范围内也可以执行程式跟其他程式语言不太一样，Ruby的类别层级内也可以执行程式，例如以下：
class Demo
puts "foobar"
end当你加载这个类别的时候，就会执行puts "foobar"输出foobar。会放在这里的程式，主要的用途是来做Meta-programming。例如，上述定义物件变量的存取方法实在太常见了，因此Ruby提供了attr_accessor、attr_writer、attr_reader类别方法可以直接定义这些方法。上述的程式可以改写成：
class Person
attr_accessor :name
def initialize(name)
@name = name
end
end
p = Person.new('ihower')
=> #<Person:0x007fe9e3094410 @name="ihower">
p.name
=> "ihower"
p.name="peny"
=> "peny"
p.name
=> "peny"
p
=> #<Person:0x007fe9e3094410 @name="peny">这里的attr_accessor其实就是一个类别方法。
类别中的方法默认是public的，宣告private或protected的话，该行以下的方法就会套用：
class MyClass
def public_method
end
private
def private_method_1
end
def private_method_2
end
protected
def protected_method
end
endRuby的private和protected定义和其他程式语言不同，都是可以在整个继承体系内呼叫。两著差别在于private只有在物件内部才能呼叫，默认的接收者(receiver)就是物件本身，也就是self。而protected方法除了可以在本身内部呼叫以外，还可以被子类别的物件、或是另一个相同类别的物件呼叫。
在物件导向的术语中，
object.call_method的意思是object收到执行call_method的指令，也就是object是call_method方法的接受者(receiver)。因此，你甚至可以改写成object.__send__(:call_method)
Ruby使用小于<符号代表类别继承：
class Pet
attr_accessor :name, :age
def say(word)
puts "Say: #{word}"
end
end
class Cat < Pet
def say(word)
puts "Meow~"
super
end
end
class Dog < Pet
def say(word, person)
puts "Bark at #{person}!"
super(word)
end
end
Cat.new.say("Hi")
Dog.new.say("Hi", "ihower")输出
Meow~
Say: Hi
Bark at ihower!
Say: Hi这个范例中，Cat和Dog子类别覆写了Pet say方法，其中的super是用来呼叫被覆写掉的Pet say方法。另外，没有括号的super和有括号的super()是有差异的，前者Ruby会自动将所有参数都代进去来呼叫父类别的方法，后者则是自己指定参数。此例中如果Dog say里只写super，则会发生wrong number of arguments的错误，这是因为Ruby会传say("Hi", "ihower")给Pet say而发生错误。
Module是Ruby一个非常好用的功能，它跟Class类别非常相似，你可以在里面定义方法。只是你不能用new来建立它。它的第一个用途是可以当做Namespace来放一些工具方法：
module MyUtil
def self.foobar
puts "foobar"
end
end
MyUtil.foobar
# 輸出 foobar另一个更重要的功能是Mixins，可以将一个Module混入类别之中，这样这个类别就会拥有此Module的方法。这回让我们拆成两个档案，debug.rb和foobar.rb，然后在foobar.rb中用require来引用debug.rb：
首先是debug.rb
module Debug
def who_am_i?
puts "#{self.class.name}: #{self.inspect}"
end
end然后是foobar.rb
require "./debug"
class Foo
include Debug # 這個動作叫做 Mixin
end
class Bar
include Debug
end
f = Foo.new
b = Bar.new
f.who_am_i? # 輸出 Foo: #<Foo:0x00000102829170>
b.who_am_i? # 輸出 Bar: #<Bar:0x00000102825b88>Ruby使用Module来解决多重继承的问题，不同类别之间但是拥有相同的方法，就可以改放在Module里面，然后include它即可。
不同于while循环用法，Ruby习惯使用迭代器(Iterator)来走访循环，例如each是一个阵列的方法，它会走访其中的元素，其中的do ... end是each方法的参数，称作Code Block，是一个匿名函式(anonymous function)。范例程式如下：
languages = ['Ruby', 'Javascript', 'Perl']
languages.each do |lang|
puts "I love #{lang}!"
end
# I Love Ruby!
# I Love Javascript!
# I Love Perl!其中两个直线|中间的lang被称作Block variable区块变量，每次迭代都会被设定成不同元素。其他迭代器范例如：
# 反覆三次
3.times do
puts 'Good Job!'
end
# Good Job!
# Good Job!
# Good Job!
# 從一數到九
1.upto(9) do |x|
puts x
end
# 多一個索引區塊變數
languages = ['Ruby', 'Javascript', 'Perl']
languages.each_with_index do |lang, i|
puts "#{i}, I love #{lang}!"
end
# 0, I Love Ruby!
# 1, I Love Javascript!
# 2, I Love Perl!(Code block)的形式除了do ... end，也可以改用大括号。通常单行会会用大括号，多行会用do ... end的形式。
3.times { puts "Hello" }透过迭代器，我们就比较少用到while、until、for等循环语法了。
# 迭代並造出另一個陣列
a = ["a", "b", "c", "d"]
b = a.map {|x| x + "!" }
puts b.inspect
# 結果是 ["a!", "b!", "c!", "d!"]
# 找出符合條件的值
b = [1, 2, 3].find_all{ |x| x % 2 == 0 }
b.inspect
# 結果是 [2]
# 迭代並根據條件刪除
a = [51, 101, 256]
a.delete_if {|x| x >= 100 }
# 結果是 [51]
# 客製化排序
[2, 1, 3].sort! { |a, b| b <=> a }
# 結果是 [3, 2, 1]
# 計算總和
(5..10).inject {|sum, n| sum + n }
# 結果是 45
# 找出最長字串find the longest word
longest = ["cat", "sheep", "bear"].inject do |memo, word|
( memo.length > word.length ) ? memo : word
end
# 結果是 "sheep"
<=>是比较运算子，当两个数字相等于回传0，第一个数字较大时回传1，反之回传-1
除了迭代，Code block只会执行一次的特性也很有用，例如用来开启档案。往常我们在档案处理完毕之后，会使用close方法关闭：
file = File.new("testfile", "r")
# ...處理檔案
file.close改用Code block语法之后，Ruby就会在Code block结束后自动关档：
File.open("testfile", "r") do |file|
# ...處理檔案
end
# 檔案自動關閉Code block的这个特性不只让你少打close方法，更可以避免你忘记关闭档案(不然就语法错误了)，也有视觉上缩排的好处。
在方法中使用yield可以执行Code block参数：
# 定義方法
def call_block
puts "Start"
yield
yield
puts "End"
end
call_block { puts "Blocks are cool!" }
# 輸出
# "Start"
# "Blocks are cool!"
# "Blocks are cool!"
# "End"def call_block
yield(1)
yield(2)
yield(3)
end
call_block { |i|
puts "#{i}: Blocks are cool!"
}
# 輸出
# "1: Blocks are cool!"
# "2: Blocks are cool!"
# "3: Blocks are cool!"可以将Code block明确转成一个变量：
def call_block(&block)
block.call(1)
block.call(2)
block.call(3)
end
call_block { |i| puts "#{i}: Blocks are cool!" }
# 輸出
# "1: Blocks are cool!"
# "2: Blocks are cool!"
# "3: Blocks are cool!"
# 或是先宣告出 proc object
proc_1 = Proc.new { |i| puts "#{i}: Blocks are cool!" }
proc_2 = lambda { |i| puts "#{i}: Blocks are cool!" }
call_block(&proc_1)
call_block(&proc_2)
# 分別輸出
# "1: Blocks are cool!"
# "2: Blocks are cool!"
# "3: Blocks are cool!"def my_sum(*val)
val.inject { |sum, v| sum + v }
end
puts my_sum(1, 2, 3, 4) # val 變數就是 [1, 2, 3, 4]
# 輸出 10其中my_sum方法中的val是一个包含所有参数的阵列。
{ }
def my_print(a, b, options)
puts a
puts b
puts options[:x]
puts options[:y]
puts options[:z]
end
my_print("A", "B", { :x => 123, :z => 456 } )
my_print("A", "B", :x => 123, :z => 456) # 結果相同
# 輸出 A
# 輸出 B
# 輸出 123
# 輸出 nil
# 輸出 456使用rescue可以将例外救回来：
begin
puts 10 / 0 # 這會丟出 ZeroDivisionError 的例外錯誤
rescue => e
puts e.class # 如果發生例外會執行 rescue 這一段
ensure
# 無論有沒有發生例外，ensure 這一段都一定會執行
end
# 輸出 ZeroDivisionError使用raise可以手动触发例外错误：
raise "Not works!!"
# 丟出一個 RuntimeError
# 自行自定例外物件
class MyException < RuntimeError
end
raise MyExceptionMetaprogramming是很进阶的技巧，这里示范define_method方法可以动态定义方法：
class Dragon
define_method(:foo) { puts "bar" }
['a', 'b', 'c', 'd', 'e', 'f'].each do |x|
define_method(x) { puts x }
end
end
dragon = Dragon.new
dragon.foo # 輸出 bar
dragon.a # 輸出 a
dragon.f # 輸出 fRuby拥有许多反射方法，可以动态知道物件的资讯：
# 這個物件有什麼方法
Object.methods
=> ["send", "name", "class_eval", "object_id", "new", "singleton_methods", ...]
# 這個物件有這個方法嗎？
Object.respond_to? :name
=> trueresult ||= a如果result是nil或false的话，将a指派给result，如果不是的话，什么都不做。以上这段程式等同于
result || ( result = a )除了本书介绍的Ruby on Rails之外，Ruby也有各式各样的应用，以下兹举一些使用Ruby发展的专案：
你可以在The Ruby Toolbox和Awesome Ruby找到更多推荐的Ruby套件和应用。