《ruby基础教程》 第三部分 提取

第三部分

数值类
  1. 一些方法:
  • 返回商的整数:x.quo(y)

  • 返回一个数组,[商,余数]:x.divmod(y)

  • Math模块 你想得到的数学函数都在里面

  • 返回整数部分:.floor

  • 返回100以内的随机数:Random.rand(100) (比我以前学的VB方便太多了好嘛!)

  • Integer的迭代方法:

    • upto遍历
    • downto遍历
  • 以分数的形式存在:Rational(1, 10)

  • step迭代的方法:

    • 2到10,每次加3:


    2.step(10,3) do |i|
    p i
    end #=> 2, 5, 8

    • 10到2,每次减3:


    10.step(2,-3) do |i|
    p i
    end #=> 10, 7, 4

数组:
  1. Array.new方法


Array.new #=> []
Array.new(5) #=> [nil,nil,nil,nil,nil]
Array.new(5,0) #=> [0,0,0,0,0]

  1. %w%i
  • 创建不包含空白的字符串数组时,可以使用%w:


    lang = %w(Ruyb Perl Python Scheme Pike)
    p lang #=>["Ruby","Perl","Python","Scheme","Pike"]

  • 创建不包含空白的符号数组时,可以使用%i:


    lang = %w(Ruyb Perl Python Scheme Pike)
    p lang #=>[:Ruby,:Perl,:Python,:Scheme,:Pike]

其中()可替换成其他符号:<> || !! @@ AA

  1. 将散列转换成数组:


a = {a: 1, b: 2}
a.to_a #=> [[:a, 1], [:b, 2]]

  1. 一次性拿到多个值:
  • a[n] or a[-n] 如果是负数,就倒着开始取值。超过总数值会报错。

    • a[n..m] or a[n…m]
    • a[n,len] 从某个元素起,取n个字符。
  1. 一次性赋多个值:

  • a = [1,2,3,4,5,6]
    a[2,3] = [c,d,e] #=> [1,2,c,d,e,6]
    a[2,0] = [a,b] #=> [1,2,a,b,3,4,5,6]


  • a = [1,2,3,4,5,6]
    a[2..3] = [a,b] #=> [1,2,a,b,5,6]

  • .values_at方法


    a = [1,2,3,4,5,6]
    a.values_at(1,3,5) #=> [2,4,6]

  1. 把数组当集合来运算:
  • 交集:ary = ary1 & ary2

  • 并集:ary = ary1 | ary2

  • 集合的差:ary = ary1 - ary2 (在1中找2没有的元素)


    ary1 = ["a","b","c"]
    ary2 = ["b","c","d"]
    p (ary1 - ary2) #=> ["a"]

  1. 把数组当

数组结构:

  • 队列:以排列的顺序,先进先出。(像排队过关一样)
  • 栈:以相反的顺序,先进后出。(像堆东西一样,最慢放入的最容易取出)
  • 追加,删除,引用:

| 操作 | 在头部开刀 | 在尾部开刀 |
| :--: | :-----: | :---: |
| 追加元素 | unshift | push |
| 删除元素 | shift | pop |
| 引用元素 | first | last |

例子:


a = [1,2,3,4,5]
a.push("E") #=> [1,2,3,4,5,E]
a.shift #=> 1
a #=> [2,3,4,5,E]

一些操作方法:
  1. 为数组增加元素:
  • a.unshift(item)

  • a.push(item) ~= a << item

  • a.concat(b) & a+b

    这个concat方法是破坏性方法,会改变被引用的对象。

什么是破坏性的方法

:会改变接收对象值的方法!要注意:被引用的对象也会被破坏!如:


a = [1,2,3,4]
b = a
b.pop #=> 4
p a #=> [1,2,3]

