Ruby惯用法

Ruby有不少惯用法，这里略作一些介绍，也方便阅读他人代码：

迭代
一般写法:

for i in (1..10)
puts i
end

习惯写法:

(1..10).each{|i| puts i}
或
1.upto(10){|i| puts i} # from njmzhang

||=赋值
一般写法：

number = 1 if number.nil?
number = 1 unless number

习惯写法：

number ||= 1

程序入口

if __FILE__ == $0
或
if $PROGRAM_NAME == __FILE__

这个相当于main(), 逻辑判断的意思当程序名($0或另一个）和当前文件名(__FILE__)一致时，也就是当前文件是被单独执行的而不是被别的文件调用。这个方法还有个用法是作为unit test使用。


预设变量和特殊记号
类似$0的Perl风格预设常量还有很多，参见Programming Ruby p319

其中比较常用的如$:代表库搜索路径，修改方法常见有：

$:.unshift('buildscript')  # from gigix
或
$: << File.join(File.dirname(__FILE__), 'CurrentClass') 

后一种方法使用了相对路径，因为Ruby的module不要求namespace和文件目录结构要对应一致，很多时候统统放一个目录里

%w格式化命令(from qiezi) 可以少打几个引号

％w{a b c d} ＃等价 ['a', 'b', 'c', 'd'] 

``（~键下的撇号）用来执行shell外部命令,如：

`help`

inject
一般写法：

result = []
(1..10).each{|item| result << item}

习惯写法：

(1..10).inject([]){|array, item| array << item}

inject有点难理解，相当于python的reduce和一些FP里的fold。inject的块变量有两个（这里是array和item)，第二个变量(item)用来枚举被inject的集合（这里是(1..10)这个range), 而第一个变量(array)由inject的参数初始化(这里是[]，可选)，并在block被反复执行时保持持久（相当于静态变量），而item则在每次枚举时被更新为下一个值。我们再看一下inject的另一种通常用法就会更明白了：求和

(1..10).inject{|sum, item| sum += item}
这个等于
(1..10).inject(0){|sum, item| sum += item}

也就是块变量sum被初始化成0然后反复迭代执行块的内容，最后返回sum


并行赋值
这个很多人都知道了，比如：

a,b = 0, 1
a,b = b, a ＃ 交换a,b

当然可以延伸出一些很诡异的变化，不提倡使用阿

还有一个用法是让函数返回“多个结果”（不是多个对象），如：

def test
  1,2
end
x, y = test ＃x = 1, y = 2	

这个njmzhang说的很对，其实函数返回的是一个array,然后再并行匹配到变量上去。（所以我对多个结果特别加了引号）
这显然是个syntax sugar，你随便用逗号分割几个变量是不会自动组成array的。

注意这种并行匹配当两遍不平衡时会造成的问题：

a,b = [1,2,3] # a = 1, b = 2, 3被丢弃
a,b,c = [1,2] # a = 1, b = 2, c = nil 被初始化成nil 

*的匹配
一般来说*用于把一个array展开：

a, *b = [1,2,3]  ＃a = 1, b = [2,3]

