加载中…
正文 字体大小:

ruby 常用的方法的总结

(2012-10-29 23:56:12)
标签:

it

分类: Ruby


 下面是学习中对ruby的一些常见的方法的总结:

1.each方法

each方法经常与block一起使用,它的最大好处能够在某冲情况下取代for循环的功能。each方法会将调用它的对象中的所有元素依次赋给与each方法相关联的block变量。

例如:

('a'..'e').each{  |char|
print char
       

输出结果是 abcde   #range中两点表示全闭区间,三点表示前闭后开输出结果是->abcd

在上面的例子中,range对象(‘a’..’e’)调用each方法,each方法将(‘a’..’e’)对象的每个值依次赋给block{|char| print char}中的char变量。

再来看下面这个例子:

file = File.open("c://sss.c") #打开名称为filename的文件,并将其内容写入到file

file.each {  |line|

puts line

}

file.close#文件打开后必须关闭

输出结果:

this is line one

this is line two

this is line three

and so on……

 

2.capitalize方法

方法是字符串类String的一个方法,对所有字符串都适用。它的作用是将调用该方法的字符串的首字母改为大写。举例如下:

s = “ruby”

s.capitalize → “Ruby”

又如:

defsay_goodnight(name)

result = "Good night, #{name.capitalize}"    #capitalize将参数name所代表的字符串的首字母改为大写

returnresult                                                     #其实这条语句是多余的,因为一个方法如果没有指定返回值,则默认返回最后一个表达式的值

end

puts say_goodnight("mum")

输出结果:

Good night,Mum

3.times方法

调用times方法的一般是具体的数字(整数)对象,times会按照对象的要求来指定其后block的执行次数。该方法是整数支持的集中常用的迭代器之一。

例如:

5.time { print “*” }

输出结果:

*****

 

4.upto()方法

upto()方法会有一个参数,它的参数的值将与调用它的对象的值构成一个range,然后再将该range内的值依次赋值给其后block中的变量。该方法是整数支持的集中常用的迭代器之一。

例如:

factorial = 1

1.upto(10) do |i|  #

      factorial*= i

end

puts factorial

执行结果为:

   3628800

 

输出结果为:

345678

5.inject方法

inject方法可以遍历集合中的所有成员以累计出一个值,一般地,他可以求得集合中元素的和或积。例如:

[2,4,6,8].inject(0) { |sum,element|   sum + element }输出结果:20//把0赋给num,数组里面的元素赋给element

[2,4,6,8].inject(1) { |product,element|  product * element }输出结果:384

上述两条语句展示了求集合中元素的和或积的方法。

inject方法的工作原理:

(1)inject有参数时,inject后面的block第一次执行时,sumproduct的值被设置为参数的值,而element的值被设置为集合中第一个元素的值。接下来每次再执行block时,sumproduct的值被设置为上次调用block时的返回值,element即为集合中下一个元素的值。inject的最终结果是最后一次调用block的返回值。

(2)inject没有参数时,那么sumproduct的初始值即为集合中第一个元素的初始值,表达式将会从第二个元素开始迭代。

根据上述说明,可以很容易得出下面这些表达式的结果:

[2,4,6,8].inject(3) { |sum,element| sum + element }输出结果:23

[2,4,6,8].inject(2) { |product,element| product * element }输出结果:768

[2,4,6,8].inject { |sum,element| sum + element }输出结果:20

[2,4,6,8].inject { |product,element| product * element }输出结果:384

调用inject方法的是一个集合,这个集合可以是数值Array,同时它还可以是range例如:

(2..5).inject(3) { |sum,element| sum + element }输出结果:17

(2..5).inject(2) { |product,element| product * element }输出结果:240

该集合也可以是数值Array的一部分,例如:

a = [2,4,6,8,10] .

a[0,2].inject(3) { |sum,element| sum + element }

输出结果:9

6.abs方法

abs方法的作用是取得调用它的数字对象的绝对值。例如:

a = -123

a.abs →123

-123.abs→ 123

注意,absnum)这种表达方式是错误的。

7.downto()方法

downto()方法是upto()方法的逆方法。downto()方法有一个参数,调用它的对象的值它的参数的值将与构成一个range,然后再将该range内的值依次赋值给其后block中的变量。该方法是整数支持的集中常用的迭代器之一。