提示:这里b引用了a,并不是复制一个a,而是让a和b同时引用一个对象!这一点要纠正认识!

  1. 从数组中删除元素:
  • a.compact & a.compact! :会把a数组中的空元素nil去掉!区别:
    • 第一种会返回一个新的数组。
    • 第二种会直接替换掉原来的数组。
  • a.delete(x) :从数组中删除x元素。
  • a.delete_at(n) : 从数组中删除a[n]元素。
  • a.delete_if {|item| … } a.reject {|item| … } a.reject! {|item| … } : 这三个方法表示:遍历所有元素,如何右边的block块成立就删掉,其中带感叹号表示破坏性的方法!
  • a.slice!(n) a.slice!(n..m) a.slice!K(n,len) : 这三个方法表示:从数组a中删除指定的部分,并返回被删除的部分的值。slice!是具有破坏性的方法。
  • a.uniq & a.uniq! :表示:去掉重复的元素。
  • a.shift :删除开头的元素。返回删除的值。
  • a.pop :删除末尾的元素。返回删除的值。
  1. 替换数组元素:
  • a.collect{|item| … }
    a.collect!{|item| … }
    a.map{|item| … }
    a.map!{|item| … }
    : 遍历数组a和各元素传给block中的item,最后付出处理后的结果。

  • a.fill(value)
    a.fill(value, begin)
    a.fill(value, begin, len)
    a.fill(value, n..m)
    : 把数组指定元素全部替换成value,默认为全部。

  • a.flatten & a.flatten! :平坦化数组a,就是把里面嵌套的数组展开成一个大数组。(soga,原来是这样啊!)


    a = [1,[2,[3]],[4],5]
    a.flatten!
    p a #=> [1,2,3,4,5]

  • a.reverse & a.reverse! :反转数组a的元素顺序。

  • a.sort
    a.sort!
    a.sort {|i,j| … }
    a.sort {|i,j| … }
    :排序,其中block中的i & j 表示:从数组中两个两个拿出来的数据。

  • a.sort_by{|i| … } :根据块的运行结果时序排序。


    a = [2,4,3,5,1]
    p a.sort_by{|i| -i } #=> [5,4,3,2,1] (这里的block只是参与计算而已,不会破坏原来的数组。)

  1. 数组与迭代器:有些使用迭代器的对象不是数组,但处理后会返回一个数组:


a = 1..5
b = a.collect{|i| i += 2}
p b #=> [3,4,5,6,7]

  1. 数组的初始化问题:


a = Array.new(3, [0,0,0]) #=> [[0,0,0],[0,0,0],[0,0,0]]
a[0][1] = 2 #=> [[0,2,0],[0,2,0],[0,2,0]]
数组的初始化就是有这些问题,要注意,可以使用block带解决:
a = Array.new(3) {[0,0,0])} #=> [[0,0,0],[0,0,0],[0,0,0]]
a[0][1] = 2 #=> [[0,2,0],[0,0,0],[0,0,0]]

  1. zip方法 :引进多个数组,然后同步遍历!:

```
ary1 = [1,2,3,4,5]
ary2 = [10,20,30,40,50]
ary3 = [100,200,300,400,500]

result = []
ary1.zip(ary2,ary3) do |a, b, c|
result << a + b + c
end
p result #=> [111, 222, 333, 444, 555]
```

  1. 一个过滤数组的方法:.select


a = (1..100).to_a
a.select{|i| i % 3 == 0} 过滤3的倍数。

13章练习题:
  1. 创建一个1到100的整数按升序排列的数组:


(1..100).to_a

  1. 累加1中的数组:


a.reduce :+

  1. inject方法


a.inject(0){|memo, i| memo += i}
表示:遍历数组元素赋值给i,每次结果回传给memo.实现累加的效果。

字符串String
  1. 什么是内嵌表达式?


