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

苏小脉

The great ruby shootout：
http://programmingzen.com/2010/0 ... shootout-july-2010/

这是一个由来自 IBM 的软件工程师 Antonio Cangiano 执行的 benchmark，其结果展示了不同 Ruby 的实现在 Linux 和 Windows 上的不同性能。

官方版的 Ruby 实现（CRuby）开发环境是 Linux，优化时针对 Linux 的多，针对 Windows NT 的少，再加上编译器优化性能的差异（GCC <=> MSVC），使得 Linux 下的 CRuby 性能整体高于 Windows。

在 Linux 下，平均最快的实现似乎是 基于 YARV 虚拟机的 Ruby 1.9.2（即 CRuby 的最新稳定 Release），基于 Sun JVM 的 JRuby 紧随其后；Windows 下，JRuby 的性能胜过了 Ruby 1.9.2。

MagLev 和 Rubinius 是这前两名巨头最大的竞争对手，现在仍在快速发展。特别值得一提的是 Rubinius，其最新的 1.1 版本在 JIT 优化和 GIL 性能上又有了提升，相信她在下一次 shootout 会有杰出的表现。

东风吹，战鼓擂，当今世界谁怕谁。革命仍未成功，阶级斗争还在继续。

zh99998

逻辑表达式

Ruby把nil和false认为逻辑假，其余任何对象认为逻辑真

if 0
  print "0 is true"
else
  print "0 is false"
end

这在其他语言里一般会得到 0 is false，但是在Ruby里是 0 is true

可以利用这个特性来做一些有趣的简写

while line = gets
  print line
end

会把标准输入一行行打印出来，直到文件尾


由于if不一定必须为true和false，而是可以使用任何对象，所以逻辑运算符也不会强制返回逻辑值，而是返回第一个决定逻辑值的对象

例
true and nil #=>nil
1 and "a" #=>"a"
false and true #=> false
false or nil #=> nil
&& 和 || 也有这一特性

比较常用的有个||=运算符，可以用来代替 a = x if a这样的语句
例
hash = {a: "b"}
hash[:a] ||= "c"
在想修改hash或数组的值，但是不确定那个键是否存在，并不想因此额外增加长度时使用

DeathKing

一些小问题

1. def f(n)
   
2.   if n == 1
   
3.     return 1
   
4.   else
   
5.     return n * f(n - 1)
   
6.   end
   
7. end
   
8. 
   
9. f(1_000_000)

复制代码

看上去是计算1,000,000的阶乘，实际呢？这种递归运算当到达一定的堆栈深度时会被停止，引发stack level too deep异常而中止。

1. SystemStackError: stack level too deep
   
