iterator ruby introduce

http://ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html

C:\Users\Administrator>irb
irb(main):001:0> def a(name)
irb(main):002:1> yield
irb(main):003:1> puts "hello"
irb(main):004:1> yield
irb(main):005:1> end
=> nil
irb(main):006:0> a("1")
LocalJumpError: no block given (yield)
        from (irb):2:in `a'
        from (irb):6
        from C:/Ruby192/bin/irb:12:in `<main>'
irb(main):007:0> a("dd") do
irb(main):008:1* puts "z"
irb(main):009:1> end
z
hello
z
=> nil
irb(main):010:0> aa=a("dd") do
irb(main):011:1* puts "z"
irb(main):012:1> end
z
hello
z
=> nil
irb(main):013:0> aa=a("dd") do
irb(main):014:1* "z"
irb(main):015:1> end
hello
=> "z"
irb(main):016:0>

Ruby代码块是用大括号或者do...end括起来的一系列代码。

1. { puts "Hello" }

Ruby代码块贯穿在实现迭代器的Ruby库中，迭代器就是一种方法，用来连续返回某种集合的元素，比如一个数组。

块的真正的作用是当你创建了一个块之后，你就可以将它与函数联系在一起。你可以在调节器用函数的那一行代码之后加入一个块。

http://developer.51cto.com/art/200912/170500.htm

&block

使用

http://blog.codahale.com/2005/11/24/a-ruby-howto-writing-a-method-that-uses-code-blocks/

Style:

Background
Foreground
Link Color
Link Visited

  Size:




  Width:



More ▼

Open Mode
Overlay Original
Replace Original

---

Font
Arial
Tahoma
Verdana
Georgia
Segoe
Times
Book
Comic
Courier
Trebuchet
Palatino
Lucida

---

Text Align
Left
Justify

---

Text Dir
Left to Right
Right to Left

---

Disable TidyRead
Save Settings
Print
Close

《Ruby》Ruby代码块和迭代器

推荐给好友收藏到IE收藏夹收藏到QQ书签收藏到百度收藏到Google

作者：追梦　　来源：http://www.itrenjia.org 　　日期：2010-07-25 22:54:38　　（共有0条评论）我要评论

第五章代码块和迭代器
&sect;5.1 代码块(Block)
&sect;5.1.1什么是代码块
在Ruby中在在大括号之间的代码或放在do/end之间的代码是一个代码块。代码块只能出现在一个方法的后边，它紧接在方法最后一个参数的同一行上

第五章代码块和迭代器

§5.1 代码块(Block)

§5.1.1什么是代码块

在 Ruby中在在大括号之间的代码或放在do/end之间的代码是一个代码块。代码块只能出现在一个方法的后边，它紧接在方法最后一个参数的同一行上。代码块的内容并不会被马上执行，当执行到被调用的方法时，解释器的运行时环境会记住代码块出现的现场，然后执行被调用的方法。

[1,2,3,4,5].each { |i|

    puts i

}

[1,2,3,4,5].each do |i|

    puts i

end

一般的使用习惯是：（to-do 具体解释）

l 当关心边际(side effect)效应时使用 do/end。

l 当关心返回结果应时使用大括号。

§5.1.2代码块与对象

代码块并不是对象，但可以方便的转化为Proc类的对象。有三种转化的方法：

l 将一个代码块传递给最后一个参数以&开始的方法。

def meth1(p1, p2, &block)

     puts block.inspect

     puts block.call

end

meth1(1, 2) { "This is a block" }

l 使用Proc.new方法，后边的参数为一个代码块：

block = Proc.new { "a block" }

l 调用Kernel.lambda方法：

       block = lambda { "a block" }

前两种方法是等价的，而第三种方法，用 lambda 生成的 Proc 对象和用 Proc.new 生成的 Proc 对象之间是有差别的。这是一个微妙的差别，这个差别与 return 关键字相关。lambda 中的 return 从 lambda 返回。而 Proc 中的 return 从外围方法返回。

可以看以下两个例子：

def test_proc

    p = Proc.new { return 1 }

    p.call

    puts "Never come here"

