Ruby函数式风格编程

虽然打算把自己的一个开源项目移植到erlang，但手头的一个工作项目却是在用ruby on rails，花了一段时间了解ruby后，发现ruby还是有点意思的。（反倒是不太喜欢Rails。我喜欢直来直去的编程，rails里面太多的magic，实在让我这个喜欢刨根究底的人难受）。

回到主题，Ruby之所以比Python、groovy和Javascript更适合函数风格的编程，尤其是erlang风格，主要因为以下几点：

• everything is message（也即任何语句都会返回值）
• may return multiple values（可以返回多值）
• parallel assignment（并行赋值）

让我们看几个例子：

例一、
命令式风格：

ruby 代码

 

1. cond = {}  
2. if par[:id]  
3.   feed = Feed.find(par[:id])  
4.   if feed  
5.     cond[:feed] = feed.id  
6.   end  
7. end  
8. if par[:m]
   
9.   limit = par[:m].to_i  
10. else  
11.   limit = 20  
12. end  
13. if limit >= 4096  
14.   limit = 4096  
15. end  
16. cond[:limit] = limit  
17. if par[:d]  
18.   days = par[:d].to_f  
19.   if days <= 0 || days >= 365  
20.     days = 365  
21.   end  
22.   cond[:time] = Time.now - days*86400  
23. end  

函数时风格：

ruby 代码

 

1. cond = {  
2.   :feed   => if par[:id]  
3.                feed = Feed.find(par[:id])  
4.                feed ? feed.id : nil  
5.              end,  
6.   :limit  => begin  
7.                 limit = par[:m] ? par[:m].to_i : 20  
8.                 limit >= 4096 ? 4096 : limit  
9.              end,  
10.   :time   => if par[:d]  
11.                days = par[:d].to_f  
12.                days = days <= 0 || days >= 365 ? 365 : days  
13.                Time.now - days * 86400  
14.              end,  
15. }.delete_if { |k, v| v.nil? } # delete all nil elements of cond  

注意15行删nil项，因为在一个if .. end子句中，总会返回一个值，在不满足所有条件的情况下，就是返回nil

例二
命令式风格:

ruby 代码

 

1. if f[:mode] == "rss"  
2.   rss = f[:feed]  
3.   params[:feed][:channel] = rss.channel.title  
4.   params[:feed][:description] = rss.channel.description  
5.   params[:feed][:link] = rss.channel.link  
6.   params[:feed][:copyright] = rss.channel.copyright  
7. else  
8.   atom = f[:feed]  
9.   params[:feed][:channel] = atom.title  
10.   params[:feed][:description] = atom.subtitle  
11.   params[:feed][:link] = atom.links.join  
12.   params[:feed][:copyright] = atom.rights  
13. end  

函数式风格:

ruby 代码

 

1. params[:feed][:channel],  
2. params[:feed][:description],  
3. params[:feed][:link],  
4. params[:feed][:copyright] = if f[:mode] == "rss"  
5.                               rss = f[:feed]  
6.                               a, b, c, d = rss.channel.title,  
7.                                            rss.channel.description,  
8.                                            rss.channel.link,  
9.                                            rss.channel.copyright  
10.                             else  
11.                               atom = f[:feed]  
12.                               a, b, c, d = atom.title,  
13.                                            atom.subtitle,  
14.                                            atom.links.join,  
15.                                            atom.rights  
16.                             end  

或者：

ruby 代码

 

1. params[:feed][:channel],    
2. params[:feed][:description],    
3. params[:feed][:link],    
4. params[:feed][:copyright] = if f[:mode] == "rss"    
5.                               rss = f[:feed]   
6.   
7.                               [rss.channel.title,    
8.                                rss.channel.description,    
9.                                rss.channel.link,    
10.                                rss.channel.copyright]  
11.                             else    
12.                               atom = f[:feed]  
13.     
14.                               [atom.title,    
15.                                atom.subtitle,    
16.                                atom.links.join,    
17.                                atom.rights]    
18.                             end    

函数式风格的好处是，如果这一段代码只是为了给某几个变量赋值，那么函数式的写法一目了然，副作用也变得尽在掌控中。而命令式风格则没那个好处了。


说明：
1、并行赋值的重要性主要在于让处理分支中的多变量赋值时方便，否则例二中的情况就很难用函数式风格处理了
2、例二中的a,b,c,d当然可以直接用[]括起来处理(如上)，但我用abcd也是为了让代码一目了然，个人感觉而已。