Ruby/RGSS Tips 每日一更 ［技术区的版聊帖？］

DeathKing

这个是一个偶然的想法，需要一定的试点。是这样的，这个帖子每天将会更新一些Ruby 或者 RGSS 的小技巧，这些技巧一般很简短，易于掌握。

细则如下：

• 每天只能有一个新回复，其他请使用“点评”功能，补充请使用“编辑”功能。否则版主有权删贴。
• 和水区版聊帖一样，先抢先得。
• 每个tips不宜超过200字。
• 每月根据情况施予不同的表彰。
• 精华内容将被搜集、整理。
• 不要重复。或者过于简略而含糊不清。
• 转载或引用请注明原文或引用链接（有些会员可能无法发送链接）。
  

注意！

• 本帖采用的是［倒序看帖］，新的帖子在最上方。
• 其他的问题将在以后补充。
  

chd114

http://rpg.blue/thread-234182-1-1.html不解释

灵魂の补给

帮顶一下
然后小技巧:
a = 0x00001
lambda{|m|a.to_s(m/2)}.call(16)
与下面意义相同
def to_s2(n)
return n.to_s(n/2)
end
to_s2(a)
一样的结果
不一样结构
前者proc后者方法
(偶纯属胡扯^pai!)

DeathKing

Ruby 1.9.3 第一个预览版已经发布了，这是一个参照级的版本，有可能包含Bug，但是这些Bug会在下一个版本Ruby 1.9.3-p0中修正。该版本自1.9.2以来的改进包括：

1. 许可证更改：

更改了Ruby 的许可证，从GPLv2双许可证更改为2-clause BSDL双许可证。

2. 升级了C API：

rb_scan_args() is enhanced with support for option hash argument extraction.
ruby_vm_at_exit() added.  This enables extension libs to hook a VM termination.

3. 更新了库：

包括ARGF、 Array、Bignum、Encoding、File、IO、Kernel、Module、Random、String、Time、 Process等。

4. 语言变化：

正则表达式现在支持 Unicode6.0（新的字符和脚本）
正则表达式现在支持Age属性（实验 阶段）
使用指令开启/关闭缩进警告。

发行日志：http://svn.ruby-lang.org/repos/ruby/tags/v1_9_3_preview1/NEWS
详细更新信息：http://svn.ruby-lang.org/repos/r ... _preview1/ChangeLog
下载地址：http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.3-preview1.zip

六脉神剑

Ruby 1.9.2-p290 发布了：

http://www.ruby-lang.org/en/news ... 2-p290-is-released/

这次的发布又是一堆 BUG 修复。

苏小脉

不要盲目地认为当前的 `self' 同时也决定了常量的上下文。Ruby 有三个隐式上下文：`self'、`klass' 以及 `cref'。本主题早先有两楼讲述了如何理解 `self' 和 `klass' [1]，用一句话总结就是：`self' 决定了调用未指定接收者的方法时的默认接收者以及如何解析当前作用域下的变量，而 `klass' 决定了当前定义的方法属于哪个类或模块。而最后一个 `cref'，则是决定了当前的常量作用域，也就是在引用常量时决定在哪个类或模块查找，定义常量时决定它最终归属于哪个类或模块。再换句话说，就是决定了当前的常量命名空间。

先来看一个例子：

1. 
   
2. X = Class.new {}
   

复制代码

这段代码中，Class.new 的块开启了一个新的作用域作为正在分配的 Class 对象的主体。很多人在这里就想当然地认为这个块相当于 class X ... end，在块中所写的代码会和 class X ... end 之间的代码有相同的效果，而这是错误的。在这个块中，只有 `self' 和 `klass' 这两个隐式上下文被设为了正在分配的这个 Class 对象本身，但 `cref' 没有变。

1. X = Class.new do
   
2.   p self
   
3.   def foo
   
4.     p :foo
   
5.   end
   
6. end
   
7. 
   
8. x = X.new
   
9. x.foo

复制代码

这段代码输出了 Class 对象本身和 `:foo'，就是因为 `self' 和 `klass' 都指向了这个 Class 对象本身。然而，当你这样做的时候：

1. X = Class.new { Y = 1 }
   
2. 
   
3. p X::Y

复制代码

解释器抛出一个警告：

1.rb:5: warning: toplevel constant Y referenced by X::Y

这个警告是提醒用户，Y 是顶层常量，不需要用 X 来修饰它 [2]，直接引用 Y 就可以了。

很明显，这是因为当前的常量上下文没有因为程序执行进入了 Class.new 的块而改变，所以在块内部定义常量的时候，`cref' 仍然是顶层。Object#instance_eval 和 Module#class_eval 影响的也只有 `self’ 和 `klass'，但不会改变 `cref'。那么什么才会使得 `cref' 改变？只有语法上的 class ... end 和 module ... end 定义。