end

test_proc     #=> 1

执行后"Never come here"不会被输出，执行p.call相当于在test_proc方法内执行了return语句。

def test_lambda

    p = lambda { return 1 }

    result = p.call

    puts "The value is: #{result}"

end

test_lambda

执行后的结果为：

The value is: 1

可见使用lambda生成的Proc对象执行call方法调用时，return表示从lambda包围得块内返回。

在一个代码块中执行next语句会导致代码块返回。返回值就是next语句后带的参数。如果next后没有参数，那么返回值为nil。

def meth2

       result = yield

       "The block result is #{result}"

end

puts meth2 { next 9 }

pr = Proc.new { next 100 }

puts pr.call

pr = lambda { next }

puts pr.call

执行结果为：

The block result is 9

100

nil

§5.2 迭代器(Iterator)

§5.2.1什么是迭代器

简单的讲，一个迭代器就是一个能接受代码块的方法。当初为了进行迭代操作而设置了带块方法，所以现在它仍然常常被称作迭带器。

[1,2,3,4,5].each { |i|

        puts i

}

上述代码中，each方法反复调用代码块，我们称each方法为一个迭代器。

迭代器(Iterator)即指调用带块方法。实际上，在早期版本的 Ruby 中，使用代码块的方法被称为迭代器，因为它们就是被设计来实现循环迭代的。但是在Ruby发展过程中，代码块的用途在后来已经得到了很大的增强，从最初的循环抽象到任何事情。可以将那些进行迭代操作的方法叫做迭代器，但如果将所有带块方法的调用过程都看作迭带器的话，并不合适而且概念上会引起混乱

§5.2.2使用迭代器

#一个使用迭代器的简单例子，数组中每一个元素作为参数执行其后的代码块

['This', 'is', 'a', 'dog'].each do |entry|

       print entry, ' '

end

执行结果为：

    This is a dog

    #另一个使用迭代器的例子，代码块可以访问其外的数据

factorial = 1

1.upto(10) do |i|

        factorial*= i

end

puts factorial

执行结果为：

    3628800

#代码块的返回值可以被调用者使用

b = [1, 2, 3, 4, 5].map do |entry|

    entry * entry

end

print b.inspect

执行结果为：

    [1, 4, 9, 16, 25]

#代码块也可以使用一个以上的参数

result = (0..100).inject(0) do |sum, i|

    sum + i

end

print result

执行结果为：

5050

§5.2.3 yield

在方法中可以使用yield来执行代码块的内容，就好像传入的代码块是这个方法的一部分一样。每当碰到一个yield调用，代码块的内容就会被执行一次。当代码块执行结束后，程序会回到yield的那一行继续向下执行。

def twoTimes

        yield

        yield

end

twoTimes { puts "Hello World!" }

执行结果为：

Hello World!

Hello World!

你可以使用yield操作传参数给一个代码块，并且从代码块取回返回值。

def fibonacii(max)

       f1, f2 = 1, 1

       while f1 <= max

           yield f1

           f1, f2 = f2, f1+f2

       end

end

fibonacii(1000) { |f| print f, " " }

执行结果为：

    1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

在这个例子中，yield接收一个参数，这个参数将会在执行的时候传递给指定的代码块。在代码块中，接收的参数使用两个竖线括起来放在代码块的头部。yield操作也可以有返回值，yield操作的返回值就是代码块中最后一个表达式的值。

§5.2.4 编写自己的迭代器

def factorial(count, &block)

        value = 1

        1.upto(count) do |i|

            value = value * i

            block.call(i, value)

        end

end

factorial(5) do |i, sum|

        puts "factorial(#{i}) = #{sum}"

end

执行结果为：

factorial(1) = 1

factorial(2) = 2

factorial(3) = 6

factorial(4) = 24

factorial(5) = 120

也可以将传入的代码块保存以供以后使用：

class Mathematics

        def initialize(&block)

           @block = block

        end

        def factorial(max)

            value = 1

            1.upto(max) do |i|

               value = value * i

               @block.call(value)

            end

        end