类似FP里的x:xs(haskell), x::xs(ocaml), [a | b] (erlang from 布娃娃）


rescue简单用法

begin
 1/0
rescue
  puts 'wrong'
end

可以简化为

1/0 rescue puts 'wrong'

命名参数的默认值
ruby有默认参数，但其实没有所谓keyword argument，而是提供一个syntax sugar用hash模拟。但是怎么像Rails的方法那样同时利用命名参数和默认参数值呢？

def image(opt={})
    default_opt = {:height => 25, :width => 10}
    default_opt.merge! opt ＃opt中同样key的内容会覆盖default_opt中key的value
end

精细duck typing控制
duck typing的精神就是行为决定类型，而不是相反

a = []
#不用
if a.kind_of? Array then a << 1
if a.instance_of? Array then a << 1
#而用
if a.respond_to? :<< then a << 1

获取metaclass
这也比较常见了，各种动态伎俩的开始

sing = class << self; self; end

符号转换到Proc
一般写法：

(1..10).map{|item| item.succ}

习惯写法：

(1..10).map(&:succ)

map(fun(x))般的FP风格

注意这是Rails特有的，通过ActiveSupport对Symbol插入to_proc方法。
不用Rails怎么办呢？一种办法是借助Ruby Facets库（gem install facets）：

require 'facet/symbol/to_proc‘

Facets库包括大量对Ruby核心类的扩展，是个有趣而又危险的大杂烩，也许我以后会另外再专门介绍一下。

  


  

    
    
分享到：
      
      
    
  

  

    

      可爱的刺猬
      |
      对Robbin《ruby on rails为什么暂时无法成 ...
    
  
  

    

      
2006-09-19 20:41
      
浏览 23608
      
评论(24)
       
论坛回复 / 浏览 (22 / 48320)
 
      
            
      
查看更多
    
    
  
    
  

    
评论
    
    

  

    24 楼
    xly_971223
    2007-05-13  
    
    
  
  
写法太灵活了是好事还是坏事呢？

一人一种写法 读起来会不会很吃力？



  

    23 楼
    cino
    2007-05-13  
    
    
  
  
楼主总结的很好，学习中，谢谢！



  

    22 楼
    dazuiba
    2007-05-12  
    
    
  
  
qiezi 写道
Suninny 写道
还有借鉴了Perl的：

names = %w[ruby rails java python cookoo firebody]

等同于：

names = ["ruby", "rails", "java", "python", "cookoo", "firebody"]



%w, %r, %Q, %q, %s, %x还挺多。



好像在哪里看到过这些惯用法的全称，但是记不得地址了，谁给个链接？





  

    21 楼
    pilipala
    2006-09-20  
    
    
  
  
qiezi 写道
这么全啊。inject我看了几次没理解，干脆不看了。



ruby函数调用可以省括号，方便是方便，不过一些FP用法也看不见了，这方面python还比较好。



从facet可以看出来，ruby里面使劲往一个类里塞东西还是有传统的。



inject的确挺不太容易搞明白的，为了搞明白索性简单实现一下，这样理解应该会更深刻些，比如：

(1..10).inject{|sum, item| sum += item}




可以用下面的代码简单实现



class Range
	def my_inject(x)
	  each { |i| x = yield(x,i) }
	  return x
	end
end




仔细想想，ruby这种yield的机制真好，将通常的一个函数调用，变成了2个函数的组合调用。 



这样一方面灵活性大大增加，变化更多。原来是写n个函数就是n种方式，现在变成写 n+m个函数就有了n*m种调用方式了。当然，别的语言也可以做到类似的实现，可是会造成太多的冗余代码，不但写得麻烦，读起来也累。



另一方面，更有利于把任务划分成更小的单位，这样会减少重复代码，让程序变得更简洁，尽量做到DRY（ don't repeat yourself ）



刚开始看ruby，感觉是一个不错的方向。

  



  

    20 楼
    cookoo
    2006-09-20  
    
    
  
  
好用么？我看了一下，大部分都已经包含在facet/core里面了。



另外好像不能精细require? 这样的话在rails里用会引起一些命名冲突。





  

    19 楼
    capitain
    2006-09-20  
    
    
  
  
extionsions也是一个扩展包, cookoo 有没有在用?





  

    18 楼
    qiezi
    2006-09-20  
    
    
  
  
cookoo 写道


@@这个太离谱了吧。。。常用只有%w{}，别的很少用，不就整个字符串嘛。

而且这个再加上字符串格式化那些%一堆或日期格式化里的%一堆，天哪，还是不要增加记忆负担了。





主要是用在正则表达式里。有时候正则表达式里要匹配'/'字符，为了不写成\/，就把默认的//改成%r{}，如果里面还要匹配{}，就可以改成%r()。圆括号和方括号又容易看错成正则表达式里面的东西，于是改成@。。。



  

    17 楼
    cookoo
    2006-09-20  
    
    
  
  
qiezi 写道
Suninny 写道
还有借鉴了Perl的：

names = %w[ruby rails java python cookoo firebody]

等同于：

names = ["ruby", "rails", "java", "python", "cookoo", "firebody"]



%w, %r, %Q, %q, %s, %x还挺多。



另外不光是括号、中括号，键盘上能看到的符号差不多都支持：



%w@ruby rails java python cookoo firebody@

%w#ruby rails java python cookoo firebody#

%w~ruby rails java python cookoo firebody~

...

真是方便。

@@这个太离谱了吧。。。常用只有%w{}，别的很少用，不就整个字符串嘛。

而且这个再加上字符串格式化那些%一堆或日期格式化里的%一堆，天哪，还是不要增加记忆负担了。







  

    16 楼
    cookoo
    2006-09-20  
    
    
  
  
njmzhang 写道
cookoo 写道




python的list comprehension是我个人很喜欢的syntax sugar







我觉得Python的list comprehension很丑陋，英语单词太多，复杂一点的list comprehension就能写成一长串，反而不好阅读。

好像还是Haskell的list comprehension看着更明白

python的list comprehension语法偏自然语言，haskell的偏数学表达，两个各有千秋，但都比ruby没有强。当然list comprehension本身也不是万能，不能把什么都往里面塞，复杂的还是老实用map之类的好。



  

    15 楼
    qiezi
    2006-09-20  
    
    
  
  
Suninny 写道
还有借鉴了Perl的：

names = %w[ruby rails java python cookoo firebody]

等同于：

names = ["ruby", "rails", "java", "python", "cookoo", "firebody"]



%w, %r, %Q, %q, %s, %x还挺多。



另外不光是括号、中括号，键盘上能看到的符号差不多都支持：



%w@ruby rails java python cookoo firebody@

%w#ruby rails java python cookoo firebody#

%w~ruby rails java python cookoo firebody~

...

真是方便。



  

    14 楼
    thundercao
    2006-09-20  
    
    
  
  
好东西,收藏一下



  

    13 楼
    njmzhang
    2006-09-20  
    
    
  
  
cookoo 写道




python的list comprehension是我个人很喜欢的syntax sugar







我觉得Python的list comprehension很丑陋，英语单词太多，复杂一点的list comprehension就能写成一长串，反而不好阅读。

好像还是Haskell的list comprehension看着更明白



  

    12 楼
    Suninny
    2006-09-20  
    
    
  
  
buaawhl 写道


。。。



搜索了一下，ruby unshift，结果出来很多 array unshift 的结果。

到底是没有找到 $:.unshift('buildscript') 的具体说明。



你没找错啊，$:是一个Array类型的全局变量，unshift是Array的一个实例变量。



找文档无需Google的，ri一下就OK了：

ri Array#unshift



  

    11 楼
    Suninny
    2006-09-20  
    
    
  
  
还有借鉴了Perl的：

names = %w[ruby rails java python cookoo firebody]

等同于：

names = ["ruby", "rails", "java", "python", "cookoo", "firebody"]









  

    10 楼
    cookoo
    2006-09-20  
    
    
  
  
谢谢大家的补充和斧正 :^) 我相应更新了一些内容