1. class X
   
2.   Y = 1
   
3. end
   
4. 
   
5. p X::Y         # => 1

复制代码

那么如何不在不建立 class ... end、module ... end 结构的情况下显式指定常量归属？直接通过 `::' 运算符修饰在某些场合下好使，但这在像 X = Class.new { ... } 这样的场合下是不会成功的，因为在块执行的时候 X 还没有定义 [3]。同时，这种方法是对 `X' 这个符号做了硬性编码，但有时我们可能会需要让这个命名空间本身是不定的（变量），比如在 Class.new 的块中定义属于正在分配的这个 Class 对象的常量。这时，有一对很好用的方法就是你的朋友：Module#const_get 和 Module#const_set。

1. X = Class.new { const_set :Y, 1 }
   
2. 
   
3. p X::Y           # => 1
   
4. p X.const_get :Y # => 1

复制代码

由于 const_get 和 const_set 的接受者就是它们操作常量时所使用的命名空间，动态性就实现了。

[1] 76、77 楼讲述了 `self' 和 `klass'（default definee）。
[2] 用 X 修饰常量则表示常量定义在 X 这个命名空间中。
[3] Class.new { ... } 连块一起，整个返回后才会把返回值赋给 X，在此之前 X 都会保持未定义状态。

zh99998

Block 不是对象，是Ruby的语言特性，近似于闭包（Closure）。

范例：

def meth
  res=  yield
  "Block called returns #{res}"
end
puts  meth do next “next_value” end    #Block called returns next_value

puts  meth do break “break_value” end   # break_vcowcuo错误哦alue

def my

  meth do return “reutnr_value” end

end

puts my ()      # return_value

红色部分就是 Block.

block 之 next

block中的 next [value] 导致 block结束，并返回[value]给调用函数。

block 之 break

block中的 break [value] 导致 block结束，并导致调用block的函数也返回，返回值是[value]。

block 之 return

block中的 return [value] 导致 block结束，并导致定义block的函数返回，返回值是[value]。

ProcProc 是Ruby 对 block的面向对象的封装。

范例：

def meth (&proc)
  res=  proc.call
  "Proc called returns #{res}"
end
puts  meth do next “next_value” end    #Proc called returns next_value

puts eth do break “break_value” end   # 出错

def my

  meth do return “reutnr_value” end

end

puts my ()      # return_value

红色部分就是 Proc.

Proc 之 next

Proc中的 next [value] 导致 Proc结束，并返回[value]给调用函数。

block 之 break

Proc中不能使用break,这回导致异常。

block 之 return

Proc中的 return [value] 导致 Proc结束，并导致定义Proc的函数返回，返回值是[value]。

LambdaLambda 是Ruby 对 Proc进一步的封装。

范例：

def meth (&proc)
  res=  proc.call
  "Lambda called returns #{res}"
end

def my

  meth (&lambda do return “reutnr_value” end)

end

puts my ()      # Lambda called returns return_value

红色部分就是 Lambda.

Lambda 和 Proc的区别就在 Lambda中的 return 导致 lambda 函数结束，并返回调用lamdad的函数（Proc和Block都是从定义的它们的函数放回)

Block,Proc,Lambda的区别总结

• Block 中 用next从自身返回，用break从调用它的函数中返回， 用 returnc从定义它的函数中返回；
• Proc 是对Block的面向对象封装，不支持breaky用法 ；
• lambda是对Proc的封装, Lambda中return等同于next;
  

转载自http://www.cnblogs.com/napoleon_liu/archive/2009/11/25/1610638.html

苏小脉

很久没来关注这个主题，分享一些关于 Rubinius 的新闻。上月，EngineYard 的应用云端引入了 Rubinius。不少人还没看清楚这颗早晨八九点钟的太阳，Rubinius 又在上周的 RailsConf 2011 上以通过用户数以万计的测试套件证明了自己的稳定性和正确性——小伙彻底红了。

如果你使用 Ruby，但又对你所使用的 Ruby 实现不够满意，那么你绝对应该关注 Rubinius。Rubinius 的创造者 Evan Phoenix 曾指出，MRI 的架构在 1.8 的时候便已然定性，想要在性能上做出革命性的改变将会导致大部分实现代码的重写。想来也是，毕竟 Matz 当初在制造 MRI 原型的时候只不过是想要一个玩具。Rubinius 从设计的出发点开始就和 MRI 不同——它的目的就是为了带给用户高效的 Ruby 代码。它的设计和实现都是建立在近几年来对进程虚拟机的大量理论研究和实践的变革之上的。Rubinius 有自己的字节码编译器，基于 Smalltalk-80 蓝图的虚拟机，当代的分代垃圾回收器（generational GC），以及由性能分析（profiling）驱动的即时编译器（JIT）。相形之下，还在使用上个世纪的保守的标记-清除 GC，同时又缺少对 JIT 的支持的 YARV 顿显失色。更令人振奋的是，Rubinius 已经开始在它的 Hydra 分支上进行全局解释器锁的移除工作。据开发员们透露，在 GIL 被移除后，最多只需要部署几十把细锁。这意味着在 Rubinius 虚拟机上运行的 Ruby 线程，将获得空前的并发能力。