2.         from (irb):21:in `f'
   
3. ... 7656 levels...
   

复制代码

进行了7656层，在1.8.6中，我的机器只能进行1479层。所以要合理使用递归，关注堆栈深度。

---

只做抛砖引玉，请讨论更深入的问题

DeathKing

ri，一个很好的帮手，不过需要安装了Ruby，因为他是有Dave Thomas（《Programming Ruby》的作者之一）设计的工具。

1. Usage: ri.bat [options] [names...]

复制代码

查询一下Net::POP3如何使用，有点像是man？真是意外的详细

1. C:\Documents and Settings\DeathKing>ri Net::POP3
   
2. -------------------------------------------- Class: Net::POP3 < Protocol
   
3. 
   
4. NET::POP3
   
5. =========
   
6. 
   
7. 
   
8. What is This Library?
   
9. ---------------------
   
10. 
    
11.      This library provides functionality for retrieving email via POP3,
    
12.      the Post Office Protocol version 3. For details of POP3, see
    
13.      [RFC1939] (http://www.ietf.org/rfc/rfc1939.txt).
    
14. 
    
15. 
    
16. Examples
    
17. --------
    
18. 
    
19.      Retrieving Messages
    
20. 
    
21.      This example retrieves messages from the server and deletes them on
    
22.      the server.
    
23. 
    
24.      Messages are written to files named 'inbox/1', 'inbox/2', ....
    
25.      Replace 'pop.example.com' with your POP3 server address, and
    
26.      'YourAccount' and 'YourPassword' with the appropriate account
    
27.      details.
    
28. 
    
29.          require 'net/pop'
    
30. 
    
31.          pop = Net::POP3.new('pop.example.com')
    
32.          pop.start('YourAccount', 'YourPassword')             # (1)
    
33.          if pop.mails.empty?
    
34.            puts 'No mail.'
    
35.          else
    
36.            i = 0
    
37.            pop.each_mail do |m|   # or "pop.mails.each ..."   # (2)
    
38.              File.open("inbox/#{i}", 'w') do |f|
    
39.                f.write m.pop
    
40.              end
    
41.              m.delete
    
42.              i += 1
    
43.            end
    
44.            puts "#{pop.mails.size} mails popped."
    
45.          end
    
46.          pop.finish                                           # (3)
    
47. 
    
48.      1.  Call Net::POP3#start and start POP session.
    
49. 
    
50.      2.  Access messages by using POP3#each_mail and/or POP3#mails.
    
51. 
    
52.      3.  Close POP session by calling POP3#finish or use the block form
    
53.          of #start.
    
54. 
    
55.      Shortened Code
    
56. 
    
57.      The example above is very verbose. You can shorten the code by
    
58.      using some utility methods. First, the block form of
    
59.      Net::POP3.start can be used instead of POP3.new, POP3#start and
    
60.      POP3#finish.
    
61. 
    
62.          require 'net/pop'
    
63. 
    
64.          Net::POP3.start('pop.example.com', 110,
    
65.                          'YourAccount', 'YourPassword') do |pop|
    
66.            if pop.mails.empty?
    
67.              puts 'No mail.'
    
68.            else
    
69.              i = 0
    
70.              pop.each_mail do |m|   # or "pop.mails.each ..."
    
71.                File.open("inbox/#{i}", 'w') do |f|
    
72.                  f.write m.pop
    
73.                end
    
74.                m.delete
    
75.                i += 1
    
76.              end
    
77.              puts "#{pop.mails.size} mails popped."
    
78.            end
    
79.          end
    
80. 
    
81.      POP3#delete_all is an alternative for #each_mail and #delete.
    
82. 
    
83.          require 'net/pop'
    
84. 
    
85.          Net::POP3.start('pop.example.com', 110,
    
86.                          'YourAccount', 'YourPassword') do |pop|
    
87.            if pop.mails.empty?
    
88.              puts 'No mail.'
    
89.            else
    
90.              i = 1
    
91.              pop.delete_all do |m|
    
92.                File.open("inbox/#{i}", 'w') do |f|
    
93.                  f.write m.pop
    
94.                end
    
95.                i += 1
    
96.              end
    
97.            end
    
98.          end
    
99. 
    
100.      And here is an even shorter example.
     
101. 
     
102.          require 'net/pop'
     
103. 
     
104.          i = 0
     
105.          Net::POP3.delete_all('pop.example.com', 110,
     
106.                               'YourAccount', 'YourPassword') do |m|
     
107.            File.open("inbox/#{i}", 'w') do |f|
     
108.              f.write m.pop
     
109.            end
     
110.            i += 1
     
111.          end
     
112. 
     
113.      Memory Space Issues
     
114. 
     
115.      All the examples above get each message as one big string. This
     
116.      example avoids this.
     
117. 
     
118.          require 'net/pop'
     
119. 
     
120.          i = 1
     
121.          Net::POP3.delete_all('pop.example.com', 110,
     
122.                               'YourAccount', 'YourPassword') do |m|
     
123.            File.open("inbox/#{i}", 'w') do |f|
     
124.              m.pop do |chunk|    # get a message little by little.
     
125.                f.write chunk
     
126.              end
     
127.              i += 1
     
128.            end
     
129.          end
     
130. 
     
131.      Using APOP
     
132. 
     
133.      The net/pop library supports APOP authentication. To use APOP, use
     
134.      the Net::APOP class instead of the Net::POP3 class. You can use the
     
135.      utility method, Net::POP3.APOP(). For example:
     
136. 
     
137.          require 'net/pop'
     
138. 
     
139.          # Use APOP authentication if $isapop == true
     
140.          pop = Net::POP3.APOP($is_apop).new('apop.example.com', 110)
     
141.          pop.start(YourAccount', 'YourPassword') do |pop|
     
142.            # Rest of the code is the same.
     
143.          end
     
144. 
     
145.      Fetch Only Selected Mail Using 'UIDL' POP Command
     
146. 
     
147.      If your POP server provides UIDL functionality, you can grab only
     
148.      selected mails from the POP server. e.g.
     
149. 
     
150.          def need_pop?( id )
     
151.            # determine if we need pop this mail...
     
152.          end
     
153. 
     
154.          Net::POP3.start('pop.example.com', 110,
     
155.                          'Your account', 'Your password') do |pop|
     
156.            pop.mails.select { |m| need_pop?(m.unique_id) }.each do |m|
     
157.              do_something(m.pop)
     
158.            end
     
159.          end
     
160. 
     
161.      The POPMail#unique_id() method returns the unique-id of the message
     
162.      as a String. Normally the unique-id is a hash of the message.
     
163. 
     
164. ------------------------------------------------------------------------
     
165. 
     
166. 
     
167. Constants:
     
168. ----------
     
169. 
     
170.      Revision = %q$Revision: 19776 $.split[1]
     
171. 
     
172. 
     
173. Attributes:
     
174. -----------
     
175. 
     
176.      address (R):
     
177.           The address to connect to.
     
178. 
     
179.      open_timeout (RW):
     
180.           Seconds to wait until a connection is opened. If the POP3
     
181.           object cannot open a connection within this time, it raises a
     
182.           TimeoutError exception.
     
183. 
     
184.      read_timeout (R):
     
185.           Seconds to wait until reading one block (by one read(1) call).
     
186.           If the POP3 object cannot complete a read() within this time,
     
187.           it raises a TimeoutError exception.
     
188. 
     
189. 
     
190. 
     
191. Class methods:
     
192. --------------
     
193. 
     
194.      APOP, auth_only, certs, create_ssl_params, default_pop3_port,
     
195.      default_pop3s_port, default_port, delete_all, disable_ssl,
     
196.      enable_ssl, foreach, new, ssl_params, start, use_ssl?, verify
     
197. 
     
198. 
     
199. Instance methods:
     
200. -----------------
     
201. 
     
202.      active?, apop?, auth_only, command, delete_all, disable_ssl,
     
203.      do_finish, do_start, each, each_mail, enable_ssl, finish, inspect,
     
204.      logging, mails, n_bytes, n_mails, on_connect, port, read_timeout=,
     
205.      reset, set_debug_output, start, started?, use_ssl?
     

复制代码

yangff

你要相信，Ruby可以像很多脚本语言一样抽插在各种软件当中……实现起来非常简单，只要编译一下……

DeathKing

像打开普通文件那样打开网页，open-uri是个好工具：

1. require 'open-uri.rb'
   
2. open("http://rpg.blue") do |f|
   
3.   f.each_line do |line|
   
4.     p line
   
5.   end
   
6. end

复制代码

为了获得更好的效果，最好先将KCODE设置为UTF-8

1. $KCODE = 'u'

复制代码

---

一些参考：
1，http://www.kuqin.com/rubycndocument/man/addlib/open-uri.html
2，http://fireflyman.javaeye.com/blog/671898

zh99998

与c等语言不同，ruby的整数大小没有限制，超过特定值后会自动变成Bignum

IamI

今天没人？
Table数据的取值范围是-32767--32768。