1. 使用send方法

第一种实现动态方法调用是使用send方法，send方法在Object类中定义，方法的第一个参数是一个符号用来表示所要调用的方法，后面则是所调用方法需要的参数。

“This is a dog1″.send(:length) =>14

上面的代码中通过send方法去对一个字符串执行length操作，返回字符串的长度。

class TestClass

def hello(*args)

”Hello ” + args.join(‘ ‘)

end

end

a = TestClass.new

puts a.send :hello, “This”, “is”, “a”, “dog!”

执行结果为：

Hello This is a dog!

2. 使用Method类和UnboundMethod类

另一种实现动态方法调用是使用Object类的method方法，这个方法返回一个Method类的对象。我们可以使用call方法来执行方法调用。

test1 = “This is a dog1″.method(:length)

test1.call =>14

class Test

def initialize(var)

@var = var

end

def hello()

”Hello, @var = #{@var}”

end

end

k = Test.new(10)

m = k.method(:hello)

m.call #=>“Hello, @iv = 99″

l = Test.new(‘Grant’)

m = l.method(“hello”)

m.call #=>“Hello, @iv = Fred”

可以在使用对象的任何地方使用method对象，当调用call方法时，参数所指明的方法会被执行，这种行为有些像C语言中的函数指针。你也可以把method对象作为一个迭代器使用。

def square(a)

a*a

end

mObj = method(:square)

[1, 2, 3, 4].collect(&mObj) =>　[1 4 9 16]

Method对象都是和某一特定对象绑定的，也就是说你需要通过某一对象使用Method对象。你也可以通过UnboundMethod类创建对象，然后再把它绑定到某个具体的对象中。如果UnboundMethod对象调用时尚未绑定，则会引发异常。

class Double

def get_value

2 * @side

end

def initialize(side)

@side = side

end

end

a = Double.instance_method(:get_value) #返回一个UnboundMethod对象

s = Double.new(50)

b = a.bind(s)

puts b.call

执行结果为：

100

看下面一个更具体的例子：

class CommandInterpreter

def do_2() print “This is 2\n”end

def do_1() print “This is 1\n”end

def do_4() print “This is 4\n”end

def do_3() print “This is 3\n”end

Dispatcher = {

?2 =>instance_method(:do_2),

?1 =>instance_method(:do_1),

?4 =>instance_method(:do_4),

?3 =>instance_method(:do_3)

}

def interpret(string)

string.each_byte {|i| Dispatcher[i].bind(self).call }

end

end

interpreter = CommandInterpreter.new

interpreter.interpret(’1234′)

执行结果为：

This is 1

This is 2

This is 3

This is 4

3. 使用eval方法

我们还可以使用eval方法实现方法动态调用。eval方法在Kernel模块中定义，有多种变体如class_eval，module_eval，instance_eval等。Eval方法将分析其后的字符串参数并把这个字符串参数作为Ruby代码执行。

str = “Hello”

eval “str + ‘ World!’” =>Hello World!

sentence = %q{“This is a test!”.length}

eval sentence =>15

当我们在使用eval方法时，我们可以通过eval方法的第二个参数指明eval所运行代码的上下文环境，这个参数可以是Binding类对象或Proc类对象。Binding类封装了代码在某一环境运行的上下文，可以供以后使用。

class BindingTest

def initialize(n)

@value = n

end

def getBinding

return binding() #使用Kernel#binding方法返回一个Binding对象

end

end

obj1 = BindingTest.new(10)

binding1 = obj1.getBinding

obj2 = BindingTest.new(“Binding Test”)

binding2 = obj2.getBinding

puts eval(“@value”, binding1) #=>10

puts eval(“@value”, binding2) #=>Binding Test

puts eval(“@value”) #=>nil

可以看到上述代码中，@value在binding1所指明的上下文环境中值为10，在binding2所指明的上下文环境中值为Binding Test。当eval方法不提供binding参数时，在当前上下文环境中@value并未定义，值为nil。

一.

数组

  数组的创建 names = ["shiwanyin","jingshang","dapao","xishuai"]

  数组对象 数组对象未确定时，用[]表示一个空数组对象。

  从数组中抽取对象 names[0]

    print "第一个名字为:",names[0],"。\n"

  将对象保存到数组中  支持多种不同对象的混合保存。

  数组的大小

    array.size

  数组的循环

    names.each do |变量|

      希望循环的处理

    end

