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

紫苏

2010-09-04 不常见的字面值及 Shell 命令表示法
Ruby 支持的字面值和 Shell 命令表示法很多样化，我们最常用的是：
1、双引号字符串，如 "hello\nworld"，支持转义字符和内嵌表达式
2、单引号字符串，如 'hello world'，原始字符串数据，不支持转义字符和内嵌表达式（在不需要这两者的时候尽量用单引号提高效率）
3、正斜杠正则表达式，如 /regex/i
4、反引号 Shell 命令，如 `pause`
除此之外，Ruby 还支持所有 Unix Shell 以及大部分脚本语言都支持的 Here document，能够方便地进行多行的字符串输入：

1. 
   
2. str = <<DELIMETER
   
3. 桑之未落
   
4. 其叶沃若
   
5. 桑之落矣
   
6. 其黄而陨
   
7. DELIMETER
   
8. p str
   

复制代码

如果你用过字幕脚本，你就会觉得这段脚本很熟悉，因为字幕脚本用的也是 here document。DELIMITER 是自定义的分隔符，在两个分隔符（这里是两个 DELIMITER）之间的内容会被认为是字符串输入。不过这样写的 here document 不能进行缩进，强行缩进的话，最后的 DELIMETER 处会发生语法错误。在 << 后加上短横线 - 就可以解决：

1. if true
   
2.   str = <<-DELIMETER
   
3.   桑之未落
   
4.   其叶沃若
   
5.   桑之落矣
   
6.   其黄而陨
   
7.   DELIMETER
   
8.   p str
   
9. end

复制代码

Ruby 还有所谓的常规定界输入（General delimited input），使得字符串、正则表达式、字元数组和 Shell 命令有了额外的表示法：
%q{这相当于一个单引号字符串}
%Q{这相当于一个双引号字符串}
%{这相当于一个单引号字符串}
%w{这 是 一 个 字 元 数 组 ， 字 元 以 空 白 符 分 隔}
%r{[0-9]+} # 正则表达式
%x{mspaint} # Shell 命令
其中 `{' 和 `}' 是用来表示该输入的开始和结束的，也可以用其它分隔符表示，如
%#这是一个双引号字符串# # 这前面可不是注释哦，虽然 RGSS 的编辑器将它当做注释高亮显示了，或者两两对应的字符， `(' 和 `)'，`[' 和 `]'，以及 `<' 和 `>'
常规定界输入也支持多行输入，%q 和 % 使用起来比 here document 还方便！

紫苏

2010-09-03 冗余代码

所谓冗余，是指没有意义、永远不会被执行的代码，或多次运算且结果相同的不必要代码。前两者很容易理解，这里我们主要说一下“多次运算的结果相同的不必要代码”。这种冗余不但可能导致代码可读性的降低（多次重复编写一大段代码），还可能降低代码运行的效率（代码容量的增加导致的程序装载效率以及多次进行结果必然相同的表达式运算）。在软件工程的哲学中有一个广为人知的原则，叫做 DRY 原则，全称是 Do not Repeat Yourself，是避免冗余的基本原则，意思是不要让相同的代码出现大于一次。例如：

1. 
   
2. a = 0
   
3. b = 32
   
4. for i in 0..100
   
5.   a += i
   
6. end
   
7. for i in 5..323
   
8.   b += i
   
9. end
   
10. p a + b
    

复制代码

我们这里有两个整数 a 和 b，分别初始为 0 和 32，我们想让它们的值递增上一系列连续的整数，于是写了两个框架基本上一样的循环。其中第二个循环就是冗余代码，我们完全可以编写一个函数（子例程）来完成这一个运算：

1. def fn(a, b)
   
2.   ret = 0
   
3.   for i in a ..b
   
4.     ret += i
   
5.   end
   
6.   return ret
   
7. end
   
8. 
   
9. a = 0
   
10. b = 32
    
11. a += fn(0, 100)
    
12. b += fn(5, 323)
    
13. p a + b

复制代码

这是提高了代码可读性的冗余消除。另一种情况：

1. def fn(a, b)
   
2.   $global = a*b
   
3.   return a*b
   
4. end

复制代码

这里，return 语句则是一句冗余代码，因为它在第一次计算 a*b 且结果保存在了 $global 后第二次计算了 a*b，而这是不必要的，因为 $global 这个变量是永远可见的，可以直接引用它并返回：

1. 
   
2. def fn(a, b)
   
3.   $global = a*b
   
4.   return $global
   
5. end
   

复制代码

然而这还属于无伤大雅的冗余，毕竟如今的 CPU 条件下，可以在极其高效的对数时间内完成乘法运算；糟糕的是出现需要花费时间执行的代码出现了冗余：