python的list comprehension是我个人很喜欢的syntax sugar，它主要是map和filter的复合化身，和inject/reduce/fold应该没瓜葛。



关于name space管理，最近关于Rails的controller和model为什么用name space分割很麻烦有不少争论。另外有些plugin也不注意合理使用name space包裹。Rails下Module.constants已经包含太多所谓根命名，这个数量越多冲突可能性越高。



firebody: 辛苦你翻译了，我想java的fp扩展里应该有类似功能。我原文说’返回两个结果‘确实容易让人困扰，已澄清。



  

    9 楼
    njmzhang
    2006-09-19  
    
    
  
  
firebody 写道


另外对于那个 函数可以返回多个值 。







函数不是返回多个值，

在Pickaxe里有写道：

"if you give return multiple parameters, the method returns

them in an array. You can use parallel assignment to collect this return value."



  

    8 楼
    buaawhl
    2006-09-19  
    
    
  
  


a,b = 0, 1



a, *b = [1,2,3]  ＃a = 1, b = [2,3]



这两条可以合起来看.



a,b = 0, 1



右边的 0, 1 类似于一个 tuple ( 可以理解为定长数组 )

对应到FP是，

{a, b} = {0, 1} 



a, *b = [1,2,3]

对应到FP是，

[a | b] = [1, 2, 3]







  

    7 楼
    firebody
    2006-09-19  
    
    
  
  
(1..10).inject([]){|array, item| array << item}

翻译成java code:

package com.redsoft.jpa.query.nativequery;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * 
 * @author firebody
 * @since 2006-9-19 22:02:29
 * 
 */
public class Injecter {
	Iterator iter;

