发布新日志

  • Ruby 小结

    2013-03-18 16:18:16

    Ruby的变量没有类型
    所有变量均无需声明即可立即使用
    不需要内存管理
    纯粹的面向对象语言
    功能强大的字符串操作和正则表达式检索功能

    字符串是指被单引号(')或双引号(")括起来的部分
    在用双引号括起来的字符串中,可以使用反斜杠(\)来指定转义字符
    用[]括起来的一串表达式是数组,而以{}括起来的一串表达式是散列表

    局部变量,变量名以小写英文字母开始。
    全局变量,以$开始
    实例变量,以@开始
    类变量,以@@开始
    类常数,以大写英文字母开始

    赋值 变量=表达式
    调用方法 表达式.方法名
    使用分号(;)或换行来分隔表达式

    流程控制结构:
    if 表达式 then 代码块 [elsif 表达式 then 代码块]..[else 代码块]end
    case 表达式 when 表达式..; 代码块...[else 代码块] end
    while 表达式;代码块 end
    for 变量..in 表达式; 代码块 end
    break 中断循环
    next 开始下一次循环
    redo 重新执行块的第一行

    exit([status]) 结束程序的运行
    gets 从命令行参数指定的文件(群)中读取一行,然后把该行的内容作为字符串返回。
    open(文件名[,mode]) 打开文件
    print 输出函数

    正则表达式

    [ ] 范围描述符。[a-z]表示从a到z之间的任意一个。
    \w 英文字母和数字。即[0-9 A-Z a-z]。
    \W 非英文字母和数字
    \s 空字符,即[\t\n\r\f]。
    \S 非空字符。
    \d 数字,即[0-9]。
    \D 非数字。
    \b 词边界字符(在范围描述符外部时)
    \B 非词边界字符
    \b 退格符(0x08)(在范围描述符内部时)
    * 前面元素出现0次以上
    + 前面元素出现1次以上
    {m,n} 前面元素最少出现m次,最多出现n次
    ? 前面元素出现0次或1次
    | 选择
    ( ) 群组
    其他字符 该字符本身
  • Ruby语言入门(22)- 内部类 -String

    2013-02-06 16:01:37

    String是处理字符串的类。可处理任意长度的字节串。

    在该类的众多方法中,那些方法名尾部是!的方法将会直接修改字符串的内容。此时,使用不带!的同名方法是比较安全的。

    类方法

    String.new(string)
    生成并返回一个与string内容完全相同的新字符串。

    String.new("test")
    =>"test"

    实例方法

    self + other
    将字符串连接起来之后,返回得到的新字符串。

    "test1"+"test2"
    =>"test1test2"

    self * times
    将字符串的内容重复times次之后,返回新字符串

    "test1"*3
    =>"test1test1test1"

    self % args
    字符串的格式化。按照格式化字符串(self)的要求对参数进行格式化之后将其返回。
    若args是数组,则等同于sprintf(self, *args),除此之外,则等同于sprintf(self, args)

    "%#x"%10        
    => "0xa"
    "%#x"%8      
    => "0x8"

    self = = other
    self > other
    self >= other
    self < other
    self <= other
    字符串的比较。

    self << other
    concat(other)
    将other字符串的内容连接到self之后。

    “123”<<"a"
    =>"123a"
    “123”<<1
    =>"123\x01"

    self =~ other
    与正则表达式other进行匹配操作。若匹配成功则返回匹配位置的索引,若失败则返回nil

    "test"=~/./
    =>0
    $~
    =>#<Matchdata "t">

    self[nth]
    以整数形式(字符代码)返回第nth字节的内容(相反地,若想从字符代码变为字符串时,请使用Integer#chr)。若nth为负值,则从字符串尾部算起。若nth超出范围则返回nil。

    "abcd"[0]
    =>"a"
    "abcd"[-2]
    =>"c"

    self[nth, len]
    返回从第nth字节算起的长度为len字节的子字符串。若nth为负数则从字符串尾部算起。若nth超出范围则返回nil。

    "abcd"[-2,2]
    =>"cd"

    self[regexp]
    self[regexp, nth]
    返回最初那个与regexp相匹配的子字符串。与匹配操作相关的信息被存入内部变量$~中。
    若使用了nth参数,则返回最初那个与regexp中第nth个括号相匹配的子字符串。若nth为0,则返回整个匹配的字符串。若匹配失败或没有与nth相对应的括号时,返回nil。

    "test"[/te/]
    =>"te"
    "test"[/te/,0]
    =>"te"

    self[first..last]
    生成并返回一个包含从索引first到索引last之间所有内容的字符串。

    "abcd"[1..2]
    =>"bc"

    self[first...last]
    将字符串的头部看作第0个缝隙,将字符串的末尾看作第self.length个缝隙,然后生成并返回一个包含从第first个缝隙到第last个缝隙之间的所有内容的字符串。

    "abcd"[1...2]
    =>"b"

    self[nth]=val
    以val来替换第nth字节的内容。若val是0到255之间的整数时,就把它看作是字符代码,并以该代码所对应的字符来进行替换操作。

    s1="abcd"
    s1[1]="f"
    s1
    =>"afcd"

    self[nth, len]=val
    以val来替换从第nth字节起长度为len字节的子字符串。若nth为负数则从尾部算起。

    s1="abcd"
    s1[1,2]="f"
    s1
    =>"afd"

    self[substr]=val
    以val来替换字符串中第一个与substr相对应的子字符串。

    s1="abcd"
    s1["bc"]="ff"
    s1
    =>"affd"

    self[regexp]=val
    self[regexp, nth]=val
    以val来替换第一个与正则表达式regexp相匹配的子字符串。若使用了参数nth时,则以val替换第一个与正则表达式regexp中的第nth个括号相匹配的子字符串。若nth为0时,则以val来替换整个匹配部分。

    s1="test"
    s1[/es/]="ff"
    s1
    =>"affd"

    self[first..last]=val
    self[first...last]=val
    以val来替换从first到last之间的内容。

    s1="abcd"
    s1[1..2]="ff"
    s1
    =>"affd"
    s1[1...2]="d"
    s1
    =>"adfd"

    self <=> other
    以ASCII代码的顺序来比较self和other。若self较大时返回正整数,相等时返回0,较小时返回负整数。

    capitalize
    capitalize!
    将首字符(若为字母的话)改为大写字母,其余的改为小写字母。

    "test".capitalize
    =>"Test"
    "TEST".capitalize
    =>"Test"

    casecmp(other)
    该方法与String#<=>一样,是用来比较字符串的顺序的。 它将忽略字母的大小写。

    center(width)
    ljust(width)
    rjust(width)
    center(width[, padding])
    ljust(width[, padding])
    rjust(width[, padding]) 
    分别返回居中、靠左、靠右的字符串。第二参数padding的话,将使用padding来填充空白.

    "test".rjust(10,"*")
    =>"******test"

    chomp([rs])
    chomp!([rs])
    删除字符串尾部的行切分符,该切分符由rs指定。rs的默认值取自变量$/的值。

    "test\n".chomp    
    => "test"

    chop
    chop!
    删除字符串末尾的字符(若字符串末尾是"\r\n"的话,就删除2个字符).

    "test".chop
    =>"tes"

    clone
    dup
    返回一个与原字符串内容相同的新字符串. 对被冻结的字符串使用clone会得到一个同样被冻结的字符串,而使用dup就会得到一个内容相同但未被冻结的字符串.


    count(str[, str2[, ... ]])
    返回在该字符串中str所含字符出现的次数.若给出多个参数,则意味着会使用所有参数的交集.

    "testtesttest".count("s")
    =>3 (count for "s")
    "testtesttest".count("st")
    =>9 (count for "s"+"t")
    "123456789".count('2-8', '3-4')
    =>2

    crypt(salt)
    生成并返回一个由self和salt加密而成的字符串. salt是一个由字母或数字、点(.)和斜线(/)构成的2字节以上的字符串.

    "test".crypt("123")
    =>"126D8rSh5sjUE"

    delete(str[, str2[, ... ]])
    delete!(str[, str2[, ... ]])
    从该字符串中删除str所包含的字符.若给出多个参数,则意味着会使用所有参数的交集.

    "123456789".delete("2-8", "4-6")  
    => "123789"
    "123456789".delete("2378")         
    => "14569"

    downcase
    downcase!
    将字符串中的大写字母都改为小写字母.

    dump
    使用反斜线表示法替换字符串中的非显示字符,并返回修改后的字符串

    "test".dump
    =>"\"test\""

    each([rs]) {|line| ... } (each 报错)
    each_line([rs]) {|line| ... }
    对字符串中的各行进行迭代操作. 此时,rs中的字符串将成为行切分符,行切分符的默认值取自变量$/的值.各line中包含用作切分符的字符串.若将rs设为nil时,则意味着不作行的切分. 若设为空字符串""则将连续的换行当做行切分符(段落模式).

    a="1\n2\n3\n"
    a.each_line {|n| puts n}
    1
    2
    3
    =>"1\n2\n3\n"

    each_byte {|byte| ... }
    对字符串中的各个字节进行迭代操作.

    a="1\n2\n3\n"
    a.each_byte {|n| puts n}
    49
    10
    50
    10
    51
    10
    =>"1\n2\n3\n"

    empty?
    若字符串为空(也就是说其长度为0),则返回真.

    gsub(pattern, replace)
    gsub!(pattern, replace)
    gsub(pattern) {|matched| .... }
    gsub!(pattern) {|matched| .... }
    以replace来替换字符串中所有与pattern相匹配的部分. replace中的\&和\0被替换为匹配的子字符串,而\1 ... \9被替换为第n个括号的内容.在替换字符串replace中,还可以使用\`、\'或\+. 它们分别对应于$`、$'、$+.

    a="test"
    a.gsub!("es","se")
    a
    =>"tset"

    hex
    把字符串看做是16进制数形式,并将其变为整数.

    "123".hex
    =>10

    include?(substr)
    若字符串中包含substr子字符串的话,就返回真.若substr是从0到255之间的Fixnum时,将把它看做是字符代码,若包含该代码所对应的字符,就返回真.

    "test".include?("e")
    =>true

    index(pattern[, pos])
    按照从左到右的顺序搜索子字符串,并返回搜索到的子字符串的左侧位置. 若没有搜索到则返回nil.在参数pattern中,可以使用字符串,0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.若给出了pos时, 则从相应位置开始搜索.省略pos时其默认值为 0.

    "test".index("es")
    =>1
    "test".index("es",3)
    =>nil

    insert(nth, other)
    在第nth个字符的前面插入other字符串.

    "test".insert(2,"ooo")
    =>"teooost"

    intern
    to_sym 
    返回与字符串相对应的符号值(Symbol). 

    "test".intern
    =>:test

    length
    size
    返回字符串的字节数.

    "test".size
    =>4

    match(regexp) 
    match(regexp[, pos]) 
    与regexp.match(self[, pos])相同

    "test".match(/./)
    => #<MatchData "t">

    next
    next!
    succ
    succ!
    返回下一个字符串. 所谓"下一个"是指,按照26个字母顺序或10进制数的顺序继续向下数时得到的结果.

    "abc".next
    =>"abd"
    "123".succ
    =>"124"

    oct
    将字符串看做是8进制字符串,并将其变为整数.

    "123".oct
    =>83

    replace(other)
    以other的内容来替换字符串的内容.

    "test".replace("123")
    =>"123"

    reverse
    reverse!
    对字符串进行反转.

    "123".reverse
    =>"321"


    rindex(pattern[, pos])
    按照从右到左的顺序来搜索子字符串,并返回找到的子字符串的左侧的位置. 若搜索失败则返回nil.在参数pattern中,可以使用字符串,从0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.若给出了pos时,就从相应位置开始搜索. 省略pos时,其值为self.size (右端).

    "character".rindex("c")
    =>5
    "character".rindex("c",0)
    =>0

    scan(re)
    scan(re) {|s| ... }
    使用正则表达式re反复对self进行匹配操作,并以数组的形式返回匹配成功的子字符串.

    "test".scan(/./)
    =>["t","e","s","t"]

    slice(nth[, len])
    slice(substr)
    slice(first..last)
    slice(first...last)
    slice(regexp[, nth])
    与self[ ]相同.

    slice!(nth[, len])
    slice!(substr)
    slice!(first..last)
    slice!(first...last)
    slice!(regexp[, nth])
    从字符串中删除指定的范围(请参考self[ ]),然后返回删除的子字符串.

    a="test"
    a.slice(1)
    =>"e"
    a.slice!(1)
    a
    =>"tst"

    split([sep[, limit]])
    使用sep指定的pattern来分割字符串,并将分割结果存入数组.
    sep可以是下列之一:
    • 正则表达式: 把正则表达式的匹配结果当作切分符来切分字符串。如果使用了括号群组的话,与群组相匹配的字符串也会出现在最后的数组中。
    • 1字节的字符串:把该字符当作切分符来进行切分
    • 2字节以上的字符串:把与Regexp.new(sep)相匹配的字符串当作切分符来进行切分。
    • 省略 或 nil:把$;的值当作切分符来进行切分。
    • 1字节的空白' ' 或 使用了$;且其值为nil时:除了头部的空白之外,使用空白进行切分。
    • 空字符串'' 或 与空字符串相匹配的正则表达式:以单个字符为单位进行切分。可识别多字节字符。

    a="test"
    a.split
    =>["test"]
    a.split("")
    =>["t","e","s","t"]

    squeeze([str[,str2[, ... ]]])
    squeeze!([str[,str2[, ... ]]])
    压缩由str所含字符构成的重复字符串。

    "111222333".squeeze
    =>"123"
    "111222333".squeeze("222")
    =>"1112333"

    strip
    strip!
    删除头部和尾部的所有空白字符。空白字符是指" \t\r\n\f\v"。strip生成并返回修改后的字符串。strip!会修改self本身并返回结果。若没有进行删除动作,则返回nil。

    "   test   ".strip
    =>"test"

    lstrip 
    lstrip! 
    删除字符串头部的所有空白字符。空白字符是指" \t\r\n\f\v"。lstrip会生成并返回加工后的字符串。lstrip!会修改self本身并返回结果。如果没有删除空白字符,则返回nil。

    "   test   ".lstrip
    =>"test   "

    rstrip 
    rstrip!
    删除字符串尾部的所有空白字符。空白字符是指" \t\r\n\f\v"。rstrip会生成并返回加工后的字符串。rstrip!会修改self本身并返回结果。如果没有删除空白字符,则返回nil。

    "  test  ".rstrip
    =>"   test"

    sub(pattern, replace)
    sub!(pattern, replace)
    sub(pattern) {|matched| ... }
    sub!(pattern) {|matched| ... }
    用replace来替换首次匹配pattern的部分。若带块调用的话,就以块的计算值来替换首次匹配的部分。sub生成并返回替换后的字符串。而sub!会修改self本身并返回结果。若没有进行替换时返回nil。
    除去只进行一次匹配这个特点以外,它与gsub是相同的。

    "test".sub("es","ttt")
    ="ttttt"

    sum([bits=16])
    计算字符串的bits位的校验和。

    "test".sum
    =448

    swapcase
    swapcase!
    将所有的大写字母改为小写字母,小写字母改为大写字母。

    "TesT".swapcase
    =>"tESt"

    to_f
    将字符串看作是10进制数形式,并将其变为浮点数Float。

    "123".to_f
    =>123.0

    to_i
    to_i(base) 
    将字符串看作是10进制数形式,并将其变为整数。

    "123".to_i
    =>123

    to_s
    to_str
    返回self。


    tr(search, replace)
    tr!(search, replace)
    若字符串中包含search字符串中的字符时,就将其替换为replace字符串中相应的字符。

    "test".tr("es","aa")
    =>"taat"

    unpack(template)
    按照template字符串的规则,把被pack起来的字符串unpack开来,并以数组的形式返回其结果.

    "test".unpack("a")
    =>["t"]

    upcase
    upcase!
    在ASCII字符串的范围内,将所有字母都变为大写形式。

    upto(max) {|s| ... }
    在从self到max的范围内,依次取出“下一个字符串”后将其传给块,进行迭代操作。

    "a".upto("e") {|s| puts s}
    a
    b
    c
    d
    e
    =>"a"

  • Ruby语言入门(21)- 内部类 -Regexp

    2013-02-06 14:01:19

    Regexp是处理正则表达式的类。正则表达式的字面值是以双斜线内夹表达式的形式生成的。

    /^this is regexp/

    还可以使用Regexp.new(string)来动态地生成正则表达式对象。

    类方法

    Regexp.compile(string[, option[, code]])
    Regexp.new(string[, option[, code]])
    编译string后生成并返回一个正则表达式对象。

    第二参数是可以使用如下的Fixnum值:
    Regexp::IGNORECASE 忽略字符的大小写差异。等同于正则表达式字面值的//i 选项。
    Regexp::MULTILINE 多行模式。正则表达式"."将会匹配换行符。等同于正则表达式字面值的//m 选项。
    Regexp::EXTENDED 忽略从(未以反斜线进行转义的)空白以及#到换行之间的内容。等同于正则表达式字面值中的//x 选项。

    若第二参数并非Fixnum,则被看作是布尔值,若为真(nil,false以外的值)的话,其效果等同于指定了Regexp::IGNORECASE。

    若指定了第三参数的话,进行匹配时将使用指定的字符编码而不受$KCODE的影响。


    Regexp.new("a")
    =>/a/
    Regexp.new("\a")
    =>/\x07/

    Regexp.escape(string[,kcode])
    Regexp.quote(string[,kcode])
    在string中的“特殊字符”前面插入转义字符(反斜线)后返回该字符串,以可选参数kcode来设定字符串的字符编码。

    Regexp.quote("a")
    =>a
    Regexp.quote("\a")
    =>"\a"

    Regexp.last_match
    返回当前范围内的最后一次正则表达式匹配的MatchData对象。调用该方法与调用$~是一样的。

    Regexp.last_match([nth]) 
    若整数nth为0,则返回匹配的字符串($&)。除此以外,则返回与第nth个括号相匹配的部分字符串($1,$2,...)。若没有相应的括号或未完成匹配,则返回nil。

    /(.)(.)/ =~ "ab"
    Regexp.last_match       
    => #<MatchData: "ab" 1:"a" 2:"b">
    Regexp.last_match[0]   
    => "ab"
    Regexp.last_match[1]   
    => "a"
    Regexp.last_match[2]   
    => "b"
    Regexp.last_match[3]   
    => nil

    Regexp.union([pattern, ...])
    用|将传给参数的pattern连起来之后,以Regexp的形式将其返回。只要与其中的一个pattern相匹配,就意味着与Regexp相匹配。

    Regexp.union("a", "b", "c")
    => /a|b|c/
    Regexp.union("a", "b", "c")=~"c"
    =>0
    $~
    =>#<MatchData: "c">
    $~[0]
    =>"c"

    实例方法

    self =~ string
    self = = = string
    与string字符串进行正则表达式的匹配操作。若匹配成功则返回匹配位置的索引(首位为0)。若匹配失败或者string为nil时,返回nil。内部变量$~中保存的是与匹配相关的信息。


    ~ self
    与$_变量的值之间进行匹配操作。等同于self =~ $_

    casefold?
    若编译正则表达式时不区分大小写,则返回真。

    kcode
    采用与$KCODE相同的形式返回编译正则表达式时的字符编码。若编译正则表达式时没有固定的编码(使用匹配时的$KCODE的值)时,返回nil。

    match(str)
    match(str, [pos])
    除去返回MatchData对象这点区别以外,它与self =~ str是相同的。匹配失败时返回nil。

    Regexp.union("a", "b", "c").match("a")
    =>#<MatchData: "a">

    若使用了第二可选参数 pos 的话,将从 pos 所指位置开始进行匹配(pos的默认值为0)。

    /(.).(.)/.match("test", 2)  
    =>#<MatchData: "st" 1:"s" 2:"t"> 

    options
    返回生成正则表达式时的选项。返回值是Regexp::EXTENDED、Regexp::IGNORECASE和Regexp::MULTILINE间的任意组合。

    Regexp.union("a", "b", "c").options
    =>-1

    source
    生成并返回正则表达式的原本的字符串形式。

    Regexp.union("a", "b", "c").source
    =>"a|b|c"

    to_s 
    生成并返回正则表达式的字符串形式

    Regexp.union("a", "b", "c").to_s
    =>"<?-mix:a|b|c>"



    正则表达式


    \  
    将下一个字符标记为一个特殊字符. 例如,“\n”匹配一个换行符。串行“\\”匹配“\”。

    ^
    匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性,^也匹配“\n”或“\r”之后的位置。

    $
    匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性,$也匹配“\n”或“\r”之前的位置。

    *
    匹配前面的子表达式零次或多次。例如,zo*能匹配“z”以及“zoo”。

    +
    匹配前面的子表达式一次或多次。例如,“zo+”能匹配“zo”以及“zoo”,但不能匹配“z”。

    ?
    匹配前面的子表达式零次或一次。例如,“do(es)?”可以匹配“does”或“does”中的“do”。

    {n}
    n是一个非负整数。匹配确定的n次。例如,“o{2}”不能匹配“Bob”中的“o”,但是能匹配“food”中的两个o。

    {n,}
    n是一个非负整数。至少匹配n次。例如,“o{2,}”不能匹配“Bob”中的“o”,但能匹配“foooood”中的所有o。

    {n,m}
    m和n均为非负整数,其中n<=m。最少匹配n次且最多匹配m次。例如,“o{1,3}”将匹配“fooooood”中的前三个o。

    ?
    当该字符紧跟在任何一个其他限制符(*,+,?,{n},{n,},{n,m})后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串“oooo”,“o+?”将匹配单个“o”,而“o+”将匹配所有“o”。

    .
    匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符,请使用像“(.|\n)”的模式。

    (pattern)
    匹配pattern并获取这一匹配。要匹配圆括号字符,请使用“\(”或“\)”。

    (?:pattern)
    匹配pattern但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。
    例如“industr(?:y|ies)”就是一个比“industry|industries”更简略的表达式.

    (?=pattern)
    正向肯定预查,在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。
    例如,“Windows(?=95|98|NT|2000)”能匹配“Windows2000”中的“Windows”,但不能匹配“Windows3.1”中的“Windows”。

    (?!pattern)
    正向否定预查,在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。
    例如“Windows(?!95|98|NT|2000)”能匹配“Windows3.1”中的“Windows”,但不能匹配“Windows2000”中的“Windows”。

    (?<=pattern)
    反向肯定预查,与正向肯定预查类拟,只是方向相反。
    例如,“(?<=95|98|NT|2000)Windows”能匹配“2000Windows”中的“Windows”,但不能匹配“3.1Windows”中的“Windows”。

    (?<!pattern)
    反向否定预查,与正向否定预查类拟,只是方向相反。
    例如“(?<!95|98|NT|2000)Windows”能匹配“3.1Windows”中的“Windows”,但不能匹配“2000Windows”中的“Windows”。

    x|y
    匹配x或y。例如,“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。

    [xyz]
    字符集合。匹配所包含的任意一个字符。例如,“[abc]”可以匹配“plain”中的“a”。

    [^xyz]
    负值字符集合。匹配未包含的任意字符。例如,“[^abc]”可以匹配“plain”中的“p”。

    [a-z]
    字符范围。匹配指定范围内的任意字符。例如,“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。

    [^a-z]
    负值字符范围。匹配任何不在指定范围内的任意字符。例如,“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。

    \b
    匹配一个单词边界,也就是指单词和空格间的位置。例如,“er\b”可以匹配“never”中的“er”,但不能匹配“verb”中的“er”。

    \B
    匹配非单词边界。“er\B”能匹配“verb”中的“er”,但不能匹配“never”中的“er”。

    \cx
    匹配由x指明的控制字符。例如,\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则,将c视为一个原义的“c”字符。

    \d
    匹配一个数字字符。等价于[0-9]。

    \D
    匹配一个非数字字符。等价于[^0-9]。

    \f
    匹配一个换页符。等价于\x0c和\cL。

    \n
    匹配一个换行符。等价于\x0a和\cJ。

    \r
    匹配一个回车符。等价于\x0d和\cM。

    \s
    匹配任何空白字符,包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

    \S
    匹配任何非空白字符。等价于[^ \f\n\r\t\v]。

    \t
    匹配一个制表符。等价于\x09和\cI。

    \v
    匹配一个垂直制表符。等价于\x0b和\cK。

    \w
    匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。

    \W
    匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。

    \xn
    匹配n,其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。
    例如,“\x41”匹配“A”。“\x041”则等价于“\x04&1”。正则表达式中可以使用ASCII编码。.

    \num
    匹配num,其中num是一个正整数。对所获取的匹配的引用。例如,“(.)\1”匹配两个连续的相同字符。

    \n
    标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式,则n为向后引用。否则,如果n为八进制数字(0-7),则n为一个八进制转义值。

    \nm
    标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式,则nm为向后引用。如果\nm之前至少有n个获取,则n为一个后跟文字m的向后引用。如果前面的条件都不满足,若n和m均为八进制数字(0-7),则\nm将匹配八进制转义值nm。

    \nml
    如果n为八进制数字(0-3),且m和l均为八进制数字(0-7),则匹配八进制转义值nml。

    \un
    匹配n,其中n是一个用四个十六进制数字表示的Unicode字符。例如,\u00A9匹配版权符号(©)。


    常用正则表达式

    用户名
    /^[a-z0-9_-]{3,16}$/

    密码
    /^[a-z0-9_-]{6,18}$/

    十六进制值
    /^#?([a-f0-9]{6}|[a-f0-9]{3})$/

    电子邮箱
    /^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/
    /^[a-z\d]+(\.[a-z\d]+)*@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/

    URL
    /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/

    IP 地址
    /((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)/

    /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/

    HTML 标签
    /^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/

    删除代码\\注释
    (?<!http:|\S)//.*$

    Unicode编码中的汉字范围
    /^[\u2E80-\u9FFF]+$/







  • Ruby语言入门(20)- 内部类 -Range

    2013-02-06 13:36:04

    Range类是范围对象的类。范围对象是由范围操作符..或...生成的。由..操作符生成的范围对象包括范围终点,而由...操作符生成的范围对象不包括范围终点。

    for i in 1..5 (range)
       ...
    end


    Range.new(first,last[, exclude_end])
    生成并返回一个从first到last的范围对象。若exclude_end为真,则该对象不包含范围终点。若省略exclude_end,则包含范围终点。生成对象时,会执行 first <=> last 以检查参数的合法性。

    Range.new(1,5)
    =>1..5
    Range.new(1,5,true)
    =>1...5
    Range.new(1,5,false)
    =>1..5

    self === other
    include?(other) 
    若other在范围内则返回真。===主要用在case句的比较中.

    r1=Range.new(1,5)
    r1 === 2
    =>true
    r1.include?(5.1)
    =>false

    比较字符串时,include?将按照字典顺序进行比较
    ("a" .. "c").include?("ba") 
    => true
    ("a" .. "c").member?("ba")
    => false

    begin
    first
    返回最初的元素。

    r1.begin
    =>1

    each {|item| ... }
    对范围内的元素进行迭代操作。

    r1.each{|n| puts n}
    1
    2
    3
    4
    5
    =>1..5

    end
    last
    返回范围终点。这与范围对象是否包含范围终点无关。

    (1..5).end   
    => 5
    (1...5).last  
    => 5

    exclude_end?
    范围对象不包含范围终点时返回真。


    (1..5).exclude_end? 
    => false
    (1...5).exclude_end?
    => true

    step([s]) {|item| ... }
    以s的步长对范围内的元素进行迭代操作。s是正整数。默认值为1。

    (1..5).step(2) {|n| puts n}
    1
    3
    5
    =>1..5

    (1...5).step(2) {|n| puts n}
    1
    3
    =>1...5


  • Ruby语言入门(19)- 内部类 -Numeric

    2013-02-05 16:07:21

    Numeric是数值的抽象类.包含Integer和Float类。
    Integers是整数的抽象类. 其子类包括Fixnum 和 Bignum.
    Float类是浮点数的类.

    方法有:

    self + other
    self - other
    self * other
    self / other
    self % other 余数(模)
    self ** other
    算术操作符

    self <=> other 
    self = = other
    self < other
    self <= other
    self > other
    self >= other
    比较操作符.

    ~ self
    self | other
    self & other
    self ^ other 异或
    位操作符. 

    self << bits
    self >> bits
    移位操作符. 向右(左)移动bits位.

    []
    返回数组

    [1.0]
    =>[1.0]

    + self 
    返回self

    +1
    =>1
    +-1
    =>-1

    - self 
    反转self的符号后将其返回.

    -1
    =>-1
    --1
    =>1

    abs 
    返回self的绝对值.

    -1.abs
    =>1

    ceil 
    返回一个等于或大于self的最小的整数.

    1.3.ceil
    =>2

    chr
    返回数字对应的字符.

    68.chr
    =>"D"

    coerce(number)
    将number变为可直接与自己进行计算的类型,然后将其存入形如[number, self]的数组并返回它.

    a=1
    a.coerce(2.0)
    =>[2.0, 1.0]

    div(other)
    返回self除以other的整数商.

    3.div(2) 
    => 1

    divmod(other)
    以数组[q, m]的形式返回self除以other所得的商(q)和余数(m).

    7.divmod(2) 
    => [3,1]

    downto(min) {|n| ... }
    循环起点为self,步长为-1,循环终点为min

    5.downto(1) {|n| puts n}
    5
    4
    3
    2
    1
    =>5

    eql?
    是否相等

    1.eql?(2)
    =>false

    floor
    返回一个不超过self的最大的整数.

    1.2.floor
    =>1
    1.2.ceil
    =>2

    finite?
    若某数值既非∞又非NaN则返回真

    1.0.finite?
    =>true

    hash
    返回数值的hash

    1.hash
    =>167445871

    infinite?
    若某数值为+∞则返回1, 若为-∞则返回-1, 除此以外返回nil.浮点数除以0得∞.

    1.0.infinite?
    =>nil

    integer?
    若self为整数则返回真.

    -1.ineger?
    =>true

    id2name (no method)
    返回与Symbol对象的整数值(可用Symbol#to_i获得该整数值)相对应的字符串. 若没有与整数相对应的符号的话就返回nil.

    modulo(other)
    返回self除以other后的余数m

    3.divmod(4)
    =>[0,3]
    3.modulo(4)
    =>3

    nan?
    当某数值为NaN(Not a number)时返回真. 浮点数的0除以0得NaN.

    1.0.nan?
    =>false

    next
    返回下一个紧跟的整数,等同于succ

    3.next
    =>4

    nonzero?
    0则返回nil,非0则返回self.

    1.nozero?
    =>1

    quo(other)
    除法运算,它会尽量返回一个接近实数商(quotient)的值.

    1.quo(3)
    =>(1/3)

    remainder(other)
    返回self除以other后的余数r

    3.divmod(1)
    =>[3,0]
    3.remainder(1)
    =>0

    round
    返回最接近self的整数.

    1.4.round
    =>1
    1.5.round
    =>2

    size
    返回所占的bit数

    1.size
    =>4
    22342342342342324.size
    =>8

    succ
    返回下一个紧跟的整数

    3.succ
    =>4

    times {|n| ... }
    循环self(从0到self-1)次

    5.times {|n| puts n}
    0
    1
    2
    3
    4
    =>5

    to_i
    to_int
    返回self的整数部分.

    1.3.to_int
    =>1

    to_f
    将数值变为浮点数(Float).

    1.to_f
    =>1.0

    to_s
    to_s(base)
    将整数变为10进制字符串形式.如果带参数,以base为进制,从2-36,转换为字符

    10.to_s
    =>"10"
    10.to_s(2)
    =>"1010"

    to_sym (no method)
    返回与对象的整数值self相对应的Symbol对象

    truncate
    舍弃小数点后面的部分.

    1.3.truncate
    =>1

    zero?
    若为0则返回真.

    1.3.zero?
    =>false

    step(limit) {|n| ... } 
    step(limit, step) {|n| ... } 
    循环执行块的内容,循环起点是self,步长为step,终点是limit. 同时,step也可以是负数(缺省设置为1).另外,limit和step还可以是Float等.

    1.1.step(1.5, 0.1) {|n| puts n}
    1.1
    1.2
    1.3
    1.4
    1.5

    upto(max) {|n| ... }
    循环起点为self,步长为1,循环终点为max.

    0.upto(5) {|n| puts n}
    0
    1
    2
    3
    4
    5
    =>0

    大多数与数值有关的方法都会在子类中得到重新定义. 这一方面是为了提高效率,另一方面是因为在上级抽象类中无法定义具体细节所致. 请参考下表来了解一下到底各个类中有些什么方法.

  • Ruby语言入门(18)- 内部类 -MatchData

    2013-02-05 15:22:54

    MatchData为处理与正则表达式的匹配过程相关的信息而设置的类. 可以通过下列途径得到该类的实例:
    Regexp.last_match
    Regexp#match, String#match
    $~

    实例方法

    self[n]
    返回第n个子字符串. 0表示整个匹配部分. 若n为负值,则从尾部算起(末尾的元素是第-1个). 若不存在第n个元素则返回nil.

    /(this)(is)(a)(TEST)?/ =~ "thisisatest"
    $~.to_a       
    => ["thisisa", "this", "is", "a", nil]
    $~[0]         
    => "thisisa"
    $~[4]         
    => nil        (不匹配)
    $~[5]         
    => nil        (超出范围)
    $~[-2]        
    => "a"

    self[start..end]
    返回从start位置开始到end位置结束的字符串集合.

    $~[1..4]
    =>["this", "is","a", nil]

    self[start, length]
    返回从start位置开始长度为length的字符串集合.
    $~[1,4]
    =>["this", "is","a", nil]

    begin(n)
    返回第n个子字符串的首字符的偏移量(offset). 0表示整个匹配部分. 若n超出范围则引发IndexError异常. 若第n个子字符串没有匹配部分则返回nil.

    /(this)(is)(a)(TEST)?/ =~ "thisisatest"
    $~.to_a       
    => ["thisisa", "this", "is", "a", nil]
    $~.begin(0)
    =>0 
    $~.begin(1)
    =>0
    $~.begin(2)
    =>4 
    $~.begin(3)
    =>6 
    $~.begin(4)
    =>nil 

    end(n)
    返回第n个子字符串的尾字符的偏移量(offset). 0表示整个匹配部分. 若n超出范围则引发IndexError异常. 若第n个子字符串没有匹配部分则返回nil.

    /(this)(is)(a)(TEST)?/ =~ "thisisatest"
    $~.to_a       
    => ["thisisa", "this", "is", "a", nil]
    $~.end(0)
    =>7 
    $~.end(1)
    =>4 
    $~.end(2)
    =>6 
    $~.end(3)
    =>7 
    $~.end(4)
    =>nil

    captures 
    返回一个包含$1,$2,...的数组. 与to_a不同的是,它不含$&. 若群组没有匹配部分,则相应的数组元素为nil.

    /(this)(is)(a)(TEST)?/ =~ "thisisatest"
    $~.to_a       
    => ["thisisa", "this", "is", "a", nil]
    $&
    =>"thisisa"
    $~.captures
    =>["this", "is", "a", nil]

    length
    size
    返回子字符串的数量(与self.to_a.size相同).

    $~.size
    =>5

    offset(n)
    返回数组[start, end],它包含第n个子字符串的偏移量.

    $~.offset(1)
    =>[0,4]  ("this")

    post_match
    返回匹配部分之后的字符串(与$'相同).

    $~.post_match
    =>"test"

    pre_match
    返回匹配部分之前的字符串(与$`相同).

    /(is)(test)?/ =~ "thisistest"
    $~.pre_match
    =>"this"

    select { ... }
    与self.to_a.select { ... } 相同.

    string
    返回匹配对象的拷贝.返回的字符串已被冻结.

    $~.string
    =>"thisisatest"

    to_a
    返回包含$&,$1,$2,... 的数组。

    /(this)(is)(a)(TEST)?/ =~ "thisisatest"
    $~.to_a       
    => ["thisisa", "this", "is", "a", nil]

    to_s
    返回整个匹配部分.

    /(this)(is)(a)(TEST)?/ =~ "thisisatest"
    $~.to_s 
    =>"thisisa"


    values_at(index1, index2, ...)
    返回一个数组,它包括与正则表达式中第indexN个括号相匹配的子字符串. 与$&一样,第0个表示整个匹配部分.

    /(this)(is)(a)(TEST)?/ =~ "thisisatest"
    $~.values_at(1,2)
    =>["this", "is"]



  • Ruby语言入门(17)- 内部类 -File

    2013-02-05 14:08:23

    File类是访问文件用的类。通常使用open或File.open来生成。

    类方法

    File.atime(filename)
    File.ctime(filename)
    File.mtime(filename)
    它们分别返回:文件的最终访问时间/文件状态的最终变更时间/最终更新时间(Time对象)。

    File.atime("c:\\test.txt")
    =>2013-02-04 18:40:21 +0800
    File.ctime("c:\\test.txt")
    =>2013-02-04 16:33:08 +0800
    File.mtime("c:\\test.txt")
    =>2013-02-04 17:08:40 +0800

    File.basename(filename[, suffix])
    返回filename中的最后一条斜线后面的部分。若给出了参数suffix且它和filename的尾部一致时,该方法会将其删除并返回结果。

    File.basename("c:\\test.txt")        
    => "test.txt"
    File.basename("c:\\test.txt", "txt")  
    => "test."
    File.basename("c:\\test.txt", ".*")  
    => "test"
    File.basename("c:\\test.txt", ".")  
    => "test.txt"

    File.dirname(filename)
    以字符串的形式返回filename中最后一条斜线之前的部分。若文件名中不含斜线,则返回"."(当前目录)。

    File.dirname("c:\\test.txt")        
    => "c:\\"

    File.extname(filename)
    返回文件名filename中的扩展名部分(跟在最后的"."之后的部分)。目录名中的"."和文件名头上的"."不会被看作扩展名的一部分。若filename中不含扩展名则返回空字符串。

    File.extname("c:\\test.txt")        
    => ".txt"
    File.extname("c:/test.txt")        
    => ".txt"
    File.extname("c:/test")        
    => ""

    (在windows的irb下,\\ 等同于 /)

    File.chmod(mode[, filename[, ...]])
    File.lchmod(mode[, filename[, ...]])
    将文件的模式改为mode。它返回修改文件的个数。lchmod只修改符号连接中的连接本身的模式。

    mode可以是:
    "r", RDONLY: 以读取模式打开文件.
    "w", WRONLY|CREAT|TRUNC: 以写入模式打开文件.打开文件时,若文件已存在就清空文件内容.
    "a", WRONLY|CREAT|APPEND: 以写入模式打开文件.通常把写入内容添加到文件结尾.

    若有"+"的话,就以读写两用模式(RDWR)打开文件.
    "r+": 将文件的读写位置设在开头.
    "w+": 与"r+"一样.打开文件时,若文件已存在就清空其内容.
    "a+": 与"r+"一样.打开文件时,若文件已存在,就把读写位置设在文件结尾.


    File.chown(owner, group[, filename[, ...]])
    File.lchown(owner, group[, filename[, ...]])
    修改文件的owner和group。只有超级用户才能修改文件的owner和group。它返回修改文件的个数。lchown只修改符号连接中的连接本身的owner和group。

    File.delete(filename ... )
    File.unlink(filename ... )
    删除文件。返回删除文件的个数。该方法是用来删除普通文件的。而删除目录时要使用Dir.rmdir。

    File.delete("c:\\test.txt")
    =>1
    File.delete("c:\\test.txt", "c:\\test1.txt", "c:\\test2.txt")
    =>3

    File.expand_path(path[, default_dir])
    将path展开为绝对路径后返回该路径字符串。若path是相对路径则以default_dir为基准进行扩展。若没有default_dir或其值为nil时将使用当前目录。

    File.expand_path(("c:/test.txt")
    =>"c:/test.txt"
    File.expand_path((".")
    =>"c:/Sites"
    File.expand_path(("..")
    =>"c:/"

    File.fnmatch(pattern, path[, flags])
    File.fnmatch?(pattern, path[, flags])
    对文件名进行模式匹配(fnmatch(3))。若path与pattern相匹配则返回真。

    File.fnmatch("*", "c:/test.txt")
    =>true
    File.fnmatch("c:/*", "c:/test.txt")
    =>true
    File.fnmatch("c:/", "c:/test.txt")
    =>false

    flags中可以任意使用下列常数(定义在File::Constants模块中)中的若干个来改变模式匹配的运作情况。flags的默认值为0(不指定标识)。

    FNM_NOESCAPE 将转义字符`\'看作普通字符。
    File.fnmatch('\*', '\a')                       
    => false
    File.fnmatch('\*', '\a', File::FNM_NOESCAPE)  
    => true

    FNM_PATHNAME 通配符'*', '?', '[]'将不再匹配'/'
    FNM_CASEFOLD 进行匹配时,不区分大小写字母
    FNM_DOTMATCH 通配符'*', '?', '[]'将匹配于开头的'.'

    File.ftype(filename)
    返回表示文件类型的字符串。该字符串应为下列之一:
    "file"
    "directory"
    "characterSpecial"
    "blockSpecial"
    "fifo"
    "link" (若为符号连接则返回"link")。
    "socket"
    "unknown"

    File.ftype("c:/test.txt")
    =>"file"
    File.ftype("c:")
    =>"directory"

    File.join(item, item, ...)
    将File::SEPARATOR置入其中连成字符串

    a="c:/"
    b="test.txt"
    c=File.join(a, b)
    =>"c:/test.txt"

    File.link(old, new)
    生成一个指向old且名为new的硬连接(hard link)。old必须是现存的。

    File.link("c:/test.txt", "c:/test1.txt")
    =>0
    (在c:下生成新文件test1.txt)

    File.new(path[, mode [, perm]])
    File.open(path[, mode [, perm]])
    File.open(path[, mode [, perm]]) {|file| ... }
    打开path所指文件并返回文件对象。

    mode可以是:
    "r", RDONLY: 以读取模式打开文件.
    "w", WRONLY|CREAT|TRUNC: 以写入模式打开文件.打开文件时,若文件已存在就清空文件内容.
    "a", WRONLY|CREAT|APPEND: 以写入模式打开文件.通常把写入内容添加到文件结尾.

    若有"+"的话,就以读写两用模式(RDWR)打开文件.
    "r+": 将文件的读写位置设在开头.
    "w+": 与"r+"一样.打开文件时,若文件已存在就清空其内容.
    "a+": 与"r+"一样.打开文件时,若文件已存在,就把读写位置设在文件结尾.

    File.readlink(path)
    以字符串形式返回字符连接的连接对象。


    File.rename(from, to)
    修改文件名称。若目录不同时,将进行移动

    File.split(pathname)
    将pathname分为dirname和basename,并返回一个包含这两部分的数组

    File.split("c:/test.txt")
    =>["c:","test.text"]

    File.stat(filename)
    File.lstat(filename)
    生成并返回一个包含filename信息的File::Stat对象。

    File.symlink(old, new)
    生成一个指向old且名为new的符号连接。

    File.truncate(path, length)
    将path所指文件裁减为至多length字节的文件。

    File.umask([umask])
    修改umask。返回修改前的umask值。若省略umask则不修改,返回当前的umask值。

    File.utime(atime, mtime[, filename[, ...]])
    修改文件的最终访问时间和更新时间。返回修改的文件数。

    File.blockdev?(path)
    File.chardev?(path)
    File.directory?(path)
    File.executable?(path)
    File.executable_real?(path)
    File.exist?(path)
    File.file?(path)
    File.grpowned?(path)
    File.owned?(path)
    File.pipe?(path)
    File.readable?(path)
    File.readable_real?(path)
    File.setgid?(path)
    File.setuid?(path)
    File.size(path)
    File.size?(path)
    File.socket?(path)
    File.sticky?(path)
    File.symlink?(path)
    File.writable?(path)
    File.writable_real?(path)
    File.zero?(path)
    判断指定文件的一些属性和判断。

    实例方法

    atime
    ctime
    mtime
    它们分别返回:文件的最终访问时间/文件状态的最终变更时间/最终更新时间

    myfile = File.new("c:/test.txt")
    myflie.atime
    =>2013-02-04 18:40:21 +0800

    chmod(mode)
    将文件模式修改为mode.若修改成功则返回0.

    myfile.chmod(112211)
    =>0

    chown(owner, group)
    修改文件的owner和group.只有超级用户才能修改文件的owner和group.修改成功则返回0.

    myfile.chown(1, 223)
    =>0

    flock(operation)
    锁定文件. 锁定成功时返回0.可用的operation列表:
    LOCK_SH 共享锁. 若干个进程可同时共享锁定.
    LOCK_EX 排它锁.在某时刻,只有一个进程能控制锁.
    LOCK_UN 解锁.
    LOCK_NB 非阻塞模式.

    myfile.flock(File::LOCK_SH)
    =>0

    path
    以字符串形式返回打开文件时使用的路径.

    myfile.path
    =>"c:/test.txt"

    lstat
    生成并返回一个包含文件状态信息的File::Stat对象

    myfile.lstat
    => #<File::Stat dev=0x0 ..... +0800?

    truncate(length)
    将文件裁剪成至多length字节大小的文件.

    myfile.truncate(10240)
    =>0

    常数:

    ALT_SEPARATOR
    当系统的文件路径分隔符与SEPARATOR不同时,即可使用该常数.在MS-DOS等系统中是"\",而在UNIX 或Cygwin等系统中则是nil.

    PATH_SEPARATOR
    PATH环境变量的元素分隔符.在UNIX中是":",而在MS-DOS等系统中是";".

    SEPARATOR
    Separator
    文件路径的分隔符. 例如,在将路径名传给处理文件的方法时就会用到它. 该分隔符使得脚本内的路径名的格式统一且不受环境的影响.其值为"/".

    File::PATH_SEPARATOR
    =>";"


  • Ruby语言入门(16)- 内部类 -IO

    2013-02-04 16:29:26

    IO类实现了基本的输出输入功能。

    IO.new(fd[, mode])
    IO.for_fd(fd[, mode]) 
    IO.open(fd[, mode]) 
    IO.open(fd[, mode]) {|io| ... } 
    生成并返回一个全新的IO对象,它对应于已打开的文件描述符fd。

    IO.for_fd与IO.new相同。IO.open稍有不同,因为它可以带块(块运行结束时fd会被关闭)。带块的IO.open返回块的结果。其他的返回生成的IO对象。

    IO.foreach(path[, rs]) {|line| ... }
    对path所指文件的各行内容进行迭代操作(与open一样,若path以"|"开头的话则读取命令输出)。


    IO.pipe
    执行pipe(2)后返回一个数组,该数组包括2个互联的IO对象。返回数组中的首元素负责读取,第二个元素负责读入。

    pipe = IO.pipe    
    => [#<IO:fd 3>, #<IO:fd 4>]
    pipe[1].puts "test"
    pipe[0].gets      
    => "test\n"

    IO.popen(command [, mode])
    IO.popen(command [, mode]) {|io| ... }
    将command作为子进程来运行,然后建立一条连接到该进程的输入输出的管线(pipeline)。

    io = IO.popen("cat", "r+")  
    => #<IO:fd 7>
    io.puts "test"
    io.gets  
    => "test\n"

    若带块时,将以生成的IO对象为参数来运行该块,并返回其结果。在块得到运行以后,生成的管道将会自动关闭。

    IO.popen("cat", "r+") {|io|
      io.puts "test"
      io.gets
    }
    => "test\n"

    当命令名为"-"时,Ruby将运行fork(2)来建立一个连接到子进程的输入输出的管线。

    不带块的例子

    io = IO.popen("-", "r+")
    if io.nil?
      # child
      s = gets
      print "child output: " + s
      exit
    end

    # parent
    io.puts "test"
    puts io.gets                   
    => "child output: test\n"
    io.close

    带块的例子

    p IO.popen("-", "r+") {|io|
      if io
        # parent
        io.puts "test"
        io.gets
      else
        # child
        s = gets
        puts "child output: " + s
      end
    }
    => "child output: test\n"

    IO.read(path,[length,[offset]]) 
    在path所指文件中,从offset位置开始读入length字节的内容并将其返回。

    IO.read("c:\\test.txt")
    =>"test1\ntest2\ntest3\n"

    IO.readlines(path[, rs])
    读入path所指文件的全部内容后,以行为单位将其转化为数组并返回该数组。

    IO.readlines("c:\\test.txt")
    =>["test1\n","test2\n","test3\n"]

    IO.select(reads[, writes[, excepts[, timeout]]])
    执行select(2)。传递给reads/writes/excepts的是等待输入的IO(或其子类)的实例的数组。


    IO.sysopen(path[, mode [, perm]]) 
    打开path所指文件并返回文件描述符。

    newfile = IO.systemopen("c:\\test.txt","r+")
    =>3
    newff = IO.new(newfile)
    =>#<IO:fd 4>

    self << object
    输出object。可以像下面这样使用一连串的<<:

    newfile = IO.systemopen("c:\\test.txt")
    =>3
    newff = IO.new(newfile, "a+")
    =>#<IO:fd 4>
    newff <<1<<"test"<<"\n"

    binmode
    将流变为二进制模式。

    new1 = newff.binmode

    clone
    dup
    返回一个全新的IO对象,该对象与receiver使用同一个IO

    new2 = newff.clone

    close
    关闭输入输出端口。

    new2.close


    close_read
    关闭读取用的IO。主要用在管道或读写两用的IO对象上。

    new2.close_read

    close_write
    关闭写入用的IO。

    new2.close_write

    closed?
    若端口已被关闭则返回真。

    new.closed?

    each([rs]) {|line| ... }
    each_line([rs]) {|line| ... }
    每次从IO端口读入1行来进行相关处理的迭代器。

    each_byte {|ch| ... }
    每次从IO端口读入1字节的内容。

    eof
    eof?
    若流(stream)到达文件末端时返回真.

    fcntl(cmd[, arg])
    将对IO执行系统调用fcntl(2)。

    fsync
    对写入用的IO执行系统调用fsync(2).

    fileno
    to_i
    返回文件描述符的号码。

    newfile.fileno
    =>2

    flush
    刷新IO端口的内部缓冲区。 

    newfile.flush

    getc
    从IO端口读入1个字符,并返回该字符对应的Fixnum。

    gets([rs])
    读入一行,若成功的话就返回读入的字符串。

    ioctl(cmd[, arg])
    对IO执行系统调用ioctl,并返回其结果。

    isatty
    tty?
    若输出输入端口已与tty结合时,返回真。

    lineno
    返回当前的行号。

    lineno=number
    设定行号。

    pid
    若是由IO.popen所生成的IO端口时,则返回子进程的进程ID。除此以外返回nil。

    pos
    tell
    返回文件指针的当前位置。

    pos = n
    将文件指针移动到指定位置。与io.seek(pos, IO::SEEK_SET)相同。

    print([arg[, ...]])
    依次将参数输出到IO端口。

    printf(format[, arg[, ...]])
    按照format将参数变为字符串,然后输出到self。

    putc(ch)
    输出字符ch到self。

    puts([obj[, ...]])
    输出各个obj到self然后换行。

    read([length])
    read([length[, buf]])
    若给出了length时,就读取length字节的内容,然后返回该字符串。

    若将某字符串传给第二参数的话,将使用读入的数据来覆盖该字符串对象,并返回读入的数据。

    buf="x"*20
    =>"xxxxxxxxxxxxxxxxxxxxx"
    io=File.open("c:\\test.txt")
    io.read(10,buf)
    buf
    =>"test"

    readchar
    与IO#getc一样,读入1个字符后返回与该字符相对应的Fixnum。

    readline([rs])
    与IO#gets一样,读入1行后返回读入的字符串.使

    readlines([rs])
    读入所有数据后,以行为单位将其转化为数组,并返回该数组。

    readpartial(maxlen[, outbuf])
    从IO读入最多maxlen的数据,并返回读入的字符串。

    reopen(io)
    reopen(name[, mode])
    将自身转接到io上.若第一参数为字符串时,将把流转接到name所指的文件上。第二参数的默认值为"r"。若省略第二参数时,将原封不动地继承self的模式。

    rewind
    将文件指针移动到头部。IO#lineno变为 0 。

    seek(offset[, whence])
    将文件指针由whence移动到offset。whence的值是下列之一。
    • IO::SEEK_SET: 从文件头部开始(默认)
    • IO::SEEK_CUR: 从当前文件指针开始
    • IO::SEEK_END: 从文件尾部开始
    • 省略whence时,其默认值为IO::SEEK_SET。

    stat
    生成并返回一个包含文件状态的File::Stat对象。

    sync
    以真和伪来表示当前的输出同步模式。当输出同步模式为真时,每次调用输出函数时都会刷新缓冲区。

    sync=newstate
    设定输出同步模式。newstate为真则表示同步模式,伪则表示非同步模式。

    sysread(length)
    sysread(length[, buf]) 
    使用read(2)进行输入,并返回包含输入数据的字符串.

    sysseek(offset[, whence]) 
    与lseek(2)相同

    yswrite(string)
    使用write(2)来输出string。若string并非字符串,将使用to_s尝试将其变为字符串。

    to_io
    返回self。

    ungetc(char)
    送回(unreading)char

    write(str)
    对IO端口输出str。若str并非字符串,将使用to_s尝试将其变为字符串。

    常数:
    SEEK_CUR
    SEEK_END
    SEEK_SET

    newfile.SEEK_CUR
    newfile.SEEK_END
    newfile.SEEK_SET
  • Ruby语言入门(15)- 内部类 -Hash

    2013-02-04 15:12:48

    哈希表(也叫散列表)的类.通过哈希表,您可以将一个任意类型的对象同另一个任意类型的对象联系起来.

    可以使用下列哈希表表达式来生成哈希表: {a=>b, ... } (key=>value)

    通常使用Object#hash方法来计算哈希表的值,而使用Object#eql?方法来判定索引是否相同.

    Hash[key,value,...]
    Hash[hash]
    生成新的哈希表.使用第一种形式时,参数的个数必须是偶数.(奇数位参数是索引,偶数位参数是元素值).使用第二种形式(将一个哈希表对象指定给参数)时, 将生成并返回一个与指定哈希表相同的全新的哈希表.(生成的哈希表的默认值为nil.)

    以下是从数组生成哈希表的方法示例:

    由[索引, 值, ...] 型的数组变为哈希表
    ary = [1,"a", 2,"b", 3,"c"]
    puts Hash[*ary]
    => {1=>"a", 2=>"b", 3=>"c"}
    puts Hash[ary]
    =>{}

    由索引和值配对出现的数组变为哈希表
    alist = [[1,"a"], [2,"b"], [3,"c"]]
    puts Hash[*alist.flatten]
    => {1=>"a", 2=>"b", 3=>"c"}

    由索引数组和值数组配对生成哈希表
    keys = [1, 2, 3]
    vals = ["a", "b", "c"]
    alist = keys.zip(vals)   # 或 alist = [keys,vals].transpose
    puts Hash[*alist.flatten]
    => {1=>"a", 2=>"b", 3=>"c"}

    无法使用上述的方法时:
    h = Hash.new
    alist = [[1,["a"]], [2,["b"]], [3,["c"]]]
    alist.each {|k,v|
      h[k] = v
    }
    puts h
    => {1=>["a"], 2=>["b"], 3=>["c"]}

    Hash.new([ifnone])
    Hash.new {|hash, key| ...} 
    生成一个全新的空哈希表.若索引没有对应值时,其默认值为ifnone.若指定了块时,则块的计算值将成为默认值.每当调用无值的哈希表元素时,都会对块进行计算,然后返回其结果.而调用哈希表时的索引将被传递给该块.

    若没有使用块时, 改变默认值将会影响到其他的值
    h = Hash.new("foo")
    puts h[1]                  # => "foo"
    puts h[1] << "bar"         # => "foobar"
    puts h[1]                  # => "foobar"
    puts h[2]                  # => "foobar"

    若使用块的话,不会出现这种问题
    h = Hash.new {|hash, key| hash[key] = "foo"}
    puts h[1]                  # => "foo"
    puts h[1] << "bar"         # => "foobar"
    puts h[1]                  # => "foobar"
    puts h[2]                  # => "foo"

    self[key]
    返回索引为key的哈希表元素的值.若该索引并未注册,则返回默认值(若未设定则为nil).若想区分该nil到底是默认值还是哈希表元素值时,请使用fetch.

    h = Hash.new {|hash, key| hash[key] = "foo"}
    puts h[1]
    =>"foo"

    self[key]=value
    store(key,value)
    将索引为key的元素值设为value.返回value.

    h[2]="fool"
    h[2]
    =>"fool"
    h.store(3,"test")
    h[3]
    =>"test"

    clear
    清空哈希表的内容. 返回self.

    h.clear
    =>{}

    clone
    dup
    返回一个与receiver内容一致的新哈希表. 对冻结的哈希表进行clone时将返回一个同样的冻结的哈希表.但使用dup时,将返回内容相同但却并未冻结的哈希表.

    b=h.clone
    b[1]
    =>"foo"

    default
    default([key])
    返回哈希表的默认值.

    h.default
    =>nil
    h.default("123")
    =>foo
    h("123")
    ="foo"

    default=value
    将哈希表的默认值设为value.若使用无对应值的索引进行搜索时,将返回该值.

    h.default="test"
    h.default
    =>"test"
    h[10]
    =>"test"

    default_proc
    返回一个Proc对象,该对象负责返回哈希表的默认值.若没有默认的Proc时将返回nil.

    h = Hash.new {|h, k| }
    puts h.default_proc        
    => #<Proc:0x0x401a9ff4>

    h = Hash.new(1)
    puts h.default_proc        
    => nil

    delete(key)
    delete(key) {|key| ... }
    删除索引key与对应元素之间的关系.返回被删除的值.若没有值与key相对应,则返回nil.若给出块的话,将在key匹配失败时对块进行计算,然后返回其结果.

    h
    => {1=>"test",2="test",3=>"test"}
    h.delete(2)
    h
    => {1=>"test",3=>"test"}

    reject {|key, value| ... }
    拷贝self之后对块进行计算,若计算值为真则删除相应的哈希表元素,最后返回该哈希表.

    delete_if {|key, value| ... }
    reject! {|key, value| ... }
    把key和value当做参数来计算块,若计算值为真则删除相应的元素.通常delete_if返回self. reject!就有所不同,若未删除元素时返回nil,除此之外则返回self.


    each {|key, value| ... }
    each_pair {|key, value| ... }
    以key和value为参数对块进行计算.返回self.

    {:a=>1, :b=>2}.each_pair {|k, v| puts [k, v]}

    => [:a, 1]
       [:b, 2]

    each_key {|key| ... }
    以key为参数来计算块.返回self.

    each_value {|value| ... }
    以value为参数来计算块.返回self.

    empty?
    若哈希表为空则返回真.

    fetch(key[, default])
    fetch(key) {|key| ... }
    返回与索引key对应的元素的值.若该索引未被注册则分为两种情况: 若给出了参数default的话,就返回它的值;若给出了块时,将返回块的计算值

    has_key?(key)
    include?(key)
    key?(key)
    member?(key)
    若key是哈希表的索引则返回真.

    has_value?(value)
    value?(value)
    若value是哈希表的元素值则返回真.对值进行判断时使用==操作符

    index(val)
    返回与val对应的索引.若无法对应时返回nil.若有若干个对应的索引时,则会随机地返回其中之一.

    invert
    将元素值和索引互换,返回变换后的哈希表.
    h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
    h.invert
    => {200=>"d", 300=>"y", 0=>"a", 100=>"n"}

    keys
    返回一个包含所有索引的数组.

    length
    size
    返回哈希表中的元素的个数.

    merge(other)
    merge(other) {|key, self_val, other_val| ... }
    merge!(other)
    merge!(other) {|key, self_val, other_val| ... }
    合并两个hash表。当self和other中包含相同索引时将按照下列两种方式来处理: 若带块则调用该块,然后由用户选择使用哪个值;不带块的话则通常使用other的值.

    rehash
    重新计算索引对应的哈希表值。当与索引对应的哈希表值发生变化时,若不使用该方法来重新计算的话,将无法取出与索引对应的哈希表值。

    replace(other)
    以other的内容来替换哈希表的内容。返回self。

    shift
    删除一个哈希表元素后,再以[key,value]数组的形式将其返回。

    to_a
    生成并返回一个数组,数组中的元素也是数组,且由[key,value]构成。

    to_hash
    返回self。

    update(other)
    update(other) {|key, self_val, other_val| ... } 
    合并哈希表的内容。若出现相同索引时,将使用other中对应的元素值。若给出了块的话,每当遇到相同索引时都会对块进行计算,然后以块的计算值作为该索引的对应值。此时,索引、self[key] 和other[key]将被作为参数传递给该块。

    foo = {1 => 'a', 2 => 'b', 3 => 'c'}
    bar = {1 => 'A', 2 => 'B', 3 => 'C'}
    p foo.dup.update(bar)                   
    => {1=>"A", 2=>"B", 3=>"C"}
    p foo.dup.update(bar) {|k,v| v}         
    => {1=>"a", 2=>"b", 3=>"c"}

    values
    返回一个包括哈希表中的所有元素值的数组。

    values_at(key_1, ... , key_n)
    返回一个数组,该数组包括与参数所指索引相对应的哈希表元素值。若没有与索引相对应的哈希表元素值时,将使用default的值。与indexes以及indices相同。


  • Ruby语言入门(14)- 内部类 -File::Stat

    2013-02-04 14:40:16

    File::Stat 是保存文件信息的对象的类.

    生成方法:

    File::Stat.new(path)
    生成并返回一个关于path的File::Stat对象. 

    afile=File::Stat.new("c:\\test.jpg")
    => $<Fiel::Stat dev=0x2.........+0800>

    File::Stat
    生成并返回一个File::Stat对象. 

    bfile=File::Stat
    =>File::Stat
    cfile=b.new("c:\\test.jpg")
    => $<Fiel::Stat dev=0x2.........+0800>

    self <=> other
    比较文件的最终更新时间.若self比other新就返回正数,相等就返回0,旧则返回负数.

    afile<=>cfile
    =>0

    ftype
    返回一个表示文件类型的字符串.该字符串应是下列之一:
    • "file"
    • "directory"
    • "characterSpecial"
    • "blockSpecial"
    • "fifo"
    • "link"
    • "socket"
    • "unknown"
    afile.ftype
    =>"file"

    dev
    设备号(文件系统)

    afile.dev
    =>2

    dev_major
    dev的major号码部分

    afile.dev_major
    =>nil

    dev_minor 
    dev的minor号码部分

    afile.dev_minor
    =>nil

    ino
    i-node 号

    afile.ino
    =>0

    mode
    文件模式

    afile.mode
    =>33188

    nlink
    hard link数

    afile.nlink
    =>1

    uid
    owner的userID

    afile.uid
    =>0

    gid
    owner的groupID

    afile.gid
    =>0

    rdev
    设备类型

    afile.rdev
    =>2

    rdev_major
    rdev的major号码部分

    afile.rdev_major
    =>nil

    rdev_minor
    rdev的minor号码部分

    afile.rdev_minor
    =>nil

    size
    文件大小(以字节为单位)

    afile.size
    =>25780

    blksize
    理想的I/O的块大小

    afile.blksize
    =>nil

    blocks
    被分配的块数

    afile.blocks
    =>nil

    atime
    最终访问时间

    afile.atime
    =>2013-02-04 14:17:43 +0800

    mtime
    最终更新时间

    afile.atime
    =>2013-01-21 16:07:43 +0800

    ctime
    最终i-node变更时间

    afile.ctime
    =>2013-01-21 16:07:43 +0800


    下列判断方法等同于那些与FileTest同名的模块函数. 虽然它们的参数中使用的是文件名,但却对Stat本身进行判断.

    directory?
    若为目录则为真

    afile.directory?
    =>false

    readable?
    若可读则为真

    afile.readable?
    =>true

    readable_real?
    若实用户/实组可以读取就为真

    afile.readable_real?
    =>true

    writable?
    若可写则返回真

    afile.writable?
    =>true

    writable_real?
    若实用户/实组可以写入就为真

    afile.writable?
    =>true

    executable?
    若有效用户/组ID能执行就为真

    afile.executable?
    =>false

    executable_real?
    若实用户/组ID能执行就为真

    afile.executable_real?
    =>false

    file?
    若为普通文件则返回真

    afile.file?
    =>true

    zero?
    若大小为0就为真

    afile.file?
    =>false

    size?
    文件大小(若为0则为伪)

    afile.size?
    =>25780

    owned?
    若属于自己则为真

    afile.owned?
    =>true

    grpowned?
    若组ID与执行组ID相等则为真

    afile.grpowned?
    =>false

    pipe?
    若是带名称管道(FIFO)则为真

    afile.pipe?
    =>false

    symlink?
    若是符号连接则为真

    afile.symlink?
    =>false

    socket?
    若是socket则为真

    afile.socket?
    =>false

    blockdev?
    若是块专用文件则为真

    afile.blockdev?
    =>false

    chardev?
    若是字符专用文件则为真

    afile.chardev?
    =>false

    setuid?
    若被setuid则为真

    afile.setuid?
    =>false

    setgid?
    若被setgid则为真

    afile.setgid?
    =>false

    sticky?
    若设定了粘着位(sticky bit)则为真

    afile.sticky?
    =>false
  • Ruby语言入门(13)- 内部类 -Dir

    2013-02-04 13:25:26

    Dir类为实现目录流操作而设置的类,它可以依次返回目录中的元素。

    Dir[pattern]
    Dir.glob(pattern)
    Dir.glob(pattern) {|file| ...}
    Dir.glob(pattern[, flags]) 
    Dir.glob(pattern[, flags]) {|file| ...} 
    以字符串数组的形式返回通配符匹配结果。若指定了块的话,将以匹配成功的文件为参数,依次计算该块,然后返回nil。可以一次指定多个pattern,此时需要使用空白(space,tab,换行)或"\0"将它们分割开来。

    可用的通配符(pattern)如下。
    • * 匹配任何字符串,包括空字符串。
    • ? 匹配任何一个字符。
    • [ ] 只要匹配方括号中任何一个字符即可。若使用-则表示字符范围。若方括号中的首字符是^时,表示匹配^后的字符以外的任意字符。
    • { } 表示依次与括号内的字符进行组合。例如,foo{a,b,c}将变为fooa, foob, fooc,然后再依次进行匹配。括号可以嵌套。例如,{foo,bar{foo,bar}}表示将依次与foo, barfoo, barbar进行匹配。
    • **/ 表示通配符*/重复出现0次以上,这将对目录进行再归式地搜索。例如,foo/**/bar表示将依次对foo/bar, foo/*/bar, foo/*/*/bar ... (此后无限延伸)进行匹配。
    • 可使用反斜线对通配符进行转义处理。
    • 可以为第2可选参数指定一个类似于File.fnmatch中所使用的标识。
    Dir.getwd
    Dir.pwd
    返回当前目录的完整路径。

    Dir.chdir([path])
    Dir.chdir([path]) {|path| ... } 
    将当前目录改为path。若省略path时,则会调用环境变量HOME或LOGDIR。若它们中包含设定值时,就将当前目录改为它们的值。若当前目录变更成功就返回0,若失败则引发Errno::EXXX异常。若指定了块的话,则只会在块的执行过程中变更当前目录。

    Dir.pwd
    =>"c:/"
    Dir.chdir("c:\\Sites")
    =>0
    Dir.pwd
    =>"c:/Sites"


    Dir.chroot(path)
    将根目录改为path。只有超级用户才能改变根目录。您将无法还原到原来的根目录。根目录变更成功时返回0,失败时将引发Errno::EXXX异常。

    Dir.mkdir(path[, mode])
    生成新目录path.若成功生成新目录就返回0,若失败则引发Errno::EXXX异常。

    Dir.mkdir("c:\\test")
    =>0

    Dir.delete(path)
    Dir.rmdir(path)
    Dir.unlink(path)
    删除目录。目录必须为空。若删除成功则返回0,若失败则引发Errno::EXXX异常。

    Dir.delete("c:\\test")
    =>0

    Dir.entries(path)
    以数组形式返回path目录中所含的文件项名

    Dir.entries("c:\\Sites")
    =>[".", "..", "chromedriver.log", "todo"]

    Dir.foreach(path) {|file| ...}
    针对path目录中的元素的迭代器。

    Dir.new(path)
    Dir.open(path)
    Dir.open(path) {|dir| ...}
    打开并返回一个针对path的目录流。若打开失败则引发Errno::EXXX异常。open()方法可以带块。若带块调用时,将执行该块。当块的运行结束时,目录将被自动关闭。

    a=Dir.open("c:\\Sites")
    => #<Dir:c:\Sites>

    close
    关闭目录流。此后若再对目录进行操作则会引发IOError异常。若成功关闭则返回nil。若失败则引发IOError异常。

    a.close
    =>nil
    a.tell
    IOError: closed directory

    each {|item| ... }
    为目录中的各个元素计算块的内容。返回self。

    a.each {|item| puts item}
    .
    ..
    chromedriver.log
    todo
    => #<Dir:c:\Sites>

    path
    以字符串形式返回当前打开目录的路径名。

    a.path
    =>"c:\\Sites"

    pos
    tell
    以整数形式返回目录流的当前位置。

    a.pos
    =>4

    pos=(pos)
    seek(pos)
    将目录流的读入位置移动到pos。pos必须是使用Dir#tell所得到值。pos=返回右边,而seek则返回self。

    a.seek(2)
    => #<Dir:c:\Sites>
    a.tell
    => 2

    read
    从目录流中读出并返回下一个元素。若读到最后一个元素则返回nil。若读取目录失败则引发Errno::EXXX异常。

    a.read
    =>"chromedriver.log"

    rewind
    将目录流的读取位置移到开头。返回self。

    a.rewind
    => #<Dir:c:\Sites>
    a.tell
    =>0
  • Ruby语言入门(12)- 内部类 - Array

    2013-02-01 15:54:37

    数组的元素可以是任意的Ruby对象。包含的模块:Enumerable

    类生成方法有:

    Array[item,...]

    a=Array[1,2,3]
    =>[1,2,3]

    Array.new([size[, val]])

    a=Array.new(5,1)
    =>[1,1,1,1,1]

    Array.new(ary)

    b=Array.new(a)
    =>[1,1,1,1,1]
    a==b
    =>true

    Array.new(size) {|index| ... }

    a=Array.new(3){"test"}
    =>["test","test","test"]

    类的内置方法有:

    self[nth]
    返回第nth个数组元素。首元素算做第0个元素。若nth值为负,则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若第nth个元素不存在,则返回nil。

    a=Array[1,2,3]
    a[1]
    =>2
    a[-1]
    =>3

    self[start..end]
    以数组形式返回从第start个元素到第end个元素间的所有元素。若start值为负,则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若start的值超出数组范围则返回nil。若end的值超出数组长度时,超出的部分将被忽略。另外,若范围的起点比终点还大时,返回nil。

    a=Array[1,2,3]
    a[1..10]
    =>[2,3]
    a[-1..3]
    =>[3]

    self[start, length]
    以数组形式返回从第start个元素算起的length个数组元素。若start值为负,则看作是从尾部算起的索引值(尾元素算做第-1个元素)。若length超出从第start个元素算起的剩余长度时,超过部分将被忽略。若length为负,则返回nil。

    a=Array[1,2,3]
    a[1,4]
    =>[2,3]
    a[-1,2]
    =>[3]

    self[nth]=val
    将第nth个数组元素的值设定为val。若nth超出数组范围时,将自动加长数组并以nil对新增部分进行初始化。

    a=Array[1,2,3]
    a[6]=6
    a
    =>[1,2,3,nil,nil,6]

    self[start..end]=val
    将从第start个数组元素到第end个数组元素间的所有元素替换为val的内容。若val并非数组时,则就以val进行替换。若val的元素个数过多时,后面的元素将会发生移位。若val为nil或空数组[]时,将删除从start到end的元素。

    a=Array[1,2,3]
    a[1..3]=["a","b"]
    a
    =>[1,"a", "b"]
    a[1..3]=6
    a
    =>[1,6]

    a=[0, 1, 2, 3, 4, 5]
    a[0..2]=["a", "b"]
    a
    => ["a", "b", 3, 4, 5]

    a[2..4] = nil
    a
    => ["a", "b"]

    self[start, length]=val
    将从索引start算起的length个数组元素替换为val的内容。若val不是数组时,则调用val.to_ary或使用[val]进行替换。返回val。

    a=Array[1,2,3]
    a[1,3]=["a","b"]
    a
    =>[1,"a", "b"]
    a[1,3]=6
    a
    =>[1,6]


    a=[0, 1, 2, 3]
    a[1, 2]=['a', 'b', 'c']
    a                      
    => [0, "a", "b", "c", 3]
    a[2, 1] = 99
    a                        
    => [0, "a", 99, "c", 3]
    a[1, 0] = ['inserted']
    a
    => [0, "inserted", "a", 99, "c", 3]


    self + other
    将self和other的内容连起来后生成新数组并返回该数组。若other并非数组时则使用other.to_ary的返回值。若该返回值依然不是数组时,则引发TypeError异常。

    a=[1,2]
    b=[3,4]
    a+b
    =>[1,2,3,4]

    self * times
    将数组内容重复多次后生成一个新数组并返回该数组.

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

    若times为字符串,则其动作等同于self.join(times)。
    a*"a"
    =>"1a2a3a"

    self - other
    集合的补集运算。从self中删除other的元素后生成一个新数组并返回该数组。重复元素将被清除。

    a=[1, 2, 3] 
    a-[1]
    => [2, 3]

    self & other
    集合的交集运算。将同属于两个数组的元素重组为一个新数组并返回该数组。重复元素将被清除。

    a=[1, 2, 3]
    b=[1, 4, 5] 
    a&b
    => [1]

    self | other
    集合的并集运算。将任属两数组之一的元素重组为一个新数组并返回该数组。重复元素将被清除。

    a=[1, 2, 3]
    b=[1, 4, 5] 
    a|b
    => [1,2,3,4,5]

    self << obj
    将obj追加到数组尾部。

    a=[1, 2, 3]
    a<<5
    => [1,2,3,5]
    a<<5<<6<<7
    =>[1,2,3,5,5,6,7]

    self <=> other
    使用<=>来依次比较self和other中的各个元素。若self大则返回正整数;若相等返回0;若小则返回负整数。如果各个元素均相等,且其中一个数组已到达尾部时,则认定较短的数组为小。

    self = = other
    使用==来依次比较self和other中的各个元素,若所有元素均相等时返回真。


    assoc(key)
    对数组中的元素数组进行检索,若某元素数组的首元素与key相等时就返回该元素数组。使用==操作符进行比较。若没有符合条件的元素数组就返回nil。

    a = [[1,15], [2,25], [3,35]]
    a.assoc(2)           
    => [2, 25]
    a.assoc(15)
    =>nil

    at(pos)
    返回位于pos的数组元素。与self[pos]相同。

    a = [[1,15], [2,25], [3,35]]
    a.at(2)           
    => [3, 35]
    a[2]
    => [3, 35]

    clear
    删除数组中的所有元素。返回self。

    clone/dup
    生成一个与receiver内容一样的新数组并返回它。clone会拷贝frozen tainted singleton-class等信息,而dup则只拷贝内容。

    collect! {|item| ..} / map! {|item| ..}
    依次将数组的各个元素传给块进行计算,然后以计算结果来替换该数组元素

    a = [1, 2, 3]
    aa.map! {|i| i * 3 }
    a   
    => [3, 6, 9]

    compact/compact!
    compact从self中删除值为nil的元素后生成新数组并返回它。compact!是具有破坏性的,若对原数组进行了改动就返回self,若没有进行改动则返回nil。

    a = [1, nil, 2, nil, 3, nil]
    a.compact!   
    a
    => [1, 2, 3]

    concat(other)
    将other连接到self末尾(该动作具有破坏性)。返回self。

    a=[1,2]
    b=[3,4]
    a.concat(b)
    a
    =>[1,2,3,4]

    delete(val)/delete(val) { ... }
    使用==来分别比较val与每个数组元素,若相等则删除该元素。若发现了与val相等的元素就返回val。若没有发现与val相等的元素则返回nil,若指定了块的话就对块进行计算并返回结果。

    array = [1, 2, 3, 2, 1]
    array.delete(2) 
    array                 
    => [1, 3, 1]


    delete_at(pos)
    删除pos所指位置的元素并返回它。若pos超出数组范围则返回nil。与at一样,可以使用负的索引从尾部起指定.

    array = [0, 1, 2, 3, 4]
    array.delete_at(2)
    array             
    => [0, 1, 3, 4]

    delete_if {|x| ... }
    reject! {|x| ... }
    依次将元素传给块进行计算,若结果为真就删除相应元素。delete_if通常返回self。若没有删除任何元素时,reject!会返回nil。

    a=[1,2,3]
    a.delete_if{|x|x=false}
    =>[1,2,3]
    a.delete_if{|x|x=true}
    =>[]

    each {|item| .... }
    依次使用每个元素来计算块。返回self。

    a=[1, 2, 3]
    a.each{|i|puts i}
    1
    2
    3
    =>[1,2,3]

    each_index {|index| .... }
    依次使用每个元素的索引来对块进行计算

    a=[1, 2, 3]
    a.each_index{|i|puts i}
    1
    2
    3
    =>[1,2,3]

    empty?
    若数组元素数目为0则返回真。

    eql?(other)
    使用Object#eql?来依次计算self和other的各个元素,若所有元素均相等则返回真。


    fetch(nth) 
    fetch(nth, ifnone)
    fetch(nth) {|nth| ... }
    与Array#[nth]一样,返回第nth个元素。但若没有第nth个元素的话,它的运作就有别于Array#[nth]了:第一种形式会引发IndexError异常。第二种形式会返回参数ifnone。而第三种形式会返回块的计算结果。

    a=[1, 2, 3]
    a.fetch(1)
    =>2

    fill(val)
    fill(val, start[, length])
    fill(val, start..end)
    fill {|index| ... } 
    fill(start[, length]) {|index| ... }
    fill(start..end) {|index| ... } 
    将val赋值给数组中被指定的范围内的所有元素。在第二种形式中,若省略length则意味着将指定范围扩大到数组尾部。若指定范围最终超出原数组的长度时,将自动加长原数组,并以val来对新增元素进行初始化。

    a=[1, 2, 3]
    a.fill(1)
    =>[1,1,1]

    first/first(n) 
    返回数组的首元素。若没有首元素则返回nil。
    a=[1, 2, 3]
    a.first
    =>1
    a.first(2)
    =>[1,2]

    flatten/flatten!
    将带嵌套的数组重整为不带嵌套的单纯数组,并返回它。flatten!的重整具有破环性,若原数组不带嵌套则返回nil。

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

    include?(val)
    若数组中包含==val的元素就返回真。

    index(val)
    返回数组中第一个==val的元素的位置。若没有与其相等的元素则返回nil。
    a=[1, 2, 3]
    a.index(1)
    =>0

    insert(nth, val[, val2 ...])/insert(nth, [val[, val2 ...]])
    在索引为nth的元素前面插入第2参数以后的值。返回self。

    a=[1, 2, 3]
    a.insert(2,'a','b')
    =>[1,2,"a","b",3]

    join([sep])
    将sep字符串夹在各元素中间使数组转换为字符串,并返回该字符串。

    若数组元素并非字符串的话,就调用to_s然后再进行连接。若元素依然是数组时,将再归调用(同样适用sep)join来连接字符串。
    若sep为nil则使用空字符串。
    若参数sep被省略,则使用变量$,的值。$,的默认值为nil。

    a = [1,2,3]
    ary.join("a")    
    => "1a2a3"

    last/last(n) 
    返回数组末尾的元素。若数组为空时,返回nil。

    a=[1, 2, 3]
    a.last
    =>3
    a.lasst(2)
    =>[2,3]

    length/size
    返回数组长度。若数组为空则返回0.

    a=[1, 2, 3]
    a.length
    =>3
    a.size
    =>3

    nitems
    返回非nil元素的个数

    pack(template)
    按照template所指字符串的样式,以二进制的形式将数组的内容打包成字符串,并返回该字符串

    pop
    删除末尾元素并返回它。若数组为空则返回nil。

    a=[1, 2, 3]
    a.pop
    =>[1,2]

    push(obj1[, obj2 ...])/push([obj1[, obj2 ...]]) 
    依次将obj1, obj2 ...添加到数组结尾。

    array = [1, 2, 3]
    array.push(4)
    =>[1,2,3,4]

    rassoc(obj)
    假定self是数组中的元素数组,若首次发现元素数组中索引为1的元素与obj相等时就返回该元素。使用==操作符进行比较。若没有符合条件的元素数组则返回nil。

    a = [[15,1], [25,2], [35,3]]
    a.rassoc(2)    
    => [25, 2]

    replace(another)
    以数组another来替换该数组的内容。返回self。

    a = [1, 2, 3]
    a.replace([4, 5])
    =>[4,5]

    reverse/reverse!
    reverse将所有元素以逆序重新排列生成新数组并返回它。reverse!的逆序排列过程具有破环性。reverse通常返回新数组。若数组只有1个元素,reverse!会返回nil,除此以外将返回self。

    a = [1, 2, 3]
    a.reverse
    =>[3,2,1]

    reverse_each {|item| ... }
    对各个元素以逆序对块进行计算。返回self。

    rindex(val)
    返回最后一个== val的元素的索引值。若没有符合条件的元素时返回nil。

    p [1, 0, 0, 1, 0].rindex(1)   
    => 3

    shift
    删除数组的首元素并返回它。剩余元素依次提前。若数组为空返回nil。

    slice(pos[, len])/slice(start..last)
    与self[]相同。

    slice!(pos[, len])/slice!(start..last)
    删除指定的元素并返回它。若没有可删除的元素时返回nil。

    sort
    sort!
    sort {|a, b| ... }
    sort! {|a, b| ... }
    对数组内容进行排序。若带块调用时,将把2个参数传给块,然后使用块的计算结果进行比较。若没有块时,使用<=>操作符进行比较。sort将生成一个经过排序的新数组并返回它。sort!的对self的排序过程具有破环性。

    to_a/to_ary
    原封不动地返回self。

    to_s
    与self.join($,)相同。

    transpose
    将self看作是由行和列构成的矩阵,然后进行行列互调(将行和列互换)。生成一个新数组并返回它。若原数组为空,则生成空数组并返回它。

    uniq/uniq!
    uniq会删除数组中的重复元素后生成新数组并返回它。剩下的元素会向前移动。uniq!具有破环性,若进行了删除则返回self,若没有删除则返回nil。

    unshift(obj1[, obj2 ...])
    unshift([obj1[, obj2 ...]])
    依次将obj1, obj2 ...插到数组的头部。返回self。

    values_at(index_1, ... , index_n)
    以数组形式返回其索引值与各参数值相等的元素。若指定了超出范围的索引值时,将指派nil与其对应
  • Ruby语言入门(11)- 内部类 - Object

    2013-02-01 15:25:15

    Object类是所有类的超类,它定义了对象的一般行为。

    包含的模块为Kernel。

    定义的方法有:

    = =
    两个对象对象是否相等

    ~ = =
    两个对象是否不等

    = = =
    对象是否为子类

    class
    对象的父类

    clone
    克隆对象

    dup
    克隆对象的内容

    display(out = $stdout)
    将对象输出到 out

    eql?/equal?
    等同于 ==

    extend(module ... )
    将参数所指模块的实例方法追加为self的特殊方法.返回self.

    freeze
    禁止修改对象的内容.返回self.

    frozen?
    若某对象禁止修改其内容则返回真

    hash
    返回对象的哈希表值.


    _ _id_ _ / object_id
    返回与各个对象对应的唯一的整数.

    inspect
    将某对象转为人工可读的字符串并返回该字符串.

    instance_eval(expr, [fname, [lineno=1]])
    instance_eval {|obj| ... }
    在对象的context中计算字符串expr并返回结果.在对象的context进行计算是指,将self设为那个对象然后开始执行.同时,若在字符串/块中定义了方法的话,则相当于定义了self的特殊方法.

    若给出了fname和lineno的话,将假定字符串位于在文件fname的第lineno行,然后开始编译,并能显示文件名/行号等栈跟踪信息. 若给出了块的话,将在对象的context中计算该块并返回结果.self将被传递给块的参数obj.

    instance_of?(klass)
    若self为klass类的直接的实例时,返回真.

    instance_variable_get(var)
    取得并返回对象的实例变量的值.

    instance_variable_set(var, val)
    将val的值赋值给对象的实例变量并返回该值.

    instance_variables
    以字符串数组的形式返回对象的实例变量名.

    is_a?(mod)
    kind_of?(mod)
    只要self是下列任何一个类的实例就返回真::mod类和它的子类,以及包括mod模块的类和它的子类.

    method(name)
    将self的方法name对象化后得到Method对象并返回该对象


    methods
    public_methods
    private_methods
    protected_methods
    methods([inherited_too]) 
    public_methods([inherited_too]) 
    private_methods([inherited_too]) 
    protected_methods([inherited_too]) 

    以字符串数组的形式返回某方法能理解的 public/private/protected 方法名列表.

    nil?
    若receiver为nil则返回真.

    respond_to?(name[, priv=false])
    若对象中包含名为name的public方法时返回真.

    send(name[, args ... ])
    send(name[, args ... ]) { .... }
    __send__(name[, args ... ])
    __send__(name[, args ... ]) { ... }
    调用对象的name方法,并将args传给该方法的参数,然后返回方法的结果.若是带块调用的话,也会把块原封不动地传给方法

    singleton_methods
    singleton_methods([inherited_too]) 
    以字符串数组的形式返回该对象中定义的特殊类名的列表.

    taint
    设定对象的"污染标记".返回self.

    tainted?
    若对象已经有"污染标记"则返回真.

    untaint
    取消对象的"污染标记".返回self.

    to_a/to_ary
    将对象转换为数组并返回该数组.

    to_hash
    将对象隐式地转换为哈希表

    to_int
    将对象隐式地转换为整数

    to_s/to_str
    将对象转换为字符串并返回该字符串.
  • Ruby语言入门(10)- 内部常数

    2013-02-01 15:13:15

    STDIN
    标准输入。$stdin的默认值。

    STDOUT
    标准输出。$stdout的默认值。

    STDERR
    标准错误输出。$stderr的默认值。

    ENV
    表示环境变量的(伪)哈希表。若改变该哈希表的值时,将作为子进程环境而被继承下来。

    ARGF
    由参数(若没的话就使用标准输入)构成的虚拟文件。也就是说,gets与ARGF.gets的意义相同。
    可以使用ARGF.file得到当前读入的文件对象,使用ARGF.filename得到当前读入的文件名。

    ARGV
    传给Ruby脚本的参数。内部变量$*的别名

    DATA
    访问脚本中__END__(脚本终点)以后部分的File对象。

    TOPLEVEL_BINDING
    顶层Binding对象。

    RUBY_VERSION
    Ruby版本

    RUBY_RELEASE_DATE
    Ruby发布日期

    RUBY_PLATFORM
    Ruby平台信息

  • Ruby语言入门(9)- 内部变量

    2013-02-01 14:35:25

    全局变量
    所有以`$'开头的变量

    内部变量
    全局变量中的内部变量(本网页介绍的变量)

    特殊变量
    内部变量中,形如"`$' + 1位数字或符号"的变量

    选项变量
    内部变量中,由命令行选项设定的变量,形如"`$-' +1个选项字符"


    根据变量值的作用域的不同,大致将内部变量划分如下:
    • 局部域, 可看做是线程内的局部变量.
    • 线程局部域,在一个线程内部时是全局域变量,但在不同的线程之间是彼此独立的.
    • 全局域
    属于局部域的:
    $_ 

    gets或readline最后读入的字符串.若遇到EOF则为nil.

    $& (等同于Regexp.last_match[0])

    在当前作用域中,正则表达式最后一次匹配成功的字符串.若最后一次匹配失败,则为nil.

    $~ (等同于Regexp.last_match)

    在当前作用域中,最后一次匹配成功的相关信息(MatchData对象).若对其进行设定的话, 则$&以及$1 ... $9等的值也会发生变化.可以使用$~[n]的形式从该数据中抽取第n个匹配结果($n)

    $‘ (等同于Regexp.last_match.pre_match)

    在当前作用域中,正则表达式最后一次匹配成功的字符串前面的字符串.若最后的匹配失败则为nil。

    $· (等同于Regexp.last_match.post_match)

    在当前作用域中,正则表达式最后一次匹配成功的字符串后面的字符串.若最后的匹配失败则为nil。

    $+

    在当前作用域中,正则表达式最后一次匹配成功的字符串部分中,与最后一个括号相对应的那部分字符串.若最后的匹配失败则为nil.

    $1($2,$3,...)  (等同于Regexp.last_match[1], Regexp.last_match[2],...)

    分别存储着最后一次模型匹配成功时与第n个括号相匹配的值.若没有相应的括号时,其值为nil.

    属于线程局部域的:

    $?

    本线程中最后结束的子进程的状态值。

    $!

    最近发生的异常的信息

    $@

    以数组形式保存着发生异常时的back trace信息. 数组元素是字符串,它显示了方法调用的位置,其形式为:"filename:line"

    $SAFE

    当前线程的安全等级。

    属于全局域的:

    $/

    输入记录分隔符。默认值为"\n"。若将该变量设为 nil 时,将一次读入整个文件。若设为空字符串 "" 则将是段落模式,此时会把2个以上的连续的换行符当作记录切分符。

    $\

    输出记录分隔符。print会在最后输出该字符串。默认值为nil,此时不会输出任何字符。

    $,

    默认的切分字符。若Array#join中省略了参数时或在print的各个参数间将会输出它,默认值为 nil ,等同于空字符串。

    $;

    当String#split中省略参数时的切分字符。默认值为nil,此时将进行特殊的分割。

    $.

    最后读入的输入文件的行号。

    $<

    由参数(若没的话就使用标准输入)构成的虚拟文件。也就是常数ARGF的别名。

    $>

    内部函数print、puts或p等的默认输出对象。初始值为STDOUT。若指定了-i[extension]选项的话,则将使用与读取源同名的文件。

    $0/$PROGRAM_NAME 

    当前运行中的Ruby脚本名.

    $*

    传递给Ruby脚本的参数.内部常数ARGV的别名.

    $$

    当前运行中的Ruby进程的pid

    $:/$LOAD_PATH

    包含一个数组,其内容是load或require加载文件时用的搜索目录列表.

    $"/$LOADED_FEATURES 

    包含以require加载的文件名的数组.这可以防止require多次加载同一个文件.

    $DEBUG

    若此值为真则变成调试模式。它由-d选项进行设定。

    $FILENAME

    虚拟文件ARGF中,当前正在读入的(gets方法正在读的)文件名

    $stdin/$stdout/$stderr 

    标准输入,标准输出,标准错误输出

    $VERBOSE

    警告等级分为三级,分别如下。
    • nil: 不输出警告
    • false: 只输出重要警告(默认)
    • true: 输出所有警告

    $KCODE

    Ruby可识别的多字节字符串的编码。变量值为"EUC" "SJIS" "UTF8" "NONE"之一。可以使用Ke,Ks,Ku,Kn。 "e" "E" 代表 "EUC","s" "S" 代表 "SJIS","u" "U" 代表 "UTF8",而"n" "N" 则代表 "NONE"。默认值为"NONE"。 


    选项变量

    用来显示Ruby解释器命令行信息的变量。其形式为$-?,?的部分是1位选项字符。

    $-0
    $/ 的别名。

    $-a
    若指定了-a时,其值为真。只读变量。

    $-d
    $DEBUG 的别名。

    $-F
    $; 的别名。

    $-i
    若指定了-i[extension]时,它将保存扩展名字符串。否则其值为nil。也可以在脚本中对其进行赋值,此时将在开始读入ARGV中的下一个文件之前进行in-place替换。

    $-I
    $LOAD_PATH 的别名。

    $-K
    $KCODE 的别名。

    $-l
    若指定了-l时,其值为真。只读变量。

    $-p
    若指定了-p时,其值为真。只读变量。

    $-v 
    若指定了-p时,其值为假。只读变量。

    $-w
    $VERBOSE 的别名。

    $-W

    返回由-W[level]指定的值。也就是说,根据$VERBOSE的取值不同
    • nil: 不输出警告 -> 0
    • false: 只输出重要警告(默认) -> 1
    • true: 输出所有警告 -> 2
  • Ruby语言入门(8)- Kernel模块的内部函数

    2013-01-29 16:36:05

    下面是一些常用的kenerl方法

    str

    把字符串str当做外部命令来运行,并以字符串方式返回命令的输出。

    Array(arg)

    调用 arg.to_ary 或 arg.to_a 将参数转为数组并返回结果

    a=Array("test")
    a.class
    => Array

    Float(arg)

    将参数变为浮点数(Float)并返回结果.
    puts Float("10")    
    => 10.0

    Integer(arg)

    将参数变为整数(Fixnum,Bignum)并返回结果.对数值,字符串以外的对象使用to_i方法。

    puts Integer("0d10") 
    => 10

    String(arg)

    调用arg.to_s将参数变为字符串并返回结果。

    a=String("test")
    a.class
    => String

    abort/abort(message)

    以非正常方式结束Ruby程序的运行。

    at_exit { .... }

    在解释器结束工作之前执行指定的块。除去at_exit是个方法这点差异之外,它与END块所进行工作基本相同。


    autoload(const_name, feature)/autoload?(const_name) 

    可以autoload任何类/模块的常数。

    binding

    生成并返回Binding对象。该对象包含变量、方法等的环境信息,它通常用作Eval的第二参数。

    catch(tag) {|tag| .... }

    运行块并返回它的值。若在块的运行过程中,遇到与tag同名的throw的话,将把throw的第二参数的值作为返回值。

    ret = catch(:exit) {
       throw :exit, 25
       some_process()
    }
    puts ret   

    #=> 25

    chop/chop!

    将内部变量$_末尾的字符去掉(若末尾是"\r\n"则去掉2个字符)。chop不改变内部变量$_的内容,chop!改变内部变量$_的内容。

    chomp([rs])/chomp!([rs])

    去掉位于内部变量$_末尾且由rs指定的字符。

    eval(expr[, binding[, fname[, lineno=1]]])

    把字符串expr当作Ruby程序来运行并返回其结果。若给第二参数传递Proc对象或Binding对象的话,将在生成该对象的环境中对字符串进行计算。

    def foo
      a = 1
      binding
    end

    eval("p a", foo)  
    # => 1

    exec(command)/exec(program[, arg1[, arg2[, ...]]])

    执行由command指定的命令.该命令将变成进程执行的代码,所以一旦启动成功,就不会再从该函数中返回.若启动失败,控制权重新回归ruby解释器,然后会引发Errno::EXXX异常.

    exit([status])

    终止Ruby程序的运行.若向status传递了一个整数的话,该整数就将成为Ruby命令的结束状态值.默认的结束状态值是0.

    exit!([status])

    以整数status为结束状态值来终止Ruby程序的运行.默认的结束状态值为-1. exit!与exit不同,它不会进行异常处理.在fork之后,若想终止子进程时可以使用该语句.

    fork/fork { ... }

    使用fork(2)系统调用来制作进程的拷贝.若在父进程中将返回子进程的进程ID,若在子进程中则返回nil.若指定一个块之后再进行调用,则会在生成的子进程中对该块进行计算.

    gets([rs])/readline([rs])

    Ruby解释器在运行时,会把从参数那里得到的文件(若没有的话,就利用标准输入)假设成一个虚拟文件(可以使用内部变量$<或ARGF访问该虚拟文件),然后从该虚拟文件中读入一行,并返回字符串.若到达文件尾部时返回nil.

    使用rs指定的字符串作为行的切分符号.rs的默认值取自内部变量$/.读入的字符串也被存入内部变量$_中.

    若将rs设为nil的话,则意味着读入文件的全部内容而忽略行的切分.若设为空字符串""的话,会把连续的换行当做行的切分符(段落模式).

    readline的功能与gets相同,但是当它遇到文件结尾时会引发EOFError异常.

    global_variables

    返回程序中已定义的全局变量(以'$'开头的变量)名的数组.

    gsub(pattern[, replace])
    gsub!(pattern[, replace])
    gsub(pattern) {|matched| ... }
    gsub!(pattern) {|matched| ... }

    在内部变量$_所包含的字符串中,将符合pattern的部分替换为replace,然后返回结果.若省略参数replace时,该方法将演变为迭代器,以块的计算值进行替换操作.将匹配的字符串以参数的形式传递给块.

    $_ = "foobar"

    puts gsub(/o+/) {|m|
      m.upcase
    }

    # => "fOObar"

    block_given?

    若某方法带块则返回真,否则返回伪。

    load(file[, priv])

    加载Ruby程序file并予以执行.若file是绝对路径,则从file开始加载.若file是相对路径,则依次搜索内部变量$:所指定的路径,并加载第一个搜索到的文件.此时,若$:中的元素是以"~"(tilde)开头的话,就把它扩展为环境变量HOME的值.

    若加载成功则返回true,若失败则引发LoadError异常.

    [require与load之间的区别]

    require对于相同的文件只会加载一次,而load则是无条件的加载.另外,require会自动补全扩展名,如.rb或.so等.而load则没有该功能.一般的典型用法是,使用require加载库,而使用load加载配置文件等.

    local_variables

    返回当前作用域中已定义的局部变量名的数组.

    loop { ... }

    (只要不被中断就)反复对块进行计算.

    open(file[, mode[, perm]])/open(file[, mode[, perm]]) {|io| ... }

    打开file并返回File对象.mode可以是下列,省略时默认为"r".
    • "r", RDONLY: 以读取模式打开文件.
    • "w", WRONLY|CREAT|TRUNC: 以写入模式打开文件.打开文件时,若文件已存在就清空文件内容.
    • "a", WRONLY|CREAT|APPEND: 以写入模式打开文件.通常把写入内容添加到文件结尾.
    若有"+"的话,就以读写两用模式(RDWR)打开文件:
    • "r+": 将文件的读写位置设在开头.
    • "w+": 与"r+"一样.打开文件时,若文件已存在就清空其内容.
    • "a+": 与"r+"一样.打开文件时,若文件已存在,就把读写位置设在文件结尾.
    可在上述任意一项后面添加"b"(如"r+b")标志.此时,将以二进制方式打开文件(只限于以文本/二进制方式来区分文件的系统).

    第三参数perm与open(2)的第三参数是一样的,它以整数的形式说明了文件在CREAT时的访问权限。若第二参数不是数值形式的话,该参数将被忽略。它的默认值是0666。

    若文件名以`|'开头时,其后的字符串会被当作命令来执行。另外,将生成管线(pipeline)来应对命令的标准输入输出。

    若文件名为"|-"的话,open将生成Ruby的子进程,并返回与子进程之间的管道(pipe)(IO对象)。(此时的运作与IO.popen相同。File.open没有生成管线的功能)。

    当open与块同时被调用时,open将打开文件并执行块,当块的运行终止后就关闭文件。此时返回块的计算结果。请看下例。

    open(path, mode) do |f|
       ...
    end

    # 等效代码
    f = open(path, mode)
    begin
       ...
    ensure
      f.close
    end


    p(obj, [obj2, ...])

    等同于print。

    print([arg1[, arg2, ...]])

    依次输出参数。若没有得到参数则输出变量$_的值。若把非字符串对象传给参数的话,将对该对象使用to_s方法将其变为字符串后输出。若是nil的话则输出字符串"nil"。

    printf([port, ]format[, arg[, ...]])

    类似于C语言的printf,它将按照format将参数格式化为字符串,然后输出到$>。当第一参数是IO的子类的实例时,将对该对象进行输出。若没有任何参数时,将不作反应。

    proc { ... }
    lambda { ... }
    proc
    lambda

    在给出的块中生成过程对象(Proc的实例)并返回它(等同于Proc.new)。

    若没有给出块的话,将返回主调(caller)方法所指的块。若主调方法没有块时,将引发ArgumentError异常。

    putc(ch)

    将字符ch输出到$>。若ch是数字的话,将输出对应于0~255的字符。若ch是字符串的话,将输出字符串中的第一个字符。

    puts([obj[, obj2[, ....]]] )

    依次将obj和换行符输出到$>。若没有参数的话则只会输出换行符。

    若参数是数组,则依次输出数组元素和换行符。若将既非数组又非字符串的对象传递给参数时,将尝试使用to_ary方法将其化为数组,再使用to_s方法将其化为字符串。若是nil则输出字符串"nil"。


    raise
    raise(exception)
    raise(message)
    raise(error_type, message [, backtrace])
    fail(error_type, message [, backtrace])

    引发异常,若没有参数时,将再次引发本线程本块内最后被rescue的异常对象($!)。若没有这样的异常时,将引发RuntimeError异常。

    begin
      open("nonexist")
    rescue
      raise   # => `open': No such file or directory - "nonexist" (Errno::ENOENT)
    end


    只有一个参数,且该参数为字符串时,将以该字符串为message来引发RuntimeError异常。若该参数为异常类或异常对象时,将引发该异常。

    raise "error message"    # => -:1: error message (RuntimeError)
    raise ArgumentError      # => -:1: ArgumentError (ArgumentError)
    raise ArgumentError.new  # => -:1: ArgumentError (ArgumentError)

    有2或3个参数时,将以第二参数为message来引发第一参数所指的异常。此时是以异常类或异常对象来指定异常的。而第三参数则是发生异常时的栈跟踪(track trace),它的形式必须与caller的返回值一致。

    raise ArgumentError, "error message"
    # => -:1: error message (ArgumentError)
    raise ArgumentError, "error message", ["file1:99","file2:999:in `method'"]
    # => file1:99: error message (ArgumentError)
                  from file2:999:in `method'

    若将非异常的类或对象赋予第一参数时,实际上发生的异常正是该对象的exception方法的返回值。

    class MyException
      def exception
        ArgumentError.new
      end
    end

    raise MyException.new
    # => -:7: ArgumentError (ArgumentError)

    采用第二种形式来指定参数时,该参数将被赋予exception方法。

    class MyException
      def exception(mesg)
        ArgumentError.new(mesg)
      end
    end

    raise MyException.new, "error message"
    # => -:7: error message (ArgumentError)


    rand([max=0])

    产生一个0至max(不含)之间的随机数。

    require(feature)
    从加载路径$:开始搜索Ruby库feature,若该库尚未被加载就立即加载。

    scan(re)/scan(re) {|matched| ... }

    与$_.scan一样。

    select(reads[, writes[, excepts[, timeout]]])

    与IO.select一样。

    set_trace_func(trace_proc)

    在Ruby解释器执行程序的过程中,每当发生方法调用或对表达式进行计算等事件时都将执行trace_proc过程对象

    set_trace_func lambda {|event, file, line, id, binding, klass|
        # ....
    }

    event表示发生事件的类别。详细内容如下:

    • "line" ... 表达式的计算。
    • "call" ... 方法调用。
    • "return" ... 从方法调用中返回。
    • "c-call" ... C(语言)方法的调用。
    • "c-return" ... 从C(语言)方法调用中返回。
    • "class" ... 进入类定义、特殊类定义或模块定义中。
    • "end" ... 类定义、特殊类定义或模块定义的结束。
    • "raise" ... 发生异常。
    file运行中的程序的源文件名(字符串)。

    line运行中的程序的源文件行号(整数)。

    id根据event的不同,将使用下列之一。与第六个块参数klass相对应。
    • line Symbol对象,它表示最后被调用的方法。在顶层中则为nil。
    • call/return/c-call/c-return Symbol对象,它表示被调用/return的方法。
    • class/end nil。
    • raise Symbol对象,它表示最后被调用的方法。在顶层中则为nil。

    binding Binding对象,它表示运行中的程序的状况(context)。

    klass根据event的不同,将使用下列之一。与第四个块参数id相对应。
    • line Class对象,它表示最后被调用的方法的所属类。在顶层中则为false。
    • call/return/c-call/c-return Class对象,它表示被调用/return的方法的所属类。
    • class/end false。
    • raise Class对象,它表示最后被调用的方法的所属类。在顶层中则为false。
    sleep([sec])

    使程序暂停sec秒。也可以将sec设为浮点数。省略sec时,若没有显式地(SIGALRM或其他线程发出的Thread#run)终止睡眠的话,将一直sleep下去。返回值是实际睡眠的秒数(整数)

    spawn(cmd, [arg, ...]) 

    基本上等同于system,但它不会等待子进程的结束。返回生成的子进程的进程ID。

    split([sep[, limit]])

    使用sep模型将$_中的字符串分割成limit个部分后转化为数组,然后返回该数组。

    sprintf(format ... )/format(format ... )

    sprintf对format字符串进行解释,格式化参数后返回结果。使用format时,等同于sprintf。

    srand([seed])

    设定rand的随机数的种子,返回旧的初始值(第一次返回0)。若省略初始值时,则以当前时刻、进程ID或srand的调用次数为基础生成一个种子。

    sub(pattern[, replace])
    sub!(pattern[, replace])
    sub(pattern) {|matched| ... }
    sub!(pattern) {|matched| ... }

    在内部变量$_所指的字符串中,将首个匹配pattern的部分替换为replace,然后返回结果.若省略参数replace时,该方法将变为迭代器,以块的计算值进行替换操作.将匹配的字符串以参数的形式传递给块

    syscall(num, arg ... )

    执行num号码所对应的系统调用。将第二参数以后的部分传给系统调用作为其参数。参数必须是字符串或整数。

    system(command)
    system(program[, arg1[, arg2[, ...]]])

    执行command,成功(子进程以 status 0 的状态结束时)则返回真,失败(包括不能执行命令)则返回伪。可参照变量$?来获取结束状态值(status)。

    test(cmd, file1 [, file2])

    进行文件测试。

    trace_var(varname, hook)
    trace_var(varname) {|newval| .... }

    注册钩子以监视对全局变量varname所进行的赋值。varname可以是字符串或Symbol。这里所说的“全局变量”是指以“$”开头的变量,包括特殊变量。

    untrace_var(varname[, hook])

    取消与全局变量varname有关的钩子。若指定了hook的话,将只会取消该钩子。若省略hook或将其设为nil时,将取消varname所有的钩子。返回取消钩子的数组。

    warn(mesg)

    依次输出mesg和换行符到$stderr之中。若内部变量$VERBOSE为nil时,则不会输出。
  • Ruby语言入门(7)- 控制语句

    2013-01-29 16:17:49


    条件分支

    if 表达式 [then]
      表达式 ...
    [elsif 表达式 [then]
      表达式 ... ]
    ...
    [else
      表达式 ... ]
    end

    if age >= 12 then
      print "adult fee\n"
    elseif age <6 then
     print "no fee\n"
    else
      print "child fee\n"
    end


    if 修饰句

    print "adult fee\n" if age >= 12

    unless 表达式 [then]
      表达式 ...
    [else
      表达式 ... ]
    end

    unless baby?
      feed_meat
    else
      feed_milk
    end

    unless 修饰句

    print "stop\n" unless valid(passwd)

    case [表达式]
    [when 表达式 [, 表达式] ...[, `*' 表达式] [then]
      表达式..]..
    [when `*' 表达式 [then]
      表达式..]..
    [else
      表达式..]
    end

    case $age
    when 0 .. 2
      "baby"
    when 3 .. 6
      "little child"
    when 7 .. 12
      "child"
    when 13 .. 18
      "youth"
    else
      "adult"
    end


    循环

    while 表达式 [do]
       ...
    end

    ary = [0,2,4,8,16,32,64,128,256,512,1024]
    i = 0
    while i < ary.length
      print ary[i]
      i += 1
    end


    表达式 while 表达式


    sleep(60) while io_not_ready?

    until 表达式 [do]
       ...
    end

    until f.eof?
      print f.gets
    end


    表达式 until 表达式

    print(f.gets) until f.eof?

    for  表达式  in 表达式 [do]
      表达式..
    end

    for i in [1, 2, 3]
      print i*2, "\n"
    end


    过程

    break将退出最内层的循环。所谓循环是指,下列之一

    while
    until
    for
    迭代

    next将跳转到最内侧循环的头部

    redo不检查循环条件,重新开始当前循环。

    retry,意味着重启迭代器

    return结束方法的运行,且把表达式的值设定为方法的返回值。若给出了2个以上的表达式,则将把这些表达式化为一个数组,然后把该数组设定为方法的返回值。若省略表达式,将返回值设为nil。



  • Ruby语言入门(6)- 字面值

    2013-01-29 15:48:28

    字面值

    我们把类似字符串“hello world”这样可以直接写入Ruby程序中的值叫做字面值。

    数值字面值

    123 整数
    -12 带符号的整数
    1.2 浮点数
    ?a a的AscII码

    字符串字面值

    "this is a string expression\n" 字符串
    'a' 字符
    'aaa' 字符串  

    在被单引号括起来的字符串中,除了\\(反斜线本身)、\'(单引号)和行尾的\(忽略换行)以外,不会对字符串内容作任何处理。

    字符串中,以\来处理的字符有:
    \t Tab
    \n 换行
    \r 回车
    \f 换页
    \b 退格
    \e Esc
    \s 空白
    \\ \
    \' '

    字符串中,以%来处理

    %!STRING! : 双引号中的字符串
    %Q!STRING! : 同上
    %q!STRING! : 单引号中的字符串
    %x!STRING! : 命令输出
    %r!STRING! : 正则表达式
    %w!STRING! : 字符串数组(以空白字符切分各元素)
    %W!STRING! : 字符串数组(以空白字符切分各元素)。展开式、反斜线表示法都有效
    %s!STRING! : 符号。展开式、反斜线表示法都无效

    实例:
    %(()) => "()"
    %w(foo bar baz) => ['foo', 'bar', 'baz']
    %w(foo\ bar baz)=> ["foo bar", "baz"]


    字符串中,以展开式来处理

    ruby = "RUBY"
    "my name is #{$ruby}" #=> "my name is RUBY"
    'my name is #{$ruby}' #=> "my name is #{$ruby}"
    "my name is #$ruby" #=> "my name is RUBY"

    在以双引号(")括起来的字符串表达式、命令字符串以及正则表达式中,可以使用“#{表达式}”把表达式的内容(以字符串的形式)嵌入其中。若表达式是以($,@)开始的变量的话,则可以省略{}部分,只使用“#变量名”的形式即可.


    集成字符串字面值

    <<[-]["'`]标识符["'`]
       ...
    标识符

    print <<EOS      # (从这里开始)直到标识符 EOS 之前的部分就是字面值
      the string
      next line
    EOS

    等同于:
    print "  the string\n  next line\n"


    可以当作一个整体进行应用:
    # 将集成字符串用作被调
    p  <<LABEL.upcase
    the lower case string
    LABEL

    # => "THE LOWER CASE STRING"

    正则表达式

    被/括起来的部分就是正则表达式,例如:/Ruby/i

    数组表达式

    被[]括起来的部分就是数组表达式,例如:[1, 2, 3]

    哈希表表达式

    被{}括起来的部分就是哈希表达式,例如:{1=>2, 2=>4, 3=>6}

    范围对象

    范围表达式两端都是数值字面值时,每次计算都将返回同一个对象。除此以外,每次计算时都会返回新的范围对象。例如: [1..9]

    符号

    符号应用的语法如下:

    :标识符
    :变量名
    :操作符

    指定给Symbol字面值的操作符,必须是那些可以作为方法进行再定义的操作符


  • Ruby语言入门(5)- 变量

    2013-01-29 14:51:42

    局部变量

    标识符首位是小写字母或“_”,则该变量就是局部变量。

    局部变量的作用域起始于声明处,结束于该声明所在的块、方法定义、类/模块定义的结尾。

    但也有例外。若块已经变成过程对象的话,则局部变量将一直持续到该过程对象终结为止。若多个过程对象引用同一个作用域的话,局部变量将被这些对象所共享。

    实例变量

    以@开始的变量是实例变量,它属于特定的对象。可以在类或子类的方法中引用实例变量。若引用尚未被初始化的实例变量的话,其值为nil。

    类变量

    以@@开始的变量是类变量。在类的定义中定义类变量,可以在类的特殊方法、实例方法等处对类变量进行引用/赋值。类变量可以被当作被类、子类以及它们的实例所共享的限制性全局变量。

    全局变量

    以$开始的变量是全局变量,可以在程序的任何地方加以引用(因此需要特别留意)。全局变量无需变量声明。引用尚未初始化的全局变量时,其值为 nil。

    伪变量

    除普通的变量之外,还有一种叫做伪变量的特殊变量。

    self 当前方法的执行主体
    nil NilClass类的唯一实例
    true TrueClass类的唯一实例
    false FalseClass类的唯一实例。nil 和 false 表示“伪”。

    __FILE__ 当前源文件名
    __LINE__ 当前源文件中的行号

    伪变量的值不可改变,若对伪变量赋值将引发语法错误。

    常数

    以大写字母([A-Z])开始的标识符是常数.常数的定义(和初始化)由赋值过程完成.不能在方法中对常数进行定义.若对已定义的常数进行赋值的话,会出现警告信息.若引用未定义的常数的话,则会引发NameError异常.


    类变量与常数的区别

    类变量可以重复赋值,常数不能。
    类变量不能在类的外部直接引用,只能在其继承类中引用/赋值。
    常熟可以在类的外部直接引用。

    类变量与实例变量的区别

    类变量可在子类中引用/赋值,而实例变量只能被引用。
    类变量可在类实例的方法中引用/赋值,而实例变量只能被引用。
  • Ruby语言入门(4)-表达式

    2013-01-29 14:41:37

    在ruby中,将表达式连接起来就构成程序。

    使用分号(;)换行将表达式分隔开来。但反斜线后出现的换行并非分隔符,它表示该行将继续下去。

    例:
    puts "hello \
    world!\n"

    Ruby的表达式包括:变量常数、各种字面值、相关计算赋值、if或while等控制结构方法调用类/方法的定义。还可以使用括号将表达式括起来进行群组化。



    Ruby的表达式包括返回值的表达式和不返回值的表达式。
    空表达式 () 返回nil。
    不返回值的表达式: while, until, while 修饰表达式, until 修饰表达式
    不能用作参数的表达式: and, or, not, if/unless/rescue 修饰表达式

    Ruby解释器在读取程序时,若遇到下列标识就会停止
    文件的末尾(eval中字符串的末尾)
    ^D(control D)、^Z(control Z)
    只包含__END__的行(若前后出现空白字符将无法辨认)
231/212>
Open Toolbar