语句
if 修饰符
if修饰词组表示当 if 右边之条件成立时才执行 if 左边的式子。即如果 conditional 为真，则执行 code。
1
| puts "foo is initialized." if foo
|
unless 语句
1
2
3
4
| unless conditional [then]
code
[else
code ]
|
unless式和 if式作用相反，即如果 conditional 为假，则执行 code。如果 conditional 为真，则执行 else 子句中指定的 code。
1
2
3
4
5
6
| x=1
unless x>2
puts "x is less than 2"
else
puts "x is bigger than 2"
end
|
unless 修饰符
1
| code unless conditional
|
如果 conditional 为假，则执行 code
1
2
3
| $var = 1
print "1 -- 这一行输出\n" if $var
print "2 -- 这一行不输出\n" unless $var
|
case 语句
1
2
3
4
5
6
| case expression
[when expression [, expression ...] [then]
code ]...
[else
code ]
end
|
case先对一个 expression 进行匹配判断，然后根据匹配结果进行分支选择。
1
2
3
4
5
6
7
8
9
10
11
12
13
| $age = 5
case $age
when 0 .. 2
puts "婴儿"
when 3 .. 6
puts "小孩"
when 7 .. 12
puts "child"
when 13 .. 18
puts "少年"
else
puts "其他年龄段的"
end
|
while 语句
1
2
3
4
5
6
7
8
9
10
11
| while conditional [do]
code
end
$i = 0
$num = 5
while $i < $num do
puts("在循环语句中 i = #$i" )
$i +=1
end
|
while 修饰符
1
2
3
4
5
6
7
8
9
| code while condition
$i = 0
$num = 5
begin
puts("在循环语句中 i = #$i" )
$i +=1
end while $i < $num
|
until 语句
1
2
3
| until conditional [do]
code
end
|
当 conditional 为假时，执行 code。
1
2
3
4
5
6
7
| $i = 0
$num = 5
until $i > $num do
puts("在循环语句中 i = #$i" )
$i +=1;
end
|
for 语句
1
2
3
| for variable [, variable ...] in expression [do]
code
end
|
先计算表达式得到一个对象，然后针对 expression 中的每个元素分别执行一次 code。
1
2
3
| for i in 0..5
puts "局部变量的值为 #{i}"
end
|
break 语句
终止最内部的循环。如果在块内调用，则终止相关块的方法（方法返回 nil）。
next 语句
跳到循环的下一个迭代。如果在块内调用，则终止块的执行（yield 表达式返回 nil）。
方法
语法
方法名应以小写字母开头。如果您以大写字母作为方法名的开头，Ruby 可能会把它当作常量，从而导致不正确地解析调用。
1
2
3
| def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
expr..
end
|
以为参数设置默认值，如果方法调用时未传递必需的参数则使用默认值
调用方法时，只需要使用方法名即可
当调用带参数的方法时，在写方法名时还要带上参数
1
2
3
4
5
6
7
8
9
| method_name 25, 30
def test(a1="Ruby", a2="Perl")
puts "编程语言为 #{a1}"
puts "编程语言为 #{a2}"
end
test "C", "C++"
test
|
返回值
Ruby 中的每个方法默认都会返回一个值。这个返回的值是最后一个语句的值
1
2
3
4
5
| def test
i = 100
j = 10
k = 0
end
|
在调用这个方法时，将返回最后一个声明的变量 k。
return 语句
return 语句用于从 Ruby 方法中返回一个或多个值
1
2
3
4
5
6
7
8
| def test
i = 100
j = 200
k = 300
return i, j, k
end
var = test
puts var
|
输出结果为：
可变数量的参数
Ruby 允许声明参数数量可变的方法。
1
2
3
4
5
6
7
8
| def sample (*test)
puts "参数个数为 #{test.length}"
for i in 0...test.length
puts "参数值为 #{test[i]}"
end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"
|
类方法
当方法定义在类的外部，方法默认标记为 private。另一方面，如果方法定义在类中的，则默认标记为 public。
alias 语句
为方法或全局变量起别名。别名不能在方法主体内定义。即使方法被重写，方法的别名也保持方法的当前定义
1
2
| alias 方法名 方法名
alias 全局变量 全局变量
|
块
块由大量的代码组成。
需要给块取个名称。
块中的代码总是包含在大括号 {} 内。
块总是从与其具有相同名称的函数调用。这意味着如果您的块名称为 test，那么您要使用函数 test 来调用这个块。
您可以使用 yield 语句来调用块。
yield 语句
1
2
3
4
5
6
| def test
yield 5
puts "在 test 方法内"
yield 100
end
test {|i| puts "你在块 #{i} 内"}
|
运行结果为：
1
2
3
| 你在块 5 内
在 test 方法内
你在块 100 内
|
yield 语句后跟着参数。您甚至可以传递多个参数。在块中，您可以在两个竖线之间放置一个变量来接受参数。
传递多个参数，那么 yield 语句如下所示：
此时，块如下所示：
1
| test {|a, b| statement}
|
BEGIN 和 END 块
每个 Ruby 源文件可以声明当文件被加载时要运行的代码块（BEGIN 块），以及程序完成执行后要运行的代码块（END 块）。
一个程序可以包含多个 BEGIN 和 END 块。BEGIN 块按照它们出现的顺序执行。END 块按照它们出现的相反顺序执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| BEGIN {
# BEGIN 代码块
puts "BEGIN 代码块"
}
END {
# END 代码块
puts "END 代码块"
}
# MAIN 代码块
puts "MAIN 代码块"
|
产生以下结果：
1
2
3
| BEGIN 代码块
MAIN 代码块
END 代码块
|
模块（Module）
模块（Module）是一种把方法、类和常量组合在一起的方式。模块（Module）为您提供了两大好处。
1
2
| 模块提供了一个命名空间和避免名字冲突。
模块实现了 mixin 装置。
|
模块与类相似，但有一下不同：
1
2
3
| 模块不能实例化
模块没有子类
模块只能被另一个模块定义
|
require 语句
require 语句类似于 C 和 C++ 中的 include 语句以及 Java 中的 import 语句。require 语句来加载模块文件。
include 语句
在类中嵌入模块。为了在类中嵌入模块，您可以在类中使用 include 语句：
1
2
3
4
5
6
7
8
9
10
11
| # 定义在 support.rb 文件中的模块
module Week
FIRST_DAY = "Sunday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end
|
在类中引用该模块：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| $LOAD_PATH << '.'
require "support"
class Decade
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months
|
$LOAD_PATH « ’.’ 让 Ruby 知道必须在当前目录中搜索被引用的文件。如果您不想使用 $LOAD_PATH，那么您可以使用 require_relative 来从一个相对目录引用文件。
Mixins
Ruby没有真正实现多重继承机制，而是采用成为mixin技术作为替代品。将模块include到类定义中，模块中的方法就mix进了类中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| module A
def a1
end
def a2
end
end
module B
def b1
end
def b2
end
end
class Sample
include A
include B
def s1
end
end
samp=Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1
|
字符串（String）
Ruby 字符串分为单引号字符串（’）和双引号字符串（”），区别在于双引号字符串能够支持更多的转义字符。
在双引号字符串中我们可以使用 #{} 井号和大括号来计算表达式的值：
1
2
3
| name1 = "Joe"
name2 = "Mary"
puts "你好 #{name1}, #{name2} 在哪?"
|
String内建方法
参考 http://www.runoob.com/ruby/ruby-string.html
1
2
3
4
| myStr = String.new("THIS IS TEST")
foo = myStr.downcase
puts "#{foo}"
|
数组（Array）
参考 http://www.runoob.com/ruby/ruby-array.html
范围（Range）
