Project1

标题: 【初阶】构建更智能的方法 - Ruby方法相关 [打印本页]
作者: DeathKing    时间: 2010-7-21 01:37
标题: 【初阶】构建更智能的方法 - Ruby方法相关
本帖最后由 DeathKing 于 2010-7-21 08:43 编辑

这个东西估计你看了也没用，很少人的工程中能用上这些东西。不过你必须承认，有了这些东西，可以使方法更具有弹性，更加灵活。

另外，欢迎大家丢砖指正。测试环境是Ruby1.8.1（RGSS），RGSS2也完全可以，甚至于Ruby1.9.6也能成功运行本次范例。

一、迭代
迭代允许我们执行由我们传递的一个语句块，当然，使用关键字yield。
  1. def a_yield_method
  2.     yield
  3. end
复制代码
调用a_yield_method {p "hi! I am a yield-method."}，由花括号扩住的正是我们所谓的“语句块”。事实上，你可以把一对{}替换为do~end，这似乎只关乎美观和“结合能力”的问题。
  1. a_yield_method {p "hi! I am a yield-method."}
  2. #=> "hi! I am a yield-method."
复制代码
这样做有个严重的问题，当我们没有传递块的时候，会触发LocalJumpError。Kernel模块提供了一个完美的解决办法，block_given?返回true或flase来标识是否传递了一个块。于是我对上一个方法稍作修改：
  1. def a_yield_method
  2.   if block_given?
  3.     yield                        # 如果传递了块就迭代
  4.   else
  5.     p "Miss"                        # 没传递就显示丢失
  6.   end
  7. end
复制代码
这样就可以确保万无一失，同时yield关键字可以让我们对原方法随时扩容，这是否又是得益于Ruby的强动态性呢？

二、块参数

在参数前加一个&，让他变成块参数，使得他可以接受Proc对象。值得一提的是，这里的&可不是C语言里面的取址运算符。
  1. def a_proc_method( &proc )
  2.   p proc.class
  3.   yield if block_given?
  4.   proc.call if block_given?
  5. end

  7. a_proc_method
  8. #=> NilClass

  10. a_proc_method { p "Double Kill" }
  11. #=> Proc
  12. #=> "Double Kill"
  13. #=> "Double Kill"
复制代码
这个例子很容易理解，我们利用反射机制检测着proc参数，并且如果传递了块就迭代并调用proc的call方法（由Proc类提供）。

三、参数列表

参数前加（一元）星号，是他称为参数列表（可变参数）。可变参数是一个数组对象，应该在定义方法时置于最后，并且没有默认值。可以用for关键字或者each（Array类提供）等方法遍历参数。

展望：Ruby 2.0以上的版本中，将添加**二元星号（作用貌似是可变参数，但是一个Hash对象？）。
  1. def multiple_arg_method( *args )
  2.   args.each do |e|
  3.     p e
  4.   end
  5. end

  7. multiple_arg_method(1,"2",3.0,[4,5],{6=>7},Proc.new{p "hi"})
  8. #=> 1
  9. #=> "2"
  10. #=> 3.0
  11. #=> [4,5]
  12. #=> {6=>7}
  13. #=> #<Proc>
复制代码
方法内部，我采取的策略是使用each方法迭代每一个元素，并用p给输出出来。可以想象，我们利用可变参数做一个简单的加法方法：
  1. def sum( *args )
  2.   result = 0
  3.   args.each do |e|
  4.     result += e
  5.   end
  6.   return result
  7. end

  9. p sum(1,2,3,4,5,6,7,8,9)
  10. #=> 45
复制代码
四、活用反射机制

众所周知，向量可以于一个数量相乘，亦可以于一个向量相乘，因此，我们可以利用反射机制定义一个智能的方法，辨识传递的参数，并作出智能的部署：

在本例中，假设向量是由Vector类管理，数量是由Numeric类管理。我们在Vector类里重载*运算符，向量的x，y坐标以@x，@y这两个实变量的形式存储。
  1. def *( opt )
  2.   if opt.is_a? Numeric                # 是数量
  3.     self.x *= opt
  4.     self.y *= opt
  5.     return self
  6.   elsif opt.is_a? Verctor        # 是向量
  7.     return self.x * opt.x + self.y * opt.y
  8.   end
  9. end
复制代码
很明显，我们利用is_a?方法，判定传递过来的参数是那个类的实例，从而决定改如何操作，这的确让方法变得灵活。当然也可以用.kind_of？或者.class.ancestors.include?方法来确定。

五、参数默认值

我们可以给参数制定默认值，当没有传递参数时，这使得Ruby不会发生ArgumentError。
  1. class Human
  2.   attr_reader :age
  3.   def initialize( age = 0)
  4.     @age = age
  5.   end
  6. end

  8. guest = Human.new
  9. p guest.age #=> 0
复制代码
没有传递参数，也可以正常使用？真是莫大的方便

[line]1[/line]

为什么有此文？晚上睡不着觉起来蛋疼……
作者: 紫苏    时间: 2010-7-21 01:55
呵呵，支持下～
动态参数列表在传参的时候也有应用，在数组对象前面加上 * 就表示展开数组，按先后顺序传递每个元素给方法～
multiple_arg_method(*[1, 2, 3, 4, 5])

向量相乘也分点积和叉积，这里写的应该是点积吧，后面一个运算符打错了：return self.x * opt.x + self.y * opt.y

关于 Ruby 2.0 的新运算符是在哪里看到的，求链接……Matz 好像在 RubyConf 上说过 2.0 会是一个 1.9 的增强版，不会有什么革命性的改变 ><
作者: dbshy    时间: 2010-7-21 10:34
好吧 在下的感觉是 总觉得这篇文章不痛不痒
就像是把参考手册照搬了一遍 内涵和难点都没讲

本来就知道的不需要看 不知道应该是一头雾水

LZ可以54在下，只是个人感觉而已



欢迎光临 Project1 (https://rpg.blue/) Powered by Discuz! X3.1