-
Ruby 小结
2013-03-18 16:18:16
Ruby的变量没有类型所有变量均无需声明即可立即使用不需要内存管理纯粹的面向对象语言功能强大的字符串操作和正则表达式检索功能字符串是指被单引号(')或双引号(")括起来的部分在用双引号括起来的字符串中,可以使用反斜杠(\)来指定转义字符用[]括起来的一串表达式是数组,而以{}括起来的一串表达式是散列表局部变量,变量名以小写英文字母开始。全局变量,以$开始实例变量,以@开始类变量,以@@开始类常数,以大写英文字母开始赋值 变量=表达式调用方法 表达式.方法名使用分号(;)或换行来分隔表达式流程控制结构:if 表达式 then 代码块 [elsif 表达式 then 代码块]..[else 代码块]endcase 表达式 when 表达式..; 代码块...[else 代码块] endwhile 表达式;代码块 endfor 变量..in 表达式; 代码块 endbreak 中断循环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 = = otherself > otherself >= otherself < otherself <= other字符串的比较。self << otherconcat(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]=valself[regexp, nth]=val以val来替换第一个与正则表达式regexp相匹配的子字符串。若使用了参数nth时,则以val替换第一个与正则表达式regexp中的第nth个括号相匹配的子字符串。若nth为0时,则以val来替换整个匹配部分。s1="test"s1[/es/]="ff"s1=>"affd"self[first..last]=valself[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,较小时返回负整数。capitalizecapitalize!将首字符(若为字母的话)改为大写字母,其余的改为小写字母。"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"chopchop!删除字符串末尾的字符(若字符串末尾是"\r\n"的话,就删除2个字符)."test".chop=>"tes"clonedup返回一个与原字符串内容相同的新字符串. 对被冻结的字符串使用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')=>2crypt(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"downcasedowncase!将字符串中的大写字母都改为小写字母.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}123=>"1\n2\n3\n"each_byte {|byte| ... }对字符串中的各个字节进行迭代操作.a="1\n2\n3\n"a.each_byte {|n| puts n}491050105110=>"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=>10include?(substr)若字符串中包含substr子字符串的话,就返回真.若substr是从0到255之间的Fixnum时,将把它看做是字符代码,若包含该代码所对应的字符,就返回真."test".include?("e")=>trueindex(pattern[, pos])按照从左到右的顺序搜索子字符串,并返回搜索到的子字符串的左侧位置. 若没有搜索到则返回nil.在参数pattern中,可以使用字符串,0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.若给出了pos时, 则从相应位置开始搜索.省略pos时其默认值为 0."test".index("es")=>1"test".index("es",3)=>nilinsert(nth, other)在第nth个字符的前面插入other字符串."test".insert(2,"ooo")=>"teooost"internto_sym返回与字符串相对应的符号值(Symbol)."test".intern=>:testlengthsize返回字符串的字节数."test".size=>4match(regexp)match(regexp[, pos])与regexp.match(self[, pos])相同"test".match(/./)=> #<MatchData "t">nextnext!succsucc!返回下一个字符串. 所谓"下一个"是指,按照26个字母顺序或10进制数的顺序继续向下数时得到的结果."abc".next=>"abd""123".succ=>"124"oct将字符串看做是8进制字符串,并将其变为整数."123".oct=>83replace(other)以other的内容来替换字符串的内容."test".replace("123")=>"123"reversereverse!对字符串进行反转."123".reverse=>"321"rindex(pattern[, pos])按照从右到左的顺序来搜索子字符串,并返回找到的子字符串的左侧的位置. 若搜索失败则返回nil.在参数pattern中,可以使用字符串,从0到255之间的字符代码或正则表达式来指定想要搜索的子字符串.若给出了pos时,就从相应位置开始搜索. 省略pos时,其值为self.size (右端)."character".rindex("c")=>5"character".rindex("c",0)=>0scan(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"stripstrip!删除头部和尾部的所有空白字符。空白字符是指" \t\r\n\f\v"。strip生成并返回修改后的字符串。strip!会修改self本身并返回结果。若没有进行删除动作,则返回nil。" test ".strip=>"test"lstriplstrip!删除字符串头部的所有空白字符。空白字符是指" \t\r\n\f\v"。lstrip会生成并返回加工后的字符串。lstrip!会修改self本身并返回结果。如果没有删除空白字符,则返回nil。" test ".lstrip=>"test "rstriprstrip!删除字符串尾部的所有空白字符。空白字符是指" \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=448swapcaseswapcase!将所有的大写字母改为小写字母,小写字母改为大写字母。"TesT".swapcase=>"tESt"to_f将字符串看作是10进制数形式,并将其变为浮点数Float。"123".to_f=>123.0to_ito_i(base)将字符串看作是10进制数形式,并将其变为整数。"123".to_i=>123to_sto_str返回self。tr(search, replace)tr!(search, replace)若字符串中包含search字符串中的字符时,就将其替换为replace字符串中相应的字符。"test".tr("es","aa")=>"taat"unpack(template)按照template字符串的规则,把被pack起来的字符串unpack开来,并以数组的形式返回其结果."test".unpack("a")=>["t"]upcaseupcase!在ASCII字符串的范围内,将所有字母都变为大写形式。upto(max) {|s| ... }在从self到max的范围内,依次取出“下一个字符串”后将其传给块,进行迭代操作。"a".upto("e") {|s| puts s}abcde=>"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")=>aRegexp.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]=> nilRegexp.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 =~ stringself = = = 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=>-1source生成并返回正则表达式的原本的字符串形式。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)...endRange.new(first,last[, exclude_end])生成并返回一个从first到last的范围对象。若exclude_end为真,则该对象不包含范围终点。若省略exclude_end,则包含范围终点。生成对象时,会执行 first <=> last 以检查参数的合法性。Range.new(1,5)=>1..5Range.new(1,5,true)=>1...5Range.new(1,5,false)=>1..5self === otherinclude?(other)若other在范围内则返回真。===主要用在case句的比较中.r1=Range.new(1,5)r1 === 2=>truer1.include?(5.1)=>false比较字符串时,include?将按照字典顺序进行比较("a" .. "c").include?("ba")=> true("a" .. "c").member?("ba")=> falsebeginfirst返回最初的元素。r1.begin=>1each {|item| ... }对范围内的元素进行迭代操作。r1.each{|n| puts n}12345=>1..5endlast返回范围终点。这与范围对象是否包含范围终点无关。(1..5).end=> 5(1...5).last=> 5exclude_end?范围对象不包含范围终点时返回真。(1..5).exclude_end?=> false(1...5).exclude_end?=> truestep([s]) {|item| ... }以s的步长对范围内的元素进行迭代操作。s是正整数。默认值为1。(1..5).step(2) {|n| puts n}135=>1..5(1...5).step(2) {|n| puts n}13=>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 <=> otherself = = otherself < otherself <= otherself > otherself >= other比较操作符.~ self 非self | other 或self & other 与self ^ other 异或位操作符.self << bitsself >> bits移位操作符. 向右(左)移动bits位.[]返回数组[1.0]=>[1.0]+ self返回self+1=>1+-1=>-1- self反转self的符号后将其返回.-1=>-1--1=>1abs返回self的绝对值.-1.abs=>1ceil返回一个等于或大于self的最小的整数.1.3.ceil=>2chr返回数字对应的字符.68.chr=>"D"coerce(number)将number变为可直接与自己进行计算的类型,然后将其存入形如[number, self]的数组并返回它.a=1a.coerce(2.0)=>[2.0, 1.0]div(other)返回self除以other的整数商.3.div(2)=> 1divmod(other)以数组[q, m]的形式返回self除以other所得的商(q)和余数(m).7.divmod(2)=> [3,1]downto(min) {|n| ... }循环起点为self,步长为-1,循环终点为min5.downto(1) {|n| puts n}54321=>5eql?是否相等1.eql?(2)=>falsefloor返回一个不超过self的最大的整数.1.2.floor=>11.2.ceil=>2finite?若某数值既非∞又非NaN则返回真1.0.finite?=>truehash返回数值的hash1.hash=>167445871infinite?若某数值为+∞则返回1, 若为-∞则返回-1, 除此以外返回nil.浮点数除以0得∞.1.0.infinite?=>nilinteger?若self为整数则返回真.-1.ineger?=>trueid2name (no method)返回与Symbol对象的整数值(可用Symbol#to_i获得该整数值)相对应的字符串. 若没有与整数相对应的符号的话就返回nil.modulo(other)返回self除以other后的余数m3.divmod(4)=>[0,3]3.modulo(4)=>3nan?当某数值为NaN(Not a number)时返回真. 浮点数的0除以0得NaN.1.0.nan?=>falsenext返回下一个紧跟的整数,等同于succ3.next=>4nonzero?0则返回nil,非0则返回self.1.nozero?=>1quo(other)除法运算,它会尽量返回一个接近实数商(quotient)的值.1.quo(3)=>(1/3)remainder(other)返回self除以other后的余数r3.divmod(1)=>[3,0]3.remainder(1)=>0round返回最接近self的整数.1.4.round=>11.5.round=>2size返回所占的bit数1.size=>422342342342342324.size=>8succ返回下一个紧跟的整数3.succ=>4times {|n| ... }循环self(从0到self-1)次5.times {|n| puts n}01234=>5to_ito_int返回self的整数部分.1.3.to_int=>1to_f将数值变为浮点数(Float).1.to_f=>1.0to_sto_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=>1zero?若为0则返回真.1.3.zero?=>falsestep(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.11.21.31.41.5upto(max) {|n| ... }循环起点为self,步长为1,循环终点为max.0.upto(5) {|n| puts n}012345=>0大多数与数值有关的方法都会在子类中得到重新定义. 这一方面是为了提高效率,另一方面是因为在上级抽象类中无法定义具体细节所致. 请参考下表来了解一下到底各个类中有些什么方法. -
Ruby语言入门(18)- 内部类 -MatchData
2013-02-05 15:22:54
MatchData为处理与正则表达式的匹配过程相关的信息而设置的类. 可以通过下列途径得到该类的实例:Regexp.last_matchRegexp#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)=>nilend(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)=>nilcaptures返回一个包含$1,$2,...的数组. 与to_a不同的是,它不含$&. 若群组没有匹配部分,则相应的数组元素为nil./(this)(is)(a)(TEST)?/ =~ "thisisatest"$~.to_a=> ["thisisa", "this", "is", "a", nil]$&=>"thisisa"$~.captures=>["this", "is", "a", nil]lengthsize返回子字符串的数量(与self.to_a.size相同).$~.size=>5offset(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 +0800File.ctime("c:\\test.txt")=>2013-02-04 16:33:08 +0800File.mtime("c:\\test.txt")=>2013-02-04 17:08:40 +0800File.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")=>1File.delete("c:\\test.txt", "c:\\test1.txt", "c:\\test2.txt")=>3File.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")=>trueFile.fnmatch("c:/*", "c:/test.txt")=>trueFile.fnmatch("c:/", "c:/test.txt")=>falseflags中可以任意使用下列常数(定义在File::Constants模块中)中的若干个来改变模式匹配的运作情况。flags的默认值为0(不指定标识)。FNM_NOESCAPE 将转义字符`\'看作普通字符。File.fnmatch('\*', '\a')=> falseFile.fnmatch('\*', '\a', File::FNM_NOESCAPE)=> trueFNM_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)判断指定文件的一些属性和判断。实例方法atimectimemtime它们分别返回:文件的最终访问时间/文件状态的最终变更时间/最终更新时间myfile = File.new("c:/test.txt")myflie.atime=>2013-02-04 18:40:21 +0800chmod(mode)将文件模式修改为mode.若修改成功则返回0.myfile.chmod(112211)=>0chown(owner, group)修改文件的owner和group.只有超级用户才能修改文件的owner和group.修改成功则返回0.myfile.chown(1, 223)=>0flock(operation)锁定文件. 锁定成功时返回0.可用的operation列表:LOCK_SH 共享锁. 若干个进程可同时共享锁定.LOCK_EX 排它锁.在某时刻,只有一个进程能控制锁.LOCK_UN 解锁.LOCK_NB 非阻塞模式.myfile.flock(File::LOCK_SH)=>0path以字符串形式返回打开文件时使用的路径.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_SEPARATORPATH环境变量的元素分隔符.在UNIX中是":",而在MS-DOS等系统中是";".SEPARATORSeparator文件路径的分隔符. 例如,在将路径名传给处理文件的方法时就会用到它. 该分隔符使得脚本内的路径名的格式统一且不受环境的影响.其值为"/".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?# childs = getsprint "child output: " + sexitend# parentio.puts "test"puts io.gets=> "child output: test\n"io.close带块的例子p IO.popen("-", "r+") {|io|if io# parentio.puts "test"io.getselse# childs = getsputs "child output: " + send}=> "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+")=>3newff = IO.new(newfile)=>#<IO:fd 4>self << object输出object。可以像下面这样使用一连串的<<:newfile = IO.systemopen("c:\\test.txt")=>3newff = IO.new(newfile, "a+")=>#<IO:fd 4>newff <<1<<"test"<<"\n"binmode将流变为二进制模式。new1 = newff.binmodeclonedup返回一个全新的IO对象,该对象与receiver使用同一个IOnew2 = newff.cloneclose关闭输入输出端口。new2.closeclose_read关闭读取用的IO。主要用在管道或读写两用的IO对象上。new2.close_readclose_write关闭写入用的IO。new2.close_writeclosed?若端口已被关闭则返回真。new.closed?each([rs]) {|line| ... }each_line([rs]) {|line| ... }每次从IO端口读入1行来进行相关处理的迭代器。each_byte {|ch| ... }每次从IO端口读入1字节的内容。eofeof?若流(stream)到达文件末端时返回真.fcntl(cmd[, arg])将对IO执行系统调用fcntl(2)。fsync对写入用的IO执行系统调用fsync(2).filenoto_i返回文件描述符的号码。newfile.fileno=>2flush刷新IO端口的内部缓冲区。newfile.flushgetc从IO端口读入1个字符,并返回该字符对应的Fixnum。gets([rs])读入一行,若成功的话就返回读入的字符串。ioctl(cmd[, arg])对IO执行系统调用ioctl,并返回其结果。isattytty?若输出输入端口已与tty结合时,返回真。lineno返回当前的行号。lineno=number设定行号。pid若是由IO.popen所生成的IO端口时,则返回子进程的进程ID。除此以外返回nil。postell返回文件指针的当前位置。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)charwrite(str)对IO端口输出str。若str并非字符串,将使用to_s尝试将其变为字符串。常数:SEEK_CURSEEK_ENDSEEK_SETnewfile.SEEK_CURnewfile.SEEK_ENDnewfile.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].transposeputs Hash[*alist.flatten]=> {1=>"a", 2=>"b", 3=>"c"}无法使用上述的方法时:h = Hash.newalist = [[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]=valuestore(key,value)将索引为key的元素值设为value.返回value.h[2]="fool"h[2]=>"fool"h.store(3,"test")h[3]=>"test"clear清空哈希表的内容. 返回self.h.clear=>{}clonedup返回一个与receiver内容一致的新哈希表. 对冻结的哈希表进行clone时将返回一个同样的冻结的哈希表.但使用dup时,将返回内容相同但却并未冻结的哈希表.b=h.cloneb[1]=>"foo"defaultdefault([key])返回哈希表的默认值.h.default=>nilh.default("123")=>fooh("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=> nildelete(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返回一个包含所有索引的数组.lengthsize返回哈希表中的元素的个数.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::Statcfile=b.new("c:\\test.jpg")=> $<Fiel::Stat dev=0x2.........+0800>self <=> other比较文件的最终更新时间.若self比other新就返回正数,相等就返回0,旧则返回负数.afile<=>cfile=>0ftype返回一个表示文件类型的字符串.该字符串应是下列之一:- "file"
- "directory"
- "characterSpecial"
- "blockSpecial"
- "fifo"
- "link"
- "socket"
- "unknown"
afile.ftype=>"file"dev设备号(文件系统)afile.dev=>2dev_majordev的major号码部分afile.dev_major=>nildev_minordev的minor号码部分afile.dev_minor=>nilinoi-node 号afile.ino=>0mode文件模式afile.mode=>33188nlinkhard link数afile.nlink=>1uidowner的userIDafile.uid=>0gidowner的groupIDafile.gid=>0rdev设备类型afile.rdev=>2rdev_majorrdev的major号码部分afile.rdev_major=>nilrdev_minorrdev的minor号码部分afile.rdev_minor=>nilsize文件大小(以字节为单位)afile.size=>25780blksize理想的I/O的块大小afile.blksize=>nilblocks被分配的块数afile.blocks=>nilatime最终访问时间afile.atime=>2013-02-04 14:17:43 +0800mtime最终更新时间afile.atime=>2013-01-21 16:07:43 +0800ctime最终i-node变更时间afile.ctime=>2013-01-21 16:07:43 +0800下列判断方法等同于那些与FileTest同名的模块函数. 虽然它们的参数中使用的是文件名,但却对Stat本身进行判断.directory?若为目录则为真afile.directory?=>falsereadable?若可读则为真afile.readable?=>truereadable_real?若实用户/实组可以读取就为真afile.readable_real?=>truewritable?若可写则返回真afile.writable?=>truewritable_real?若实用户/实组可以写入就为真afile.writable?=>trueexecutable?若有效用户/组ID能执行就为真afile.executable?=>falseexecutable_real?若实用户/组ID能执行就为真afile.executable_real?=>falsefile?若为普通文件则返回真afile.file?=>truezero?若大小为0就为真afile.file?=>falsesize?文件大小(若为0则为伪)afile.size?=>25780owned?若属于自己则为真afile.owned?=>truegrpowned?若组ID与执行组ID相等则为真afile.grpowned?=>falsepipe?若是带名称管道(FIFO)则为真afile.pipe?=>falsesymlink?若是符号连接则为真afile.symlink?=>falsesocket?若是socket则为真afile.socket?=>falseblockdev?若是块专用文件则为真afile.blockdev?=>falsechardev?若是字符专用文件则为真afile.chardev?=>falsesetuid?若被setuid则为真afile.setuid?=>falsesetgid?若被setgid则为真afile.setgid?=>falsesticky?若设定了粘着位(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.getwdDir.pwd返回当前目录的完整路径。Dir.chdir([path])Dir.chdir([path]) {|path| ... }将当前目录改为path。若省略path时,则会调用环境变量HOME或LOGDIR。若它们中包含设定值时,就将当前目录改为它们的值。若当前目录变更成功就返回0,若失败则引发Errno::EXXX异常。若指定了块的话,则只会在块的执行过程中变更当前目录。Dir.pwd=>"c:/"Dir.chdir("c:\\Sites")=>0Dir.pwd=>"c:/Sites"Dir.chroot(path)将根目录改为path。只有超级用户才能改变根目录。您将无法还原到原来的根目录。根目录变更成功时返回0,失败时将引发Errno::EXXX异常。Dir.mkdir(path[, mode])生成新目录path.若成功生成新目录就返回0,若失败则引发Errno::EXXX异常。Dir.mkdir("c:\\test")=>0Dir.delete(path)Dir.rmdir(path)Dir.unlink(path)删除目录。目录必须为空。若删除成功则返回0,若失败则引发Errno::EXXX异常。Dir.delete("c:\\test")=>0Dir.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=>nila.tellIOError: closed directoryeach {|item| ... }为目录中的各个元素计算块的内容。返回self。a.each {|item| puts item}...chromedriver.logtodo=> #<Dir:c:\Sites>path以字符串形式返回当前打开目录的路径名。a.path=>"c:\\Sites"postell以整数形式返回目录流的当前位置。a.pos=>4pos=(pos)seek(pos)将目录流的读入位置移动到pos。pos必须是使用Dir#tell所得到值。pos=返回右边,而seek则返回self。a.seek(2)=> #<Dir:c:\Sites>a.tell=> 2read从目录流中读出并返回下一个元素。若读到最后一个元素则返回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=>trueArray.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]=>2a[-1]=>3self[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]=6a=>[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]=6a=>[1,6]a=[0, 1, 2, 3, 4, 5]a[0..2]=["a", "b"]a=> ["a", "b", 3, 4, 5]a[2..4] = nila=> ["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]=6a=>[1,6]a=[0, 1, 2, 3]a[1, 2]=['a', 'b', 'c']a=> [0, "a", "b", "c", 3]a[2, 1] = 99a=> [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)=>nilat(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}123=>[1,2,3]each_index {|index| .... }依次使用每个元素的索引来对块进行计算a=[1, 2, 3]a.each_index{|i|puts i}123=>[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)=>2fill(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=>1a.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)=>0insert(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=>3a.lasst(2)=>[2,3]length/size返回数组长度。若数组为空则返回0.a=[1, 2, 3]a.length=>3a.size=>3nitems返回非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)=> 3shift删除数组的首元素并返回它。剩余元素依次提前。若数组为空返回nil。slice(pos[, len])/slice(start..last)与self[]相同。slice!(pos[, len])/slice!(start..last)删除指定的元素并返回它。若没有可删除的元素时返回nil。sortsort!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)将对象输出到 outeql?/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对象并返回该对象methodspublic_methodsprivate_methodsprotected_methodsmethods([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_methodssingleton_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_VERSIONRuby版本RUBY_RELEASE_DATERuby发布日期RUBY_PLATFORMRuby平台信息 -
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: 输出所有警告
$KCODERuby可识别的多字节字符串的编码。变量值为"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=> ArrayFloat(arg)将参数变为浮点数(Float)并返回结果.puts Float("10")=> 10.0Integer(arg)将参数变为整数(Fixnum,Bignum)并返回结果.对数值,字符串以外的对象使用to_i方法。puts Integer("0d10")=> 10String(arg)调用arg.to_s将参数变为字符串并返回结果。a=String("test")a.class=> Stringabort/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, 25some_process()}puts ret#=> 25chop/chop!将内部变量$_末尾的字符去掉(若末尾是"\r\n"则去掉2个字符)。chop不改变内部变量$_的内容,chop!改变内部变量$_的内容。chomp([rs])/chomp!([rs])去掉位于内部变量$_末尾且由rs指定的字符。eval(expr[, binding[, fname[, lineno=1]]])把字符串expr当作Ruby程序来运行并返回其结果。若给第二参数传递Proc对象或Binding对象的话,将在生成该对象的环境中对字符串进行计算。def fooa = 1bindingendeval("p a", foo)# => 1exec(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...ensuref.closeendp(obj, [obj2, ...])等同于print。print([arg1[, arg2, ...]])依次输出参数。若没有得到参数则输出变量$_的值。若把非字符串对象传给参数的话,将对该对象使用to_s方法将其变为字符串后输出。若是nil的话则输出字符串"nil"。printf([port, ]format[, arg[, ...]])类似于C语言的printf,它将按照format将参数格式化为字符串,然后输出到$>。当第一参数是IO的子类的实例时,将对该对象进行输出。若没有任何参数时,将不作反应。proc { ... }lambda { ... }proclambda在给出的块中生成过程对象(Proc的实例)并返回它(等同于Proc.new)。若没有给出块的话,将返回主调(caller)方法所指的块。若主调方法没有块时,将引发ArgumentError异常。putc(ch)将字符ch输出到$>。若ch是数字的话,将输出对应于0~255的字符。若ch是字符串的话,将输出字符串中的第一个字符。puts([obj[, obj2[, ....]]] )依次将obj和换行符输出到$>。若没有参数的话则只会输出换行符。若参数是数组,则依次输出数组元素和换行符。若将既非数组又非字符串的对象传递给参数时,将尝试使用to_ary方法将其化为数组,再使用to_s方法将其化为字符串。若是nil则输出字符串"nil"。raiseraise(exception)raise(message)raise(error_type, message [, backtrace])fail(error_type, message [, backtrace])引发异常,若没有参数时,将再次引发本线程本块内最后被rescue的异常对象($!)。若没有这样的异常时,将引发RuntimeError异常。beginopen("nonexist")rescueraise # => `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 MyExceptiondef exceptionArgumentError.newendendraise MyException.new# => -:7: ArgumentError (ArgumentError)若采用第二种形式来指定参数时,该参数将被赋予exception方法。class MyExceptiondef exception(mesg)ArgumentError.new(mesg)endendraise 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表达式 ... ]endif age >= 12 thenprint "adult fee\n"elseif age <6 thenprint "no fee\n"elseprint "child fee\n"endif 修饰句print "adult fee\n" if age >= 12unless 表达式 [then]表达式 ...[else表达式 ... ]endunless baby?feed_meatelsefeed_milkendunless 修饰句print "stop\n" unless valid(passwd)case [表达式][when 表达式 [, 表达式] ...[, `*' 表达式] [then]表达式..]..[when `*' 表达式 [then]表达式..]..[else表达式..]endcase $agewhen 0 .. 2"baby"when 3 .. 6"little child"when 7 .. 12"child"when 13 .. 18"youth"else"adult"end循环while 表达式 [do]...endary = [0,2,4,8,16,32,64,128,256,512,1024]i = 0while i < ary.lengthprint ary[i]i += 1end表达式 while 表达式sleep(60) while io_not_ready?until 表达式 [do]...enduntil f.eof?print f.getsend表达式 until 表达式print(f.gets) until f.eof?for 表达式 in 表达式 [do]表达式..endfor i in [1, 2, 3]print i*2, "\n"end过程break将退出最内层的循环。所谓循环是指,下列之一whileuntilfor迭代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 stringnext lineEOS等同于:print " the string\n next line\n"可以当作一个整体进行应用:# 将集成字符串用作被调p <<LABEL.upcasethe lower case stringLABEL# => "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__的行(若前后出现空白字符将无法辨认)
标题搜索
我的存档
数据统计
- 访问量: 148961
- 日志数: 185
- 文件数: 6
- 建立时间: 2007-08-06
- 更新时间: 2015-01-06