"String#{ruby}" #=> 这个#{}里可以执行ruby表达式的东西就是啦!

  1. 创建字符串
  • 使用%Q与%q

    ```
    desc = %Q{Ruby 的字符中也可以使用'' 和 "".}
    str = %q|Ruby said, 'Hello world!'|

    其中%Q相当于"",%q相当于''。
    ```

  • Here Document方法

    ```
    <<"结束标识"

    内容
    结束标识

    #=> (这里更多的时候要换成<<-"结束标识",这样能让结束的标识不一定在)

    这个方法应该很少用。
    ```

  • sprintf方法 & printf方法

    • printf


    n = 123
    printf("%d\n", n) #=> %d表示以整数形式输出
    printf("%4d\n", n) #=> %4d表示以4位数格式输出
    printf("%04d\n", n) #=> %04d表示不够4位时被零
    printf("%+d\n", n) #=> %+d表示输出结果带 + or -


    n = "Ruby"
    printf("Hello,%s!\n",n) #=> %s表示以字符串形式输出
    printf("Hello,%8s!\n",n) #=> %8s表示输出炎8位字符串
    printf("Hello,%-8s!\n",n) #=> %-8s表示输出左对齐的8位字符

    • sprintf

    printf一样的结果。但书中没有说明具体区别,差评!

  1. 获取字符串的长度
  • length or size两种方法可以,随意!
  • bytesize可以获取字节数。
  • 判断是否为0:empty?
  1. 字符串的索引
  • 当成数组一样用就可以了。
  1. 连接字符串
  • +


    a = "Hello,"
    b = "World!"
    a + b #=> "Hello,World!"

  • <<


    a = "Hello,"
    b = "World!"
    a << b #=> "Hello,World!" (a会被改变!)

  1. 字符串的比较
  • 判断两个字符串是否相同:== !=

  • 比较大小


    "aaaaa" < "b" #=> true 一般按照a~z的顺序排序

  • 如果查看码位 : .ord

  1. 字符串的分割:split(x) :以x为分割点进行分割!

  2. 换行符的操作:

  • 删掉

    | 属性 | 删掉最的一个字符 | 删掉挑选符 |
    | :---: | :------: | :----: |
    | 非破坏性的 | chop | chomp |
    | 破坏性的 | chop! | chomp! |


    a = "abcde"
    b = "abcde\n"
    a.chop #=> "abcd"
    b.chop #=> "abcde"
    b.chomp #=> "abcde"

  1. 字符串的检索与置换
  • 字符串的检索

    • index方法 从左到右检索,返回第一个字母的索引
    • rindex方法 从右到左检索,返回第一字母的索引


    a = "abbbbbb"
    a.index("bb") #=> 1
    a.rindex("bb") #=> 5

  • 判断是否包含某个索引值: include?


    a = "abbbbbb"
    a.include?("bb") #=> true

  1. 字符串与数组有很多共同的索引的方法:
  • s[n] s[n..m] s.slice!(n)
  • s.concat(s2) s+s2 s.delete(str) s.reverse
  1. 其他方法:
  • strip : 删除头尾的空白字符

  • upcase :小写转大写

  • downcase :大写转小写

  • swapcase :大的转小,小的转大

  • capitalize :首字母大写,其余转小写

  • tr :置换字符,与gsub相似,但这里可以一次转换多个字符。


    "ABCDE".tr("BD", "bd") #=> "AbCdE"

14章节练习题提取:
  1. 一个打散的字符串数组,如何快速连接成句子:


a = ["Ruby", "is", "an", "object", "oriented", "programming", "language"]
a.join(" ")
#=> "Ruby is an object oriented programming language"

  1. 统计下面各个字母出现次数,并用*的个数来表示次数:


a = "Ruby is an object oriented programming language"
b = Hash.new(0)
a.each_char do |c|
b[c] += 1
end
b.sort.each do |k, v|
printf("'%s': %s\n", c, "*" * v.to_i)
end

运行结果如图:

很酷!

  • 散列直接用a[c]就可以拿到这个值,不需要进行检索
  • printf格式输出,方便!先定义好整个字符串样式,再后面定义各个引用值。