贫一句：世界是 YARV 的，也是 JRuby 的，但归根结底还是 Rubinius 的！ =)

关注 Rubinius：
http://rubini.us
http://twitter.com/#!/rubinius

DeathKing

元编程相关技术：
元编程：http://ruby-metaprogramming.rubylearning.com/
Metaclass详解：http://www.letrails.cn/archives/ruby-metaclass-tutorials/

紫苏

`Module#undef_method' 是一个值得注意的方法。它的作用是将一个方法从方法分派的任务中移除，使得调用该方法者收到一个 `NoMethodError' 异常（即 `obj.respond_to? :method => true'）。然而，`undef_method' 并非是把方法彻底从类结构中移除了，它仅仅是将以符号表示的方法名所标识的方法标记为“未定义”，使得解释器在通过方法分派、反射等机制寻找这个方法时会立即抛出异常。这就逻辑蕴含了另一个事实：哪怕基类或是 mixed-in 模块有同名的方法，在派生类的同名方法被 `undefine_method' 处理后，也不会尝试进行向上搜寻的方法分派。

`Module#undef_method' 还有一个家族成员——`Module#remove_method'。它彻底从当前模块（即 `remove_method' 的接收者。一个 `Module' 的实例）结构中移除一个方法的引用。如此一来，方法分派函数在派生类中找不到一个方法，就会尝试在基类中寻找。

1. class Base
   
2.   def bar
   
3.     p :'base bar'
   
4.   end
   
5. end
   
6. 
   
7. class Derivation < Base
   
8.   def bar
   
9.     p :'derivation bar'
   
10.   end
    
11. end
    
12. 
    
13. d = Derivation.new
    
14. 
    
15. class Derivation
    
16.   remove_method :bar
    
17. end
    
18. 
    
19. d.bar                   # => :"base bar"
    
20. 
    
21. class Derivation
    
22.   undef_method :bar
    
23. end
    
24. 
    
25. d.bar                   # => NoMethodError

复制代码

可见 `remove_method' 后仍然能找到基类的 bar 方法，但 `undef_method' 后却不能。

再演示另外一个和 eigenclass （Ruby 单例类）有关的例子：

1. 
   
2. obj = Object.new
   
3. 
   
4. def obj.foo
   
5.   p self
   
6. end
   
7. 
   
8. p obj.respond_to? :foo  # => true
   
9. 
   
10. class << obj
    
11.   undef_method :foo
    
12. end
    
13. 
    
14. p obj.respond_to? :foo  # => false
    
15. 
    
16. Marshal.dump(obj)       # => error

复制代码

可以发现，仅仅是 `undef_method' 并不会移除 eigenclass 中的 eigenmethod（单例方法），所以它不能被 `Marshal' 模块 dump。当我们把 `undef_method' 替换为 `remove_method' 后，就可以 dump 了。

在方法被标记为未定义或彻底移除之前通过反射获取的该方法的 `Method' 对象，在之后仍然能正常运作：

1. class Klass
   
2.   def foo
   
3.     p :'Klass#foo'
   
4.   end
   
5. end
   
6. 
   
7. obj = Klass.new
   
8. 
   
9. def obj.bar
   
10.   p :'obj.bar'
    
11. end
    
12. 
    
13. m_foo_unbound = Klass.instance_method :foo
    
14. m_foo = obj.method :foo
    
15. m_bar = obj.method :bar
    
16. 
    
17. class Klass
    
18.   remove_method :foo
    
19. end
    
20. 
    
21. class << obj
    
22.   remove_method :bar
    
23. end
    
24. 
    
25. p obj.respond_to? :foo        # => false
    
26. p obj.respond_to? :bar        # => false
    
27. 
    
28. m_foo_unbound.bind(obj).call  # => :"Klass#foo"
    
29. m_foo.call                    # => :"Klass#foo"
    
30. m_bar.call                    # => :"obj.bar"

复制代码

这同时也演示了方法的绑定和方法分派相互独立的特性。

最后，Ruby 还提供了一个语法糖 `undef' 以更简洁的语法（后面可以跟上一个纯粹的标识符，而无须符号或是其它字面值，类似与 `alias' 这个语法糖）调用了和 Module#undef_method 相同的实现。`undef' 是 Ruby 的关键字。

苏小脉

http://ideone.com/

这是一个在线试玩 Ruby 的 Web 接口，省去了编译一份本地 Ruby 拷贝的工作。它使用的 Ruby 解释器版本是 1.9.2。