end

the_value = Mathematics.new do |count|

        puts "Current value is #{count}"

end

the_value.factorial(5)

执行结果为：

Current value is 1

Current value is 2

Current value is 6

Current value is 24

Current value is 120

关键词：Ruby代码块和迭代器

下一篇： 《Ruby》Ruby基本类型

您看到此新闻时的感受是：

• 
  支持
• 
  高兴
• 
  震惊
• 
  愤怒
• 
  无奈
• 
  谎言
• 
  枪稿
• 
  不解
• 
  搞笑
• 
  无聊
• 
  标题党

相关文章

• 《Ruby》Ruby代码块和迭代器[2010-07-25]
• 《Ruby》Ruby基本类型[2010-07-25]
• 《Ruby》Ruby类与对象[2010-07-25]
• 《Ruby》Ruby编程环境安装[2010-07-25]
• 《Ruby》Ruby语言概述[2010-07-25]

用户评论

http://www.itxuexi.com/tech/script/ruby/85561252680952.html

Style:

Background
Foreground
Link Color
Link Visited

  Size:




  Width:



More ▼

Open Mode
Overlay Original
Replace Original

---

Font
Arial
Tahoma
Verdana
Georgia
Segoe
Times
Book
Comic
Courier
Trebuchet
Palatino
Lucida

---

Text Align
Left
Justify

---

Text Dir
Left to Right
Right to Left

---

Disable TidyRead
Save Settings
Print
Close

Ruby入门介绍

2009-09-11 22:55:52 来源:脚本之家(www.jb51.net) 【大 中 小】 评论：0 条

-

一、方法
Ruby 的方法定义允许为参数设置默认值，不过在带有默认值的参数后面不能出现不带有默认值的参数（允许 * 和 &），也就是说下面的方法定义是不被允许的，解释时会出现 parse error。 还有一点与 C# 不同的是，方法定义不能出现在方法调用的后面。

# parse error
def Display(args1="proshea", args2)
end
# 允许
def Display(args1="proshea", *args2)
end
# 允许
def Display(args1="proshea", &args)
end
Show()
# 出现在 Show 调用之后是错误的
def Show
end

Ruby 也支持 C# params 这样的参数功能， 只是 Ruby 用 * 标识罢了。

def Display(*args)
print %Q~#{args.join("-")}~
end
# proshea-32-WinForm
Display("proshea", 32, "WinForm") 

同样的， Ruby 也有类似于 C# delegate 的应用，只是更简单，直接用 & 来表示，并且 Ruby 用一个称为 yield 的关键字来知会解释器执行传入的代码块或者说 Proc object（过程对象？）。

1def Display(&block)
2 if block_given?
3 yield(block)
4 else
5 print %Q~没有传入过程对象~
6 end
7end
8
9def Show()
10 print %Q~Show 方法调用~
11end
12
13# 没有传入过程对象
14Display()
15# 在 Display 内部调用 Show 方法
16# 注意起始大括号仍然只能和方法名在同一行
17Display(){
18 Show()
19} 

block_given? 是被定义在内部模块 Kernel 当中的方法，用以表明是否传入了 Proc object。之后，Ruby 用 yield 通知解释器执行传入的 Proc。过程对象也可以带有参数，不同于普通方法的是过程对象的参数是位于一组 | | 之中。可以使用 Proc object 的 call 方法来调用带参数的过程对象。

1class Employee
2 def initialize(username, age, &block)
3 @username, @age, @block = username, age, block
4 end
5
6 def Display(txt)
7 # 虽然 @block 是个实例变量，但在此处一定要加上大括号
8 print "#{@block.call(txt)}: #@username-#@age"
9 end
10end
11
12emp = Employee.new("proshea", 32){
13 |txt|
14 txt
15}
16emp.Display("context")

1

-

1 2 3 4 5 下一页

您看完这篇文章的心情是： <已有0人发表看法>

0

0

0

0

0

0

0

0

吃惊
欠揍
支持
很棒
一般
搞笑
扯淡
不解

收藏到网摘：

Tags：Ruby 入门