1. arr = [1, 3, 52, -2, 0, -234, 33, 6, 76, 44, 3, -2, 5]
   
2. res = 0
   
3. res += 6 if arr.include?(6)
   
4. res += arr.sort[2]
   
5. if arr.include?(6)
   
6.   res += arr.sort[3] << 3
   
7.   p "#{res}foo"
   
8. end
   
9. p "#{res}bar"

复制代码

这里，arr.include? 和 arr.sort 都出现了两次，而由于期间 arr 没有改变，故这两者的第二次出现都是冗余代码；恰好这两者都是耗时间的操作——include? 需要线性时间内完成，而 sort 需要线性对数时间内完成。我们将冗余消除后，理论上运行效率会提升将近一倍：

1. 
   
2. arr = [1, 3, 52, -2, 0, -234, 33, 6, 76, 44, 3, -2, 5]
   
3. res = 0
   
4. has6 = arr.include?(6)
   
5. sorted_arr = arr.sort
   
6. res += 6 if has6
   
7. res += sorted_arr[2]
   
8. if has6
   
9.   res += sorted_arr[3] << 3
   
10.   p "#{res}foo"
    
11. end
    
12. p "#{res}bar"
    

复制代码

然而你也不能只留意在源脚本中实际出现了多次的代码冗余，有时在某些特殊控制结构里，比如循环，即时表达式在字面上仅出现了一次，实则也可能是一种冗余：

1. arr = [1, 3, 52, -2, 0, -234, 33, 6, 76, 44, 3, -2, 5]
   
2. for i in 0..100
   
3.   sorted_arr = arr.sort
   
4.   p sorted_arr[rand(sorted_arr.length)]
   
5. end

复制代码

这里，arr.sort 会被循环执行，但实际上进行排序的数组没有改变，每次排序的结果都是相同的，所以我们可以把这一行拿到循环外面去，避免了冗余：

1. sorted_arr = arr.sort
   
2. for i in 0..100
   
3.   p sorted_arr[rand(sorted_arr.length)]
   
4. end

复制代码

假设数组长度是 n，那理论上这里的冗余避免后效率是避免前的将近 100 倍。
DRY 原则也不是绝对要遵守的，要看情况而定——有时出现的冗余，比如多次通过 [] 数组下标访问数组元素，影响并不大，因为它们并不耗费多少时间，为了它们去分配一个临时变量来保存可能并不值得。在编译性语言以及有即时编译机制的解释性语言中，聪明的编译器和解释器会自动进行各种优化，如公共子表达式消除、死代码消除、常数合并，能杜绝大部分冗余，但 RM 所使用的 Ruby 1.8 MRI 解释器直接解释源代码，没有任何优化，所以是需要用户来考虑效率的

紫苏

2010-09-02 Proc.new 和 lambda
Proc 是 procedure 的简称，意味着一个过程，或者例程。我们基本上可以把 Ruby 的 Proc 对象看作是 Ruby 的匿名函数，但在 Ruby 1.8 中，通过不同方法获取的 Proc 对象有微妙的区别：

1. def foo
   
2.   local = 'This is a local variable'
   
3.   $proc = Proc.new { return }
   
4.   $proc.call # OK
   
5.   p '这里永远不会执行'
   
6. end
   
7. 
   
8. foo
   
9. $proc.call # error

复制代码

在 foo 方法内部，$proc 执行后，直接结束了函数的运行，而在方法外部调用 $proc 则会产生非局部跳转的异常，这里的意思是告诉你不能在顶层 return。从这个现象可以得出结论：Proc.new 会绑定创建时的上下文，而在这个 Proc 对象内 return 则是与该上下文绑定的。比如，上面的代码中，$proc 创建时的上下文是 foo 方法的局部上下文，在方法内部调用 $proc 时 foo 的局部上下文还存在（方法还没有返回），所以没有问题；在方法外部调用 $proc 时 foo 的局部上下文已不复存在（方法已经返回），所以发生了异常
我们再来看看闭包的定义：

在计算机科学中，闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。