15散列类

    15.1复习散列

    15.2散列的创建

      15.2.1使用{}

        {键=>值}

        像下面那样指定键值对，键值对之间用逗号，隔开

        h1 = {"a"=>"b","c"=>"d"}

        p h1["a"]  #=>"b"

        用符号作为键时

        ｛键：值｝

        h2 = {a:"b",c:"d"}

        p h2  #=>{:a=>"b",:c=>"d"}

      15.2.2使用Hash.new

        用来创建新的散列的方法。

        指定参数值返回

    15.3 值的获取与设定

      与数组一样，散列也是用[]来实现与键相对应的元素值的获取与设定的。

      h = Hash.new

      h["R"] = "Ruby"

      p h["R"] #=>"Ruby"

      还可以用store方法设定值，用fetch方法获取值。下面的例子的执行结果与上面的例子是一样的。

      h = hash.new

      h.store("R","Ruby")

      p h.fetch("R")  #=>"Ruby"、(如果散列中不存在指定的键，程序就会发生异常)

      对fetch方法指定第二个参数，那么该参数值就会作为键不存在是散列的默认值。

      h = Hash.new

      p h.fetch("N"){String.new} #=>""

    15.3.1

      一次性获取所有的键值。由于散列是键值对形式的数据类型，因此获取键值的方法是分开的。

      h = {"a" = "b","c" = "d"}

      p h.keys  #=>["a","c"]

      p h.values #=>["b","d"]

      p h.to_a   #=>[["a","b"],["c","d"]]

      除了返回数组，使用迭代器获取散列值。

Number无需声明

字符串类

  14.1字符串的创建

    str1 = "字符串"；str2 = '字符串'。

    使用“”时可以执行用#｛｝括起来的Ruby式子。 这个#｛｝就称为内嵌表达式。

  14.1.1 %Q和%q

    创建包含“‘的字符串，使用%Q或者%q会比使用\"  \'更简单

    desc = %Q{Ruby的字符串中也可以使用’‘和”“}     %Q相当于用“”创建字符串

    str = %q|Ruby said, 'Hello world'             %q相当于用‘’创建字符串

  14.1.2

    使用Here Document

    Here Document 是源自于Unix的shell的一种程序写法。

    使用<<创建字符串（创建包含换行的长字符串时这个方法是最简单的）

    <<"结束标识符"

    字符串内容

    结束标识符

    <<后面的结束标识符可以用“”括着的字符串（转义字符和内嵌表达式）或者用‘’括着的字符串定义（原封不动的显示）。

    Here Document 的结束标识符一定要在行首。在程序缩进较深的地方会出现缩进乱掉的情况。

      使用<<- 代替 <<,忽略掉结束标识符前的空格和制表符。结束标识符就没有必要写在行首。

range类

r1=1..5     #定义范围对象r1,包括元素1,2,3,4,5

r2=Range.new(1,5)  #等价与1..5

r3=1...5     #定义范围对象r3,包括元素2,3,4

r4=Range.new(1,5,true) #等价与1...5

二。循环

1. times方法

在前面已经有提到过了，语法如下：

复制代码 代码如下:

循环次数.times do                    循环次数.times {

      重复执行的动作                          重复执行的动作              

end                                               }

#也可以在times模块中加入变量

5.times { |i|

    print "This is the", i+1, " time. \n"

}

# i变量是从0开始计算的

2. for 语句

复制代码 代码如下:

语法：

for 变量 in 开始数值..结束数值 do

   反复执行的动作

end

# do是可以省略的

from = 0

to = 20

sum = 0

for i in from..to

   sum += 1

end

语法：

for 变量 in 对象

  反复执行的动作

end

names = ["Windy", "Cindy", "Jack", "Hugo"]

for name in names

   print name, " likes Ruby. \n"

end

第二个语法的for语句，与java中的for each语句非常类似，for (i in list?) {...}

3. while 语句

while语句与JAVA中也是类似的

复制代码 代码如下:

语法：

while 条件 do

   反复执行的动作

end

a = 1

sum = 0

while a <10 do

   sum += a

   i += a

end

4. until 语句

其语法与while语句类似，只是只有条件不符合的时候，才会反复执行循环

复制代码 代码如下:

语法：

until 条件 do

    反复执行的动作

end

# do可以省略

sum = 0

until sum >50

   sum += 1

end

print sum

# 以上until循环可以转换成下面的while循环

while !(sum >50)

   sum += 1

end

5. each 方法

在前面已经提到过这个方法了，这里就简要记录下语法

复制代码 代码如下:

对象.each { |变量|

想要反复执行的动作

}

6. loop方法

它是一种没有结束条件的方法，只是不断进行循环处理，示例如下：

复制代码 代码如下:

loop {

   print "Ruby"

}

三。运算符

算术运算符+-*/   取余% 平方**

比较运算符  >,<,==,!=,>=,<=,===,<=>,.eql?,equal?(区别最后两个) 前者是判断两个数值是否相同，后者是判断是否为同一个数，如果不懂可以继续追问我。

四。正则表达式 这一部分应该是ruby的特色，建议你好好学学。推荐这个地址给你

http://www.runoob.com/ruby/ruby-regular-expressions.html

纯手打