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

苏小脉

字符串扣留

　先从一个 Ruby 实例看起：

p "hello".object_id, "hello".object_id

　　object_id 可以获取一个对象的唯一标识，而这行代码打印出了不同的 ID，说明两次引用的字符串字面值生成了两个不同的字符串对象，但它们的内容是一致的。这在面向对象语言中是一个普遍的现象，在某些场合下可能会引起以下问题：

   1. 当频繁使用 Ruby 的字面值指定某个字符串时，每次通过 Ruby 的字面值指定的字符串都会生成一个新的对象，长此以往就会产生大量的内容相同的字符串对象。这种空间的浪费意味着不必要的数据占用了更多的 Cache 和内存，减少了其它资源利用 Cache 的机会，也同时增加了内存分配和回收的复杂度；
   2. 我们经常需要比较字符串是否相等（如散列表的键值比较），而无论是什么语言，底层的实现方法也无非是调用 memcmp、strcmp 之类的函数来比较内存，理论上这个过程需要 O(n) 的时间（n = 字符串长度），而如果这样的比较需要频繁进行，那代价也是不容忽视的。

　　当今不少高级语言中，都内置一种被称为“扣留”（Intern）的机制，它解决了这一难题。它的思想是：使用一个全局的字符串常量池来管理字符串，每次准备分配新的字符串对象之前，程序都会先检查内容相同的字符串对象是否已经被“扣留”在了常量池中，若是，则不分配新的对象，直接引用常量池中的对象；若不是则分配新的对象，并“扣留”在常量池中。这当然增加了字符串对象构造时的时间，但却解决了上述两种情况下的空间（没有产生字符串的克隆）和时间（逐字节比较字符串变为了指针相等的判断）效率问题。

　　这个机制最早由 Lisp 用来管理符号，后来也被 Python（intern(string)）、Java（String#intern）、.NET（String.intern） 等语言继承，用来实现字符串的扣留。Ruby 通过符号表实现了符号对象的扣留机制，但内置的字符串对象并没有扣留。Ruby 的 String#intern 方法看似扣留，实则是把一个已有的字符串对象转换为符号对象。使用这个方法并不会节省内存，只能起到简化字符串比较的时间复杂度的作用。所以，在 Ruby 中，操作常量的字符串并处于上述两种情况时应该尽量使用符号而不是字符串。Ruby 1.9 的新 Hash 字面值支持一种更简洁的符号键语法糖，其设计目的就是为了推荐用户使用符号而不是字符串。

http://szsu.wordpress.com/2010/09/21/string_intern/

DeathKing

( Dave Thomas && Matz ) @ Ruby Conf 2010








DeathKing于2010-12-11 17:30补充以下内容：
给新手的String类参考手册：http://rpg.blue/thread-162871-1-1.html

苏小脉

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