散列类
  1. 新建hash:
  • a = {} a = {键: 值}
  • a = Hash.new(x) (这里可以设置一个默认值)。
  1. 值的获取与设定
  • fetch & store 一个用来取一个用来存,基本和a["s"]的作法一样,但:

    用下面两个方法可以

    • 设默认值
    • 添加block


    a.store("s1", "Ruby")
    a.fetch("s2", "undef") #=> "undef" (找不到,所以默认值)
    a.fetch("s2"){String.new} #=> "" (这里还可以用block)

  1. hash的迭代器。

| 数组形式 | 迭代器形式 |
| :----: | :-------------------: |
| keys | each_key{|键| …… } |
| Values | each_value{|值| …… } |
| to_a | each{|键,值| …… } |
| | each{|数组| …… } |

  1. hash的默认值。好处:取不存在的值时,不至于发生错误
  • 创建hash时指定默认值:


    h = Hash.new(1)
    h["a"] = 10
    h["a"] #=> 10
    h["b"] #=> 1

  • 创建hash时增加一个block:


    h = Hash.new do |hash,key|
    hash[key] = key.upcase
    end
    h ["a"] = "b"
    p h["a"] #=> "b"
    p h["b"] #=> "B"
    p h["c"] #=> "C" 当找不到这个值时,就会自动去执行这个block

  • 用fetch方法指定默认值:


    h = Hash.new do |hash.key|
    hash[key] = key.upcase
    end
    p h.fetch("x", "(undef)") #=> "(undef)"
    同时两个默认值的方法,fetch的优级级会高

  1. 判断是否为某个Hash的 or
    • h.key?(key)
    • h.has_key?(key)
    • h.include?(key)
    • h.member?(key)
    • h.value?(value)
    • h.has_value?(value)
  1. 查看Hash的大小
  • h.size & h.length


    h = {"a" => "b", "c" => "d"}
    h.size #=> 2

  • h.empty?

  1. 删除值:
  • h.delete(key)

  • h.delete_if{|key, val| … }

  • h.reject!{|key, val| … }

    当不符合时,delete_if会返回原来的Hash,reject!会返回一个nil

  1. 初始化散列
  • h.clear 清空使用过的散列

    那这个东西和h = Hash.new 有什么区别呢?在引用的时候要注意下,请看图:

  • 我忘记了一个超级方便的排序方法:sort
    PS:比起之学VB时的什么泡沫排序法之类的,这里简直不能太好!

正在表达式(Regexp类)
  1. 正则表达式的创建:


re = Regexp.new("Ruby") #=> /Ruby/

  • %r(模式)
  • %r<模式>
  • %r|模式|
  • %r!模式!
  1. 判断某个字符串是否匹配:正则表达式 =~ 字符串
  • 匹配:返回匹配的起始位置

  • 不匹配:返回nil

    还可以:用!~来颠倒结果。

  • 进一步应用:


    if 正则表达式 =~ 字符串
    匹配时的处理
    else
    不匹配时的处理
    end

  1. 匹配行首与行尾:

^, $分别表示匹配行首与行尾:

像这样的特殊字符称为:元字符。

\A,\z分别表示匹配字符串头与尾:

\z \Z 两者的区别


p "abc\n".gsub(/\z/, "!") => "abc\n!"
p "abc\n".gsub(/\Z/, "!") => "abc!\n!"