例如:

20.downto(15) { |i| print i, ““}

输出结果:201918171615

8.step()方法

方法的形式为:a.step(b,c) {block},它有两个参数,其中第一个参数b与调用该方法的数字对象b构成一个range。相当于是一个以a为首项,b为末项,c为公差的一个等差数列。step方法的作用就是将该等差数列的各项分别传入block中,即进行迭代。

例如:

10.step(202) {|i| print i, “,”}

输出结果:

101214161820

注意,从数学的意义上讲,在setp方法中并不要求b = n*c成立(n为整数),只需要满足a < b成立即可。

例如:

12.step(265.1) {|i| print i, “,”}

输出结果:

12.017.122.2

 

9.map 方法和collect方法一样
将操作后的数据放入一个新的数组返回,并且又不影响原有的数组。从表面上看,Ruby中的Map和Collect正好可以实现该功能,因为关于这两个迭代器的描述是这样的:Invokes block once for each element of self. Creates a new array containing the values returned by the block. 恩,很不错,这个迭代器会遍历每个数据,然后放入block块进行运算,最后将block块的返回值加入一个新创建的数组,这个新数组会在迭代完成后返回。

#代码块的返回值可以被调用者使用。

b = [1, 2, 3, 4, 5].map do |entry|   #将操作后的数据放入一个新的数组返回

   entry * entry

end

print b.inspect 

 #执行结果为: [1, 4, 9, 16, 25]

 

10.inspect方法

当我们试着直接观察一个对象,就会出现一些像 # 的东西.这只是个缺省的行为,我们可以自由地改变它.我们所要做的只是加一个名为 inspect 的方法.它会换一个更明了的描述对象的字符串,包括部分或全部的实变量。

ruby> class Fruit
| def inspect
| "a fruit of the " + @kind + " variety"
| end
| end
nil
ruby> f2
"a fruit of the banana variety"

一个相关的方法是to_s(转化为字符串),用在打印对象的时候.一般的,你可以认为 inspect 是一个编写或调试程序时用的工具,而 to_s 是一个美化程序输出的方法。eval.rb显示结果时总采用 inspect。 你可以用 p 方法简单的从程序里取得调试信息.

 

11.print、p、puts的区别
        puts将一个字符串打印到控制台并在其后添加一个换行符(除非该字符串已经以一个换行符结尾了)。如果传递给puts的对象不是一个字符串,那么puts就调用该对象的to_s方法,并且打印返回的字符串。
 
        print方法和puts方法的做的基本上是同一件事情,但是它并不在末尾添加一个换行符。
 
        p是puts的一个有用的替代者,不仅仅是因为p比puts更简短,而且还因为它是通过inspect方法将对象转换成字符串的,有时候此方法能比to_s方法返回对程序员更加友好的对象表示。比如,当要打印一个数组时,p输出采用的是数组字面量的表示法,而puts则只是简单的将每个元素打印到单独的一行! 

array = [2,4,6,8,10]

puts array
p array

print array

puts array输出的结果是:

2
4
6
8
10

p array的结果:[2, 4, 6, 8, 10]

ptint array的结果:12345  //末尾没有换行符

 12.yield方法

 在用yield时就像是在定义时包含它的块在遇到yield时执行和定义块名字相同的块一样!!!

在方法中可以使用yield来执行代码块的内容,就好像传入的代码块是这个方法的一部分一样。每当碰到一个yield调用,代码块的内容就会被执行一次。当代码块执行结束后,程序会回到yield的那一行继续向下执行。

def time
  start = Time.now
  yield
  sleep(1)
  puts Time.now 
  puts  start
end
time { puts "code_here" }
time { puts "more_code_here1" }
time { puts "more_code_here2" }

#结果:

code_here
Sat Dec 31 11:51:46 +0800 2011
Sat Dec 31 11:51:45 +0800 2011
more_code_here1
Sat Dec 31 11:51:47 +0800 2011
Sat Dec 31 11:51:46 +0800 2011
more_code_here2
Sat Dec 31 11:51:48 +0800 2011
Sat Dec 31 11:51:47 +0800 2011