然而 Proc.new 产生的 Proc 对象并没有真正的自由，它与创建时的上下文绑定在了一起，并不是一个独立的匿名函数个体（因为不能自由地 return，且成功 return 后会让外部的函数返回），所以它并不算是真正意义上的闭包
可喜的是，刁钻古怪的 Ruby 还是用一种隐晦的方式提供给了我们真实的闭包。把上面的代码中的 Proc.new 替换为 lambda 后，就能发现没有错误了。lambda 是 Kernel 里的方法，这个名称来源是 λ-calculus 中的 λ 符号，意味着一种匿名函数演算法，由 Scheme 语言最早支持，后来被各种语言继承。lambda 产生的 Proc 对象，其内部 return 是从当前的 Proc 对象，即当前的闭包返回，所以 lambda 产生的 Proc 对象才是 Ruby 真正的闭包
这里还有最后一个问题，就是 Ruby 1.8 对 proc 和 lambda 的定义产生了混淆。proc 也是 Kernel 里的一个方法，其文档中表示 Kernel#proc 等价于 Proc.new，但当我们实际把上面代码中的 Proc.new 替换为 proc 时，会发现没有异常。实际上在 Ruby 1.8 中，Kernel#proc 是等价于 Kernel#lambda 的，也就是说 Kernel#proc 也是真实的闭包。然而从命名上来看，proc 和 Proc.new 不同而合 lambda 相同，是一个很明显的设计失误，所以在 1.9 中，Ruby 巧妙地让 Proc.new 等价于了 Kernel#proc

小幽的马甲

2010-9-1

垃圾回收(Garbage Collection)

GC是个很有意思的东西。不管是用C的malloc和free还是Pascal的new和dispose管理内存都需要有一个释放的过程，有的时候会很麻烦，GC就是把这个过程智能化了，可以把不用的对象（垃圾）自动释放掉。
RM里的GC模块只有三个方法：GC.enable（打开GC）、GC.disable（关闭GC）、GC.start（初始化GC），很好理解。
为了测试GC的效果，我们可以在事件里调用

1. a = Window_Help.new
   
2. a = 1

复制代码

执行后可以看到，地图上仍会留一个窗口，但是约一分钟后就会自动消失。
如果后面加句GC.start则会立刻消失。
当然，平时写脚本是绝对不要依赖GC，该释放的对象还是要释放。
默认脚本中只有在Cache.clear里用到了GC，因为那时候缓存的哈希表被清空，但对象并没有被释放，所以需要调用GC。

DeathKing

三元表达式、三元运算符（Ternary Operator）

　　平常接触的if控制结构都是这样的：

1. if condition
   
2.   exp1
   
3. else
   
4.   exp2
   
5. end

复制代码

不过当exp只有一句的时候，这样看起来会十分的占地方，所以就有了下面这种简写为一排的方式：

1. if condition then exp1 else exp2 end

复制代码

不过这样看起来也有很大一堆，还有没有更简单、优雅的写法呢？当然是有的，Ruby继承了C的三元运算符（Ternary Operator），上面的表达式会被替换成这样：

1. condition ? exp1 : exp2

复制代码

实质上，首先会计算condition的值，为真的话就执行exp1，否则就就只exp2。不过要注意的是，三元运算符的优先级比=（赋值运算符）高，所以下面的做法是完全可行的：

1. foo = true ? 1 : 0
   
2. p foo #=> 1

复制代码

如果说你是Visual Basic程序员，你会发现，三元运算符就和IIf函数类似。

zh99998

重名陷阱

由于Ruby在语法上很人性化很自由，这也就带来了一些问题

例如
1.在方法调用中省略括号所引起的误会  注：标引用的部分引自Ruby手册

因为表示Range对象(或范围表达式)的.., ...的结合度较低(请参考操作符表达式)，所以会引发下列错误
1..3.to_a
=> -:1: bad value for range (ArgumentError)
上面的代码会被解释成下面这个样子。
1..(3.to_a)

下面的代码不会得到预期的结果
p (1..3).to_a
因为它被解释成下面的代码。
(p (1..3)).to_a

p (true && true)    #=> true
p (true and true)   #=> parse error
p ((true and true)) #=> true
因为true and false被看作是语句，所以必须使用括号将其变为表达式的等价形式。同时，将它传给p的参数时还需要再加上一层括号才行。

p {1=>2}    #=> parse error (大括号被当作块)
p ({1=>2})  #=> {1=>2}
p (1=>2)    #=> {1=>2} (参数被当作哈希表)
p (1=>2, 3) #=> parse error    (只能把省略大括号的哈希表放在参数列表的最后)
p (0,1=>2)  #=> 0
                1=>2

2.运算符和方法的重名

a=1;
b = a+2;   # a 和 2 的和
b = a +2;  # 被解释成 a(+2)
b = a + 2; # a 和 2 的和

a = b = c = true
a?b:c       # 被解释成 a?(b(:c))
a ? b : c   # 条件操作符

3.变量和方法的重名
以小写字母开头的方法，可能与变量重名

1. def a
   
2.   1
   
3. end
   
4. p a #=>1
   
5. a = 2
   
6. p a #=> 2
   
7. p a() #=> 1

复制代码

如果没有a这个变量，那么只p a就可以输出1
但是大写字母则不同，无论有没有同名常量，都必须加()

1. def A
   
2.   1
   
3. end
   
4. p A #=>出错
   
5. A = 2
   
6. p A #=>2
   
7. p A() #=>1