:大写的\Z,如果最后一个是换行符,则会同时匹配换行符与前一个字符。

  1. 匹配某一个字符:
  • [AB] :匹配A 或B
  • [ABC] :匹配A,B,C中的一个
  • [012ABC] :匹配0,1,2,A,B,C中的一个
  • [A-Z] :匹配A~Z中的一个
  • [ABC][BC] : 匹配一个两位数,第一个数为A,B,C中的一个,第二位数为B,C中的一个。
  • [A_-] :匹配A _ - 中的一个。
  • [^ABC] :匹配除A,B,C外的任意一位数。
  • . :万能通配符,相当于五笔中的z
  1. 反斜杠模式
  • \s : 匹配空格,制表符, 换行符,换页符

  • \d :匹配0到9的数字。

  • \w :匹配英文字与数字。

  • \A :匹配字符串的开头。

  • \z :匹配字符串的末尾。

  • \ :后面如果跟着:^ [ 等字符时,可以为这些字符转义再匹配。如:

    | 模式 | 字符串 | 匹配部分 |
    | ------- | --------- | ------------ |
    | /ABC[/ | "ABC[" | "▶ ABC[ ◀" |
    | /^ABC/ | "ABC" | (不匹配) |
    | /^ABC/ | "012^ABC" | "012▶^ABC ◀" |

  1. 重复模式:(单个字符)
  • * :重复0次以上。可以重复很多次也可以直接没有
  • + :重复1次以上。至少有一次以上
  • ? :重复0次或1次。可有可无不重复,前后的匹配还是要的!
  1. 最短匹配:
  • 上面6中和重复匹配会最可能匹配更多的字符。

  • 最短匹配:加上一个? ,在第一次匹配时就停止,匹配最短的字符。

    也叫贪婪匹配与懒惰匹配。

  1. 使用()来重复匹配多个字符。

| 模式 | 字符串 | 匹配部分 |
| ---------- | ---------- | ----------- |
| /^(ABC)$/ | "ABC" | "▶ABC ◀" |
| /^(ABC)
$/ | "" | "▶◀" |
| /^(ABC)$/ | "ABCABC" | "▶ABCABC ◀" |
| /^(ABC)
$/ | "ABCABCAB" | (不匹配) |

  1. 使用|来多一个匹配选项,可以多选一,也可以全中。

| 模式 | 字符串 | 匹配部分 |
| -------------- | ----- | -------- |
| /^(ABC|DEF)$/ | "ABC" | "▶ABC ◀" |
| /^(ABC|DEF)$/ | "DEF" | "▶DEF ◀" |
| /^(ABC|DEF)$/ | "AB" | (不匹配) |

  1. 使用quote方法来转义所有表达式所有字符:
 re1 = Regexp.new("abc*def")
 re2 = Regexp.new(Regexp.quote("abc*def")) p (re1 =~ "abc*def") #=> nil
 p (re2 =~ "abc*def") #=> 0
  1. 正则表达式的一些选项:

形式:/ … / im

  • i :忽略英文有大小写
  • x :忽略正则表达式中的空白字符以及 # 后面的字符的选项。指定这个选项后,我们就可以使用 # 在正则表达式中写注释了。
  • m :使用后可以:用.匹配换行符了。
  1. 捕获:
  • 查看匹配的部分是什么字符串:以()的形式


    /(.)(.)(.)/ =~ "abc" first = $1
    second = $2
    third = $3
    p first #=> "a"
    p second #=> "b"
    p third #=> "c"

  • 如果是有重复的匹配只会捕获最后一次的字符,如果此时我们想忽略它的捕获,可以这样:以(?:)开头就可以忽略捕获。


    /(.)(\d\d)+(.)/ =~ "123456"
    p$1 #=> "1"
    p$2 #=> "45"
    p$3 #=> "6"
    /(.)(?:\d\d)+(.)/ =~ "123456"
    p $1 #=> "1"
    p $2 #=> "6"

  • 另外一种形式:


    /C./ =~ "ABCDEF"
    p $` #=> "AB"
    p $& #=> "CD"
    p $' #=> "EF"
    这三种可以捕获整个匹配过程的字符

  1. sub方法与gsub方法:带block


str = "abracatabra"
nstr = str.sub(/.a/) do |matched|
'<'+matched.upcase+'>'
end
p nstr #=> "ab<RA>catabra"
nstr = str.gsub(/.a/) do |matched|
'<'+matched.upcase+'>'
end
p nstr #=> "ab<RA><CA><TA>b<RA>"

可以带block,然后把匹配的部分传入block,最后block处理后的结果置换匹配的字符串。

  1. 直接返回的字符串数组:scan方法


p "abracatabra".scan(/.a/) #=> ["ra", "ca", "ta", "ra"]

这是纠正一点:转义符号增加的顺序:


/http:\/\// =~ "http://baidu.com"
$& #=> "http://"

纠正:\+要转义的符号 这才是正确的格式。

章节:IO类

这一章节主要对文件内容的操作。暂时不会用到,理解起来也费劲。

章节:File类与Dir类

这一章节主要是对文件夹的操作。暂时不会用到,记起来也很费劲。

章节:Encoding类

这一章节主要是编码类的讲解。暂时不会用到,要用到时再来查看。

第20章 Time类与Date类
  1. 获取当前时间:
  • Time.new
  • Time.now

时间相关的方法:

| 方法名 | 意义 |
| ----- | ------------------------ |
| year | 年 |
| month | 月 |
| day | 日 |
| hour | 时 |
| min | 分 |
| sec | 秒 |
| usec | 秒以下的位数(以毫秒为单位) |
| to_i | 从 1970 年 1 月 1 日到当前时间的秒数 |
| wday | 一周中的第几天(0 表示星期天) |
| mday | 一个月中的第几天(与 day 方法一样) |
| yday | 一年中的第几天(1 表示 1 月 1 日) |
| zone | 时区(JST 等) |

  1. 指定特定时间:


t = Time.mktime(2017,7,25,16.59,40)
#=> 2017-07-25 16:40:00 +0800

  1. 时间的比较:
  • < > - 等,平常的计算比较方法都可以用啦。
  1. 时间的计算:默认直接计算秒数:


t = Time.now
p t #=> 2013-03-30 03:11:44 +0900 t2=t+60*60*24 #=>增加24小时的秒数
p t2 #=> 2013-03-31 03:11:44 +0900

  1. 时间输出的格式:
  • t.strftime(format)
  • t.to_s

| 格式 | 意义与范围 |
| ---- | -------------------------------- |
| %A | 星期的名称(Sunday 、 Monday ......) |
| %a | 星期的缩写名称(Sun 、 Mon ......) |
| %B | 月份的名称(January 、 February ......) |
| %b | 月份的缩写(Jan 、 Feb ......) |
| %c | 日期与时间 |
| %d | 日(01 ~ 31) |
| %H | 24 小时制(00 ~ 23) |
| %I | 12 小时制(01 ~ 12) |
| %j | 一年中的天(001 ~ 366) |
| %M | 分(00 ~ 59) |
| %m | 表示月的数字(01 ~ 12) |
| %p | 上午或下午(AM、PM) |
| %S | 秒(00 ~ 60) |
| %U | 表示周的数字。以星期天为一周的开始(00 ~ 53) |
| %W | 表示周的数字。以星期一为一周的开始(00 ~ 53) |
| %w | 表示星期的数字。0 表示星期天(0 ~ 6) |
| %X | 时间 |
| %x | 日期 |
| %Y | 表示西历的数字 |
| %y | 西历的后两位(00 ~ 99) |
| %Z | 时区( JST 等) |
| %z | 时区(+0900 等) |
| %% | 原封不动地输出 % |

示例:

Ruby
t = Time.now.strftime("%Y-%m-%d")
#=> "2017-7-25"

###### 另外两个冷门的格式:(需要引用time类)

  • t.rfc2822
  • t.iso8601f


require "time"
t = Time.now
p t.rfc2822 #=> "Tue, 25 Jul 2017 17:19:00 +0800"
p t.iso8601 #=> "2017-07-25T17:19:42+08:00"

  1. 本地时间与国际时间的切换:
  • t.utc
  • t.localtime


t = Time.now
p t #=> 2017-07-25 17:21:35 +0800
t.utc #=> 2017-07-25 09:21:35 UTC
t.localtime #=> 2017-07-25 17:21:35 +0800

  1. 从字符串中获取时间:
  • Time.parse(str)

    ```
    require "time"

    p Time.parse("2017-7-25") #=> 2017-07-25 00:00:00 +0800
    ```

  1. 日期的获取:Date类,适合只需日期不需时间的操作。
  • Date.today

  • 计算:直接加减默认计算天数

  • 同样也有各种方法:


    d = Date.today
    p d.year pd.month pd.day
    p d.wday p d.mday pd.yday
    # 年 => 2017
    #月 => 7
    #日 => 25
    # 一周中的第几天(0 表示星期天)
    # 一个月中的第几天(与 day 方法一样) => 30 #一年中的第几天(1表示 1月 1日) =>206

  • 用指定日期生成Date对象:


    d = Date.new(2017,7,25)
    puts d #=> 2017-7-25

    还可以用-1 -2 表示末尾的第几天:


    d = Date.new(2017,7,-1) #=> 2017-7-31 7月月尾
    d = Date.new(2017,7,-2) #=> 2017-7-30 7月月尾前一天

  1. Date类的运算:
  • 正常的加减,默认会以天数为单位计算
  • >> << 会以月份为单位进行运算。
  1. Date类的格式:
  • 与前面的Time类一致。
  1. 从字符串中获取Date类:
    • 和Time类一致: Date.parse(str)
Proc类
  1. 什么是proc类,

把block块变成一个对象,这个对象所属的类就是Proc类。这样可以方便我们在后面的调用。

  1. 创建方法:
  • Proc.new(…)
  • proc{}
  1. 调用方法:
  • 利用Proc#call方法

  • 利用Proc[]方法

    ```
    sayhello = Proc.new do |name|
    puts "Hello, #{name}."
    end

    sayhello.call("World") #=> Hello, World.
    sayhello["World"] #=> Hello, World.
    ```

  1. 另一种写法:lambda

lambda 还有另外一种写法:-> (块变量){处理}

```
prc1 = Proc.new do |a, b, c|
p [a, b, c]
end
prc1.call(1,2) #=> [1, 2, nil]

prc2 = lambda do |a, b, c|
p [a, b, c]
end
prc2.call(1,2) #=> 错误 (ArgumentError)
```

lambda proc 两者的区别:

  • lambda的参数数量要对应否则会出错,proc的参数数量则没有那么严格。
  • lambda可以使用return将值从块中返回。
  1. proc类可以接收块

  2. proc的特征:

具有闭包的特征。 闭包:将处理内容、变量等环境同时进行保存的对象,在编程语言中称为闭包(closure)。

  1. proc的实例方法:
  • prc.call(args,…)
  • prc[args, … ]
  • prc.yield(args, … )
  • prc.(args, … )
  • prc === arg


prc = Proc.new{|a, b| a + b}
p prc.call(1, 2) #=> 3
p prc[3, 4] #=> 7
p prc.yield(5, 6) #=> 11
p prc.(7, 8) #=> 15
p prc === [9, 10] #=> 19

Ruby
fizz = proc{|n| n % 3 == 0 }
buzz = proc{|n| n % 5 == 0 }
fizzbuzz = proc{|n| n % 3 == 0 && n % 5 == 0}
(1..100).each do |i|
case i
when fizzbuzz then puts "Fizz Buzz"
when fizz then puts "Fizz"
when buzz then puts "Buzz"
else
puts i
end
end

  • prc.arity : 返回块变量的个数。
  • prc.parameters
  • prc.lambda? :判断是否通过lambda定义的方法。
  • prc.source_location: 返回值为[代码文件名,行编号]
comments powered by Disqus