	public Injecter(Iterator iter) {
		super();

		this.iter = iter;
	}

	public void kickoff(Class type, InjecterCodeBlack executeBlack) {
		Object instance = null;
		try {
			instance = type.newInstance();
		} catch (InstantiationException e) {
			throw new RuntimeException(e);
		} catch (IllegalAccessException e) {
			throw new RuntimeException(e);
		}
		while (iter.hasNext()) {
			executeBlack.executeCodeBlack(instance, iter.next());
		}
	}

	interface InjecterCodeBlack {
		void executeCodeBlack(Object arg1, Object iteratedItem);
	}

	public static void main(String[] args) {

		new Injecter(Arrays.asList(new String[] { "1", "2", "3" }).iterator())
				.kickoff(ArrayList.class, new InjecterCodeBlack() {

					public void executeCodeBlack(Object arg1,
							Object iteratedItem) {
						((List) arg1).add(iteratedItem);
						System.out.println(arg1);
					}
				});
	}

}



另外对于那个 函数可以返回多个值 。



我想乱弹一下，哈哈，大家别笑话我这个ruby门外汉 。



这是我和某某人乱弹经过:



引用
倪宏业 说:

def test



  1,2



end



x, y = test ＃x = 1, y = 2	

firebody(啊翔) 说:

感觉他名次上搞了一些技巧

firebody(啊翔) 说:

其实我认为这不是返回两个结果

倪宏业 说:

x,y=test 是赋值 ?

firebody(啊翔) 说:

对，这是一个分别赋值

倪宏业 说:

其实是这么理解的

x,y = test #;

x = 1;

y = 2;

三句？





firebody(啊翔) 说:

我分析有两种可能

firebody(啊翔) 说:

一种是 ruby本身有更进一步的分析引擎，分析出的单元执行语句就是你上面提到的

倪宏业 说:

晕#是注释吧？

firebody(啊翔) 说:

晕倒，当然了

倪宏业 说:

我还当成一个交换符，哈哈。。。

firebody(啊翔) 说:

一种是 ruby本身对这种并行负值作了特殊的支持 ，

firebody(啊翔) 说:

比如 x , y 是一个特殊对象，表示 一个变量集合域

firebody(啊翔) 说:

1,2表示一个对象，是一个值域

firebody(啊翔) 说:

x,y = 1,2

firebody(啊翔) 说:

两边是相同的对象类型（域类型）

firebody(啊翔) 说:

然后=在这个类型上作了特殊的定义

firebody(啊翔) 说:

可能就分别赋值得语义

firebody(啊翔) 说:

以为ruby可以把任意的对象从新组合成一个新的对象

firebody(啊翔) 说:

在这个新的对象上执行新的操作，符号赋写就被赋予更特殊的含义

firebody(啊翔) 说:

所以，后面的分析 我觉得更有可能一些

firebody(啊翔) 说:

如果是 后面的那种分析的话

倪宏业 说:

感觉复杂了

firebody(啊翔) 说:

cookoo说返回两个对象，就是感觉是一种“名次的欺骗？ “

firebody(啊翔) 说:

其实就是返回一个对象

firebody(啊翔) 说:

哦，也可能是我胡思乱想，哈哈



firebody(啊翔) 说:

可能就是 ruby进行再解析了



  

    6 楼
    njmzhang
    2006-09-19  
    
    
  
  
buaawhl 写道


搜索了一下，ruby unshift，结果出来很多 array unshift 的结果。

到底是没有找到 $:.unshift('buildscript') 的具体说明。



这个不就是把buildscript加到$:路径里吗



  

    5 楼
    buaawhl
    2006-09-19  
    
    
  
  
gigix 写道


inject就是reduce，map就是map……后面这句是废话。

源文件管理的惯用法如下

[code=Ruby]

# to import buildscript/javascripttest.rb ...

$:.unshift('buildscript')

require 'javascripttest'





这个unshift不错。



有点类似于Python的

from Sound.Effects import echo



不过，Python还可以直接 import 到 Function 级别 （对应Java的Class Static Method? ）

from Sound.Effects.echo import echofilter



搜索了一下，ruby unshift，结果出来很多 array unshift 的结果。

到底是没有找到 $:.unshift('buildscript') 的具体说明。



    
    
« 上一页 1 2 下一页 »