原文:http://ihower.tw/rails3/ruby.html
Ruby程序语言入门
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社区 所翻译的文章可以一读:
- Ruby中文官方網站:Ruby簡介 http://www.ruby-lang.org/zh_TW/about/
- Ruby中文官方網站:二十分鐘Ruby體驗 http://www.ruby-lang.org/zh_TW/documentation/quickstart/
- Ruby中文官方網站:從其他程式語言到Ruby http://www.ruby-lang.org/zh_TW/documentation/ruby-from-other-languages/
- Ruby使用手冊 http://guides.ruby.tw/ruby/
各种Ruby实现
除了用C語言实现的官方版Ruby(又叫做CRuby或MRI, Matz’s Ruby Interpreter)http://ruby-lang.org/,也有其他不同实现的Ruby环境。這些实现都以RubySpec作为其语法的标准:
- JRuby http://jruby.org/是由Java实现的Ruby,运行在高效能、支援系統執行緒及有非常多函数库的Java虚拟机(JVM)上。JRuby算是目前Ruby要开发跨平台(Windows、Mac和Linux)桌面软件最好的选择。
- MacRuby http://www.macruby.org/是由Objective-C实现的 Ruby,運作在Mac OS X操作系统上。强项在于开发Mac原生桌面软件,未來有机会可以运行在iOS上,甚至成为Apple官方程序语言之一。
- Rubinuis http://rubini.us/是用C++、Ruby和LLVM编译器技术实现的Ruby VM,可以在Mac OS X、Debian/Ubuntu、FreeBSD、Windows上执行。LLVM可以說是当代代最重要的编译器架构,拥有各种编译器最佳优化技术。给給Ruby带來多少效能改善幅度,值得关注。
- Ruby Enterprise Edition(简称REE) http://www.rubyenterpriseedition.com/是个非常流行的CRuby 1.8分支版本,特別适合用來搭配Ruby on Rails和Phusion Passenger使用,相对于Ruby 1.8.7可以增加效能和节省内存使用量。
- IronRuby http://ironruby.net/是由.NET实现的Ruby,使用了Dynamic Language Runtime技术。
IRB(Interactive Ruby)
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++是弱分型(注:原文就是这样,不过貌似,java,C,C++应该是强类型语言)。让我们举个例子吧:
/* PHP */
$i = 1;
echo "Value is " + $i
# 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是个动态强类型的解释程序语言。
整数Integer
任何整数都是Fixnum对象:
5
-205
9999999999
0
完整的Fixnum API请参考Ruby doc文件。
浮点数Float
中间带有点号的就是浮点数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
使用单引号或双引号括起来的就是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
puts var3.downcase
完整的String API请参考Ruby doc文件。
Ruby完全地物件導向
你可能已经注意到,在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
局部变量Local Variable
局部变量使用小写开头,习惯单字之间以下划线_
來分隔。示例如下:
composer = 'Mozart'
puts composer + ' was "da bomb", in his day.'
my_composer = 'Beethoven'
puts 'But I prefer ' + my_composer + ', personally.'
类型转换Conversions
刚刚提到数字和字符串不能直接相加,你必須使用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
常量Constant
大写开头的为常量,示例如下:
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
nil.class # NilClass
nil.nil? # true
42.nil? # false
nil == nil # true
false == nil # false
注释
Ruby偏好一律使用单行注释:
# this is a comment line
# this is a comment line
多行注释比较少見:
=begin
This is a comment line
This is a comment line
=end
字串符号Symbols
Symbol一种唯一且不会变动的识别名称,用冒号开头:
: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 # 输出 577768
object_id
方法会返回Ruby內部的内存保存的编号,你会发现相同內容的字串,也会是不同的新对象,但是Symbol不会。这种特性让Symbol的主要用途是当做Hash的鍵,一会就会介绍到。
数组Array
使用中括号,索引从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
如果读取一个沒有赋值的数组元素,预设值是nil
。更多数组方法示例:
colors = ["red", "blue"]
colors.push("black")
colors << "white"
puts colors.join(", ") # red, blue, black, white
colors.pop
puts colors.last #black
完整的Array API请参考Ruby doc文件。
Hash
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
。
完整的Hash API請參考Ruby doc文件。
注意到Ruby 1.8的Hash不像Array,你无法预测里面的鍵值顺序。例如输入{ :a => 1, :b=> 2, :c => 3 }.merge( :d => 4 )
會输出成{:a=>1, :d=>4, :b=>2, :c=>3}
。這個问题在Ruby 1.9获得修正,会依照你給的顺序输出成{:a=>1, :b=>2, :c=>3, :d=>4}
。
流程控制Flow Control
让我们來看看一些流程控制:
比较方法
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 ) # 或
控制结构If
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
case name
when "John"
puts "Howdy John!"
when "Ryan"
puts "Whatz up Ryan!"
else
puts "Hi #{name}!"
end
循环 while, loop, until, next and break
while用法范例:
i=0
while ( i < 10 )
i += 1
next if i % 2 == 0 #跳過偶数
end
until用法示例:
i = 0
i += 1 until i > 10
puts i
# 輸出 11
loop用法示例:
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
正则表达式Regular Expressions
于Perl类似的语法,使用=~
:
# 抓出手手机号码
phone = "123-456-7890"
if phone =~ /(\d{3})-(\d{3})-(\d{4})/
ext = $1
city = $2
num = $3
end
方法定义Methods
使用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
方法),绝大部分的情況加上括号比较无疑虑。
?
与
!
的惯例
方法名称可以用?
或!结尾
,前者表示会回传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]
类Classes
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
除了对象方法与对象变量,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')
p.name
=> "ihower"
p.name="peny"
=> "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
end
p = Person.new('ihower')
p.name
=> "ihower"
p.name="peny"
=> "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
end
Ruby的private和protected定义和其他程序语言不同,都是可以在整个继承体系內调用。兩著差別在于private只有不指定接受者(receiver)時才可以调用,你甚至不能打self.private_method_1
,默认一定就是self当成private方法的接受者。而protected方法除了可以被一个类或子类的对象调用,也可以让另一个相同类的对象來当做接受者。
Class 继承
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而发生错误。
循环遍历与迭代器Iterator
不同於while循环
用法,Ruby习惯使用迭代器(Iterator)來遍历循环,例如each
是一個数组的方法,它會遍历其中的元素,其中的do .... end
是each
方法的參數,称为匿名方法(code block)。范例程序如下:
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) { |x| puts x }
# 多一個索引临时变量
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 }
# 找出最长字串find the longest word
longest = ["cat", "sheep", "bear"].inject do |memo,word|
( memo.length > word.length )? memo : word
end
仅执行一次调用
除了迭代,也有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
在方法中使用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"
帶有參數的Code block
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!"
Proc object
可以將Code block明確轉成一個變數:
def call_block(&block)
block.call(1)
block.call(2)
block.call(3)
end
call_block { |i| puts "#{i}: 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
是一个包含所有参数的数组。
参数尾巴的Hash可以省略{ }
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 MyException
Module
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
它即可。
Metaprogramming用程式寫程式
Metaprogramming是很進階的技巧,這裡示範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 # 輸出 "f"
Introspection反射機制
Ruby擁有許多反射方法,可以動態知道物件的資訊:
# 這個物件有什麼方法
Object.methods
=> ["send", "name", "class_eval", "object_id", "new", "singleton_methods", ...]
# 這個物件有這個方法嗎?
Object.respond_to? :name
=> true
其他常見慣例
result ||= a
如果result
是nil
或false
的話,將a
指派給result
。以上這段程式等同於
result || ( result = a )
參考投影片
- Ruby 程式語言入門導覽 http://ihower.tw/rails3/files/ruby-intro.pdf
- Ruby 1.9 投影片 http://www.slideshare.net/ihower/ruby-19-1311075