你可以使用yield操作传参数给一个代码块,并且从代码块取回返回值。

    def fibonacii(max)

      f1, f2 = 1, 1

      while f1 <= max

          yield f1

          f1, f2 = f2, f1+f2

      end

end

fibonacii(1000) { |f| print f, " " }

   执行结果为:

   1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

在这个例子中,yield接收一个参数,这个参数将会在执行的时候传递给指定的代码块。在代码块中,接收的参数使用两个竖线括起来放在代码块的头部yield操作也可以有返回值,yield操作的返回值就是代码块中最后一个表达式的值。

 13.Proc方法

 结合代码块使用.有两种用法可以参考:主要是时实现把将要执行的代码片段存放在一起,不立即执行,等到我们要用的时候再执行。

①将一个代码块传递给最后一个参数以&开始的方法。

def meth1(p1, p2, &block)

     puts block.inspect

     puts block.call

end

meth1(1, 2) { "This is a block" }

②使用Proc.new方法,后边的参数为一个代码块:

block = Proc.new { "a block" } #代码不会立即执行

block.call                              #此时会执行Proc存放的代码

#结果: a block
用Proc来组织我们的代码 
Proc是组织代码的好工具,比如现在我们要测试一下某些代码的执行花费时间,通过Proc可以很灵活地做到这一点:


def time(a_proc)
    start = Time.now
    a_proc.call       
    sleep(1)
    puts Time.now - start
end

time(Proc.new { puts "code_here "})
time(Proc.new { puts "more_code_here "})   #此时的两个time是在call之后分别调用的,不是同时,是串行的!!

结果是:

code_here 
1.0
more_code_here 
1.0

14.call方法

   Proc对象的使用方式和Method对象的一样,都是通过call方法来执行与之关联的代码逻辑,我们传给call方法的参数将会传给Proc对象包含的代码块,而代码块的执行结果将会通过call方法返回给我们。那么你可以proc方法来创建Proc对象,效果和通过Proc类的new方法来创建是一样的:

def call_test( b )
  d = b+4;
  ca = Proc.new{ 
  |i| i +d
   puts "call的方法 #{i+d}"}
   ca.call(7)
 end
hh(4)

#结果:call的方法 15

 15.next方法

在一个代码块中执行next语句会导致代码块返回。返回值就是next语句后带的参数。如果next后没有参数,那么返回值为nil

def meth2

      result = yield  #执行meth2后的返回值赋值给result

      "The block result is #{result}"

end 

puts meth2 { next 9 }

pr = Proc.new { next 100 }

puts pr.call

pr = lambda { next }

puts pr.call

执行结果为:

The block result is 9

100

nil

 15.alias 方法

这个方法是对一个函数名或者变量重新命名,当对变量重新命名之后就和旧的变量绑定在了一起,无论哪一个变量改变都会造成变量的改变。但是在重命名函数名(方法名的时候)有点不同,此后即使重新定义了原始方法,别名方法仍然保持着重定义前的老方法的特性。若改变了某方法的内容后,又想使用修改前的方法时,别名会很有用。

def meth

puts "I'm old!"

end

alias :new_meth :meth

def meth

puts "I'm new!!"

end

puts meth

puts new_meth

结果是:I'm new!!  

             I'm old!"

alias 与 alias_method的区别 

    1. alias是Ruby的一个关键字,而alias_method是Module类的一个方法
    2. alias的参数就是方法本身(method identify),注意,不是字符串,也不是Symbol,alias_method的参数则是字符串或者symbol,并且使用逗号分隔
    3. alias_method可以重定义,而alias则不能
    alias new_method_name old_method_name
    alias_method :new_method_name, :old_method_name
    alias_method 'new_method_name', 'old_method_name'

例如:

class B
  def b
    p "bbbbbb"
  end
  alias_method :cb,:b
end
= B.new
d.cb
结果:bbbbb
 

0

阅读 评论 收藏 转载 喜欢 打印举报
  • 评论加载中,请稍候...
发评论

    发评论

    以上网友发言只代表其个人观点,不代表新浪网的观点或立场。

      

    新浪BLOG意见反馈留言板 电话:4006900000 提示音后按1键(按当地市话标准计费) 欢迎批评指正

    新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 会员注册 | 产品答疑

    新浪公司 版权所有