复制代码

带等号方法

1. def a=(val)
   
2.   @a = val
   
3. end
   
4. a = 1
   
5. p @a #=> nil
   
6. self.a = 1
   
7. p @a #=> 1

复制代码

IamI

Class、Module两个类是抽象的抽象。在Class中定义的实例方法是Class类的对象的方法，也就是普通的类的类方法。比如说：

1. class Class
   
2.   def hi
   
3.     p "HI!"
   
4.   end
   
5. end
   
6. 
   
7. class A
   
8.   hi
   
9. end
   
10. A.new.hi

复制代码

不言自明。

Class和Moudle的类方法只能被显式的调用，诸如Class.new。

另外，事实上，假设A是一个类，当你调用A.new方法的时候，操作如下所示：
A.new调用A.allocate => 生成实例
调用实例的initialize方法 => 根据伪多态完成初始化操作。

Object是一切的起源。它是超脱一切的存在（囧）。Object的include-in Kernel（你没看错，它是一个Mix-in）可以在任何位置被调用。也许你会问。既然Kernel是一个嵌入模块，那么为什么在没有类没有实例的方法也可以调用？因为直接p self可以（VX）看到顶级被调——Main :Object。是的，你逃不出Object的掌控。

如果你要给所有类定义一个方法，想在Class类eval？错了，instance_eval。具体请参考一开始的那段话。

OK，给下面两楼两个话题。Binding、$SAFE

DeathKing

2010-08-28

昨天进行过一次讨论：http://rpg.blue/thread-154899-1-1.html
既然抢到了今天的帖子，那么就借花献佛。

Ruby中的方法名有一定的俗成的约定，下面列出了这些约定，不过，这不是强制性必须遵守的！

以 = 号结尾的方法通常是setter，会为同名实变量设定值；
以 ? 号结尾的方法返回的是一个所谓的布林值，也就是true或者false；
以 ! 号结尾的方法表示该方法具有破坏性，所以要小心操作。

一些例子：

• 由元编程方法 attr_writer :method 或 attr_accessor :method 建立的 method= 方法就会为 @method 实变量赋值；
• 由 Object 类提供的 is_a? 方法返回 true 或者false ，来判断对象是否是一个类的实例，如： 1.is_a? Fixnum #=> true ；
• 由String 类提供的gsub! 方法比较常见（Window_Message 大多用这个方法处理），它就具有破坏性，直接在源对象上操作；
  

关于破坏性与非破坏性的比较：

1. 
   
2. ary = [1,3,5,7,9,2,4,6,8,10]
   
3. 
   
4. ary.sort #=> [1,2,3,4,5,6,7,8,9,10]
   
5. p ary    #=> [1,3,5,7,9,2,4,6,8,10]
   
6. 
   
7. ary.sort! #=> [1,2,3,4,5,6,7,8,9,10]
   
8. p ary     #=> [1,2,3,4,5,6,7,8,9,10]
   

复制代码

zh99998

p不是关键字，但是可以执行p 1正常输出1而不出错，为什么？
Ruby里调用方法时，如果不会产生歧义，则可以省略括号，使代码变得整洁美观
比如要输出一个跟RM里的用语【等级】同名的文件，可以简写成这样

1. print IO.read Vocab.level

复制代码

这比完整写法

1. print(IO.read(Vocab.level()))

复制代码

好看的多
但是一定要注意使用时的原则是不引起歧义，例如

1. open File.expand_path "test.txt" , "w"

复制代码

就会出错，原因是参数"w"可能是expand_path的参数也可以是open的参数
所以必须加一层括号

1. open File.expand_path("test.txt") , "w"

复制代码

Ruby中类似的简写除了括号之外，还有其他的，例如Hash

1. p 1 => 2

复制代码

乍一看似乎是会Syntax，但是这一句是能执行的，输出{1 => 2}
这一特性在ruby的应用(窗口编程/网页)中使用得十分广泛

紫苏

有人会问：Ruby 没有析构方法？乍一看似乎这个真没有，其实这个可以有——

define_finalizer  ObjectSpace.define_finalizer( anObject, aProc=proc() )  

Adds aProc as a finalizer, to be called when anObject is about to be destroyed.  

ObjectSpace.define_finalizer 可以为某个对象添加一个类似 C++ 析构函数的最终化处理器，如果在 initialize （类似构造函数）中调用这个方法，就能为每个实例添加一个固定的析构方法
例：

1. 
   
2. class MySprite < Sprite
   
3.     def initialize(viewport = nil)
   
4.         super(viewport)
   
5.         ObjectSpace.define_finalizer(self, proc { self. dispose })
   
6.     end
   
7. end

复制代码

这样一来，当 MySprite 对象被回收时，精灵资源会自动释放