严格说来,Ruby中没有函数.但Kernel模块中定义的方法(可以在任何地方用做函数,因此)可被其他语言当做函数来调用.若您对这些方法进行再定义时,就必需考虑到对其他方面的影响.
` str
把字符串str当做外部命令来运行,并以字符串方式返回命令的输出.使用`str`形式来调用该方法(还可以使用%x(...)表示法进行调用.请参考命令输出).
可以使用$?来了解命令的结束状态.
若您只想执行命令,而不需要得到命令输出时,可以使用system.如果是那些终端控制命令的话,`command`可能会运行失败.
Array(arg)
调用 arg.to_ary 或 arg.to_a 将参数转为数组并返回结果.若变换后没有得到数组就会引发TypeError异常.
若arg中没有to_ary或to_a方法的话,就返回只包含一个元素的数组[arg].
Float(arg)
将参数变为浮点数(Float)并返回结果.
若将不能转为整数或浮点数的字符串传递给参数的话,会引发ArgumentError异常.
请参考String#to_f.
p Float("10") # => 10.0
p Float("10e2") # => 1000.0
p Float("1e-2") # => 0.01
p Float(".1") # => 0.1
p Float("nan") # => NaN (ruby 1.7 特性: => invalid value (ArgumentError))
p Float("INF") # => Infinity (ruby 1.7 特性: => invalid value (ArgumentError))
p Float("-Inf") # => -Infinity (ruby 1.7 特性: => invalid value (ArgumentError))
p Float(("10" * 1000).to_f) # => Infinity
p Float("0xa.a") # => 10.625 # (ruby 1.7 特性: => invalid value (ArgumentError))
p Float(" \n10") # => 10.0 # 前面的空白被忽略
p Float("1_0_0") # => 100.0 # `_' 也被看做是数值要素
p Float("") # => invalid value (ArgumentError)
p Float(nil) # => 0.0 # ruby1.7特性: cannot convert nil into Float (TypeError)
p Float(Object.new) # => cannot convert Object into Float (TypeError)
Integer(arg)
将参数变为整数(Fixnum,Bignum)并返回结果.对数值,字符串以外的对象使用to_i方法(Ruby 1.7 特性:在1.7中是to_int).若变换结果不是整数(Integer的子类)就会引发TypeError异常.
若参数是字符串的话,将按其前缀,如0x,0b,0等分别决定要按照16进制,2进制或是8进制的标准来处理该字符串.
若把不能变为整数的字符串传递给参数时,将引发ArgumentError异常.
p Integer(10.1) # => 10
p Integer(10.8) # => 10
p Integer("10") # => 10
p Integer("10_0_0") # => 1000
p Integer("10__0") # => 100
# => invalid value for Integer: "10__0" (ArgumentError) (ruby 1.7 特性)
p Integer("_10") # => invalid value for Integer: "_10" (ArgumentError)
p Integer("10_") # => invalid value for Integer: "10_" (ArgumentError)
p Integer("0d10") # => invalid value for Integer: "0d10" (ArgumentError)
# => 10 (ruby 1.7 特性)
p Integer("010") # => 8
p Integer("0o10") # => invalid value for Integer: "0o10" (ArgumentError) (ruby 1.7 特性)
# => 8
p Integer("0x10") # => 16
p Integer("0b10") # => 2
p Integer(" \n10\t ") # => 10
p Integer("") # => `Integer': invalid value for Integer: "" (ArgumentError)
p Integer(nil) # => 0
p Integer(Object.new) # => cannot convert Object into Integer (TypeError)
请参考String#hex,String#oct,String#to_i.
String(arg)
调用arg.to_s将参数变为字符串并返回结果。若变换后的结果并非字符串的话，会引发TypeError异常。若arg已经是字符串的话，则不作任何处理直接返回arg。
abort
abort(message) ((<ruby 1.7 特性>))
以非正常方式结束Ruby程序的运行。它与Exit的区别在于，调用时若$!不为nil的话，就将异常消息输出到标准错误输出当中；另外，程序的结束status始终都是EXIT_FAILURE(在绝大多数环境中都是1)。
ruby 1.7 特性:若指定了message参数的话，就将message赋值给SystemExit#message后输出到标准错误输出中。
at_exit { .... }
在解释器结束工作之前执行指定的块。除去at_exit是个方法这点差异之外，它与END块所进行工作基本相同。一旦注册了要进行的处理内容之后就不能取消。请参考结束时的相关处理。
Proc对象返回注册的处理内容。
autoload(const_name, feature)
autoload?(const_name) ((<ruby 1.8 feature>))
在首次调用常数const_name时会require feature。const_name可以是字符串或Symbol。而且const_name中不能包含"::"操作符(即只能指定顶层的常数)。
返回nil。
ruby 1.8 特性：可以autoload任何类／模块的常数。const_name中还是不能有"::"操作符，可以像下面这样定义。(实际上是调用了Module#autoload)
------- /tmp/foo.rb --------- class Foo class Bar end end ----- end of /tmp/foo.rb ---- class Foo autoload :Bar, '/tmp/foo.rb' end p Foo::Bar
另外，还可以下面这样定义。
class Foo end Foo.autoload :Bar, '/tmp/foo.rb' p Foo::Bar
autoload?的功能是，若autoload常数尚未定义(没被load)时，返回其路径名。另外，若已经load的话就返回nil。
------- /tmp/foo.rb --------- class Foo class Bar end end ----- end of /tmp/foo.rb ---- class Foo end Foo.autoload :Bar, '/tmp/foo.rb' p Foo.autoload?(:Bar) # => "/tmp/foo.rb" p Foo::Bar # => Foo::Bar p Foo.autoload?(:Bar) # => nil
请注意下例。在autoload的库中，嵌套内的常数还没有被定义。乍看起来好像会正常运行，实则不然(出现了警告消息)。
------- /tmp/bar.rb ---------
class Bar
end
----- end of /tmp/bar.rb ----
class Foo
autoload :Bar, '/tmp/bar.rb'
end
p Foo::Bar
p Foo.autoload?(:Bar)
# => -:4: warning: toplevel constant Bar referenced by Foo::Bar
Bar
nil
若不使用嵌套的话，可以把上例简写为
class Foo
end
class Bar
end
p Foo::Bar
# => -:5: warning: toplevel constant Bar referenced by Foo::Bar
Bar
binding
生成并返回Binding对象。该对象包含变量、方法等的环境信息，它通常用作Eval的第二参数。
caller([level])
以$@的back trace(字符串数组)形式返回level层上(省略参数时为1)的调用者的信息。若是顶层的话就返回空数组。将caller的返回值代入$@就可以设定异常的发生位置。
def foo p caller(0) p caller(1) p caller(2) p caller(3) end def bar foo end bar => ["-:2:in `foo'", "-:9:in `bar'", "-:12"] ["-:9:in `bar'", "-:12"] ["-:12"] []
下列函数可以从caller的要素中抽取并返回[文件名、行号、方法名]。
def parse_caller(at)
if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
file = $1
line = $2.to_i
method = $3
[file, line, method]
end
end
def foo
p parse_caller(caller.first)
end
def bar
foo
p parse_caller(caller.first)
end
bar
p parse_caller(caller.first)
=> ["-", 15, "bar"]
["-", 19, nil]
nil
当$DEBUG为真时，debug函数非常有用。以下是该函数例程。
def debug(*args) p [caller.first, *args] if $DEBUG end debug "debug information" => ["-:5", "debug information"]
callcc {|cont| .... }
请参考Continuation。
catch(tag) {|tag| .... }
运行块并返回它的值。若在块的运行过程中，遇到与tag同名的throw的话，将把throw的第二参数的值作为返回值。
例如下例代码在运行过程中不会调用some_process，同时catch的值是25，而并非10。
ret = catch(:exit) {
throw :exit, 25
some_process()
10
}
p ret #=> 25
嵌套的循环不会因为遇到break就一下子跳出。这时可使用catch或异常。
catch(:loop1) {
for i in 1..2
for j in 1..2
throw :loop1, j
end
end
}
chop
chop!
将内部变量$_末尾的字符去掉(若末尾是"\r\n"则去掉2个字符)。chop!将改变字符串本身并返回结果。若没有可以去掉的字符则返回nil。
请参考String#chop了解详情。chop函数与$_.chop之间存在以下区别。
chomp([rs])
chomp!([rs])
去掉位于内部变量$_末尾且由rs指定的字符。chomp!将改变字符串本身并返回结果。若没有可被去掉的字符串则返回nil。rs的默认值为$/
请参考String#chomp了解详情。chomp函数与$_.chomp之间存在以下区别。
eval(expr[, binding[, fname[, lineno=1]]])
把字符串expr当作Ruby程序来运行并返回其结果。若给第二参数传递Proc对象或Binding对象的话，将在生成该对象的环境中对字符串进行计算。请参考binding。
def foo
a = 1
binding
end
eval("p a", foo) # => 1
若指定了fname 和 lineno的话，将假定字符串位于fname文件lineno行，并且进行编译。这时可以显示栈跟踪(stack trace)等信息。
exec(command)
exec(program[, arg1[, arg2[, ...]]])
执行由command指定的命令.该命令(或shell,详见下文)将变成进程执行的代码,所以一旦启动成功,就不会再从该函数中返回.若启动失败,控制权重新回归ruby解释器,然后会引发Errno::EXXX异常.
在第一种语句中,若command中包含shell的元字符(* ? {} [] <> () ~ & | \ $ ; ' ` " \n)的话,则经由shell执行命令.除此之外,将由解释器直接执行.
使用第二种语句时,通常不经过shell就执行命令.此时,将把空字符或shell的元字符等原般不动地传递给program的参数.若首个参数是包含两个元素的数组时,第一个元素的字符串将成为启动程序时的路径,而第二个元素将成为程序名的"别名".
ruby 1.8 特性:即使第一个元素不是完整路径,也会自动从环境变量PATH中开始搜索.
exit([status])
终止Ruby程序的运行.若向status传递了一个整数的话,该整数就将成为Ruby命令的结束状态值.默认的结束状态值是0.
exit通过引发SystemExit异常来结束程序的运行.若有必要的话,可以使用rescue部分来捕捉到它.
ruby 1.8 特性:若status为true的话,就以EXIT_SUCCESS作为结束状态值.若status为false的话,就以EXIT_FAILURE作为结束状态值.默认的结束状态值已被改为EXIT_SUCCESS.
exit!([status])
以整数status为结束状态值来终止Ruby程序的运行.默认的结束状态值为-1.
exit!与exit不同,它不会进行异常处理.在fork之后,若想终止子进程时可以使用该语句.
ruby 1.8 特性:若status为true的话,就以EXIT_SUCCESS作为结束状态值.若status为false的话,就以EXIT_FAILURE作为结束状态值.默认的结束状态值已被改为EXIT_FAILURE.
fork
fork { ... }
使用fork(2)系统调用来制作进程的拷贝.若在父进程中将返回子进程的进程ID,若在子进程中则返回nil.若指定一个块之后再进行调用,则会在生成的子进程中对该块进行计算.
gets([rs])
readline([rs])
Ruby解释器在运行时,会把从参数那里得到的文件(若没有的话,就利用标准输入)假设成一个虚拟文件(可以使用内部变量$<或ARGF访问该虚拟文件),然后从该虚拟文件中读入一行,并返回字符串.若到达文件尾部时返回nil.
使用rs指定的字符串作为行的切分符号.rs的默认值取自内部变量$/.读入的字符串也被存入内部变量$_中.
若将rs设为nil的话,则意味着读入文件的全部内容而忽略行的切分.若设为空字符串""的话,会把连续的换行当做行的切分符(段落模式).
readline的功能与gets相同,但是当它遇到文件结尾时会引发EOFError异常.
global_variables
返回程序中已定义的全局变量(以'$'开头的变量)名的数组.
另外请参考local_variables, Object#instance_variables, Module.constants, Module#constants, Module#class_variables.
gsub(pattern[, replace])
gsub!(pattern[, replace])
gsub(pattern) {|matched| ... }
gsub!(pattern) {|matched| ... }
在内部变量$_所包含的字符串中,将符合pattern的部分替换为replace,然后返回结果.若省略参数replace时,该方法将演变为迭代器,以块的计算值进行替换操作.将匹配的字符串以参数的形式传递给块.
$_ = "foobar"
p gsub(/o+/) {|m|
m.upcase
}
# => "fOObar"
gsub!将改写$_所包含的字符串本身.请参考String#gsub来获得更多资讯.String#gsub和gsub之间存在以下差异.
iterator? ((<obsolete>))
block_given?
若某方法带块则返回真,否则返回伪.
load(file[, priv])
加载Ruby程序file并予以执行.若file是绝对路径,则从file开始加载.若file是相对路径,则依次搜索内部变量$:所指定的路径,并加载第一个搜索到的文件.此时,若$:中的元素是以"~"(tilde)开头的话,就把它扩展为环境变量HOME的值.
若可选参数priv的值为真,则在内部生成一个无名模块作为顶层来进行加载和运行,这便不会污染全局名字空间了.
若加载成功则返回true,若失败则引发LoadError异常.
[require与load之间的区别]
require对于相同的文件只会加载一次,而load则是无条件的加载.另外,require会自动补全扩展名,如.rb或.so等.而load则没有该功能.一般的典型用法是,使用require加载库,而使用load加载配置文件等.
# 用例
load "#{ENV['HOME']}/.myapprc"
load "/etc/myapprc"
另外,如果想在特定目录中加载文件的话,写成 load 'filename' 就不恰当了.这时请务必使用绝对路径.
local_variables
返回当前作用域中已定义的局部变量名的数组.
另外,请参考global_variables, Object#instance_variables, Module.constants, Module#constants, Module#class_variables.
loop { ... }
(只要不被中断就)反复对块进行计算.
open(file[, mode[, perm]])
open(file[, mode[, perm]]) {|io| ... }
打开file并返回File对象.mode可以是下列字符串或者整数(File::Constants模块的常数的逻辑和).省略时默认为"r".
若有"+"的话,就以读写两用模式(RDWR)打开文件.
可在上述任意一项后面添加"b"(如"r+b")标志(如果是整数就是File::BINARY).此时,将以二进制方式打开文件(只限于以文本/二进制方式来区分文件的系统).
第三参数perm与open(2)的第三参数是一样的，它以整数的形式说明了文件在CREAT时的访问权限。若第二参数不是数值形式的话，该参数将被忽略。它的默认值是0666。
若文件名以`|'开头时，其后的字符串会被当作命令来执行。另外，将生成管线(pipeline)来应对命令的标准输入输出。
若文件名为"|-"的话，open将生成Ruby的子进程，并返回与子进程之间的管道(pipe)(IO对象)。(此时的运作与IO.popen相同。File.open没有生成管线的功能)。
注意: 与Perl不同的是，命令通常是以`|'开头的。
当open与块同时被调用时，open将打开文件并执行块，当块的运行终止后就关闭文件。此时返回块的计算结果。请看下例。
open(path, mode) do |f| ... end # 等效代码 f = open(path, mode) begin ... ensure f.close end
p(obj, [obj2, ...])
以通俗易懂的方式输出obj。等同于以下代码。(请参考Object#inspect)
print obj.inspect, "\n", obj2.inspect, "\n", ...
返回nil。
print([arg1[, arg2, ...]])
依次输出参数。若没有得到参数则输出变量$_的值。若把非字符串对象传给参数的话，将对该对象使用to_s方法将其变为字符串后输出。若是nil的话则输出字符串"nil"。
若给变量$;(输出字段分隔符)指定了一个非nil的值的话，将在各个参数之间输出该分隔符。若给变量$\(输出记录分隔符)指定了一个非nil的值的话，将在最后输出它。
返回nil。
printf([port, ]format[, arg[, ...]])
类似于C语言的printf，它将按照format将参数格式化为字符串，然后输出到$>。当第一参数是IO的子类的实例时，将对该对象进行输出。若没有任何参数时，将不作反应。
请参考sprintf格式来了解Ruby中format字符串的扩展问题。
返回nil。
proc { ... }
lambda { ... }
proc
lambda
在给出的块中生成过程对象(Proc的实例)并返回它(等同于Proc.new)。
若没有给出块的话，将返回主调(caller)方法所指的块。若主调方法没有块时，将引发ArgumentError异常。
putc(ch)
将字符ch输出到$>。若ch是数字的话，将输出对应于0～255的字符。若ch是字符串的话，将输出字符串中的第一个字符。
返回ch。
putc("ch")
putc(?c)
putc(99)
# => ccc
puts([obj[, obj2[, ....]]] )
依次将obj和换行符输出到$>。若没有参数的话则只会输出换行符。
若参数是数组，则依次输出数组元素和换行符。若将既非数组又非字符串的对象传递给参数时，将尝试使用to_ary方法将其化为数组，再使用to_s方法将其化为字符串。若是nil则输出字符串"nil"。
若参数是以换行符结尾时，puts将不再输出换行符。
puts "foo", "bar\n", "baz" puts "" # 只输出换行 puts # 只输出换行 puts "foo" => foo bar baz foo
返回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)
exception方法必定返回异常对象。否则将引发TypeError。
发生的异常会被存入变量$!中。而发生异常时的栈跟踪信息将被存入变量$@中。
rand([max=0])
产生一个0至max(不含)之间的随机数。若未调用srand的话，就自动调用它。
若将max设为nil或0的话，将返回一个0至1(不含)的实数型Float随机数。
readlines([rs])
把从命令行参数那里得到的文件(若没有的话,就利用标准输入)假设成一个虚拟文件(ARGF)，再读入该文件的所有内容，然后以行为单位将这些内容转换为数组，最后返回该数组。
以rs所指的字符串为行的切分符。rs的默认值取自内部变量$/。
若将rs设为nil则意味着没有行切分符。若设定为空字符串""，则把连续换行当作行切分符(段落模式)。
require(feature)
从加载路径$:开始搜索Ruby库feature，若该库尚未被加载就立即加载。
Ruby库就是指Ruby脚本(*.rb)或扩展库(*.so)，若feature的扩展名被省略时，则会同时搜索这两种文件(欲知具体的搜索顺序，请参考$:)。若给出扩展名时，则只会搜索这种文件。另外，扩展库的扩展名不仅限于常用的那些，还常常使用.so。
加载库后返回true。若该库已被加载则不会重复加载，此时返回false。若加载失败则引发LoadError异常。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的不同，将使用下列之一。与第六个块参数klass相对应。
Symbol对象，它表示最后被调用的方法。在顶层中则为nil。
Symbol对象，它表示被调用／return的方法。
nil。
Symbol对象，它表示最后被调用的方法。在顶层中则为nil。
Binding对象，它表示运行中的程序的状况(context)。
根据event的不同，将使用下列之一。与第四个块参数id相对应。
Class对象，它表示最后被调用的方法的所属类。在顶层中则为false。
Class对象，它表示被调用／return的方法的所属类。
false。
Class对象，它表示最后被调用的方法的所属类。在顶层中则为false。
sleep([sec])
使程序暂停sec秒。也可以将sec设为浮点数。省略sec时，若没有显式地(SIGALRM或其他线程发出的Thread#run)终止睡眠的话，将一直sleep下去。返回值是实际睡眠的秒数(整数)。
spawn(cmd, [arg, ...]) ((<ruby 1.9 特性>))
基本上等同于system，但它不会等待子进程的结束。返回生成的子进程的进程ID。
split([sep[, limit]])
使用sep模型将$_中的字符串分割成limit个部分后转化为数组，然后返回该数组。请参考String#split以获得更多的资讯。
sprintf(format ... )
format(format ... )
采用同C语言sprintf一样的方法对format字符串进行解释，格式化参数后返回结果。使用format时，就好像使用C语言sprintf一样。
Ruby对整数的大小没有上限，因此把负数指定给%b, %o, %x时(可看作左边有无数个1)，就会显示成..f。若想以“符号加绝对值”的形式进行输出的话，就得写成%+x、% x这样。
请参考sprintf格式化来获取更多资讯。
srand([seed])
设定rand的随机数的种子，返回旧的初始值(第一次返回0)。若省略初始值时，则以当前时刻、进程ID或srand的调用次数为基础生成一个种子。
sub(pattern[, replace])
sub!(pattern[, replace])
sub(pattern) {|matched| ... }
sub!(pattern) {|matched| ... }
在内部变量$_所指的字符串中,将首个匹配pattern的部分替换为replace,然后返回结果.若省略参数replace时,该方法将变为迭代器,以块的计算值进行替换操作.将匹配的字符串以参数的形式传递给块.
sub!将改写$_所包含的字符串本身.请参考String#sub来获得更多资讯.String#sub和sub之间存在以下差异.
syscall(num, arg ... )
执行num号码所对应的系统调用。将第二参数以后的部分传给系统调用作为其参数。参数必须是字符串或整数。
请参考syscall(2)或 /usr/include/sys/syscall.h 以了解数值与系统调用的对应关系。
Ruby遵从系统调用的习惯，若syscall(2)返回-1时，引发Errno::EXXX异常。若返回其他值则不作变动。
system(command)
system(program[, arg1[, arg2[, ...]]])
执行command，成功(子进程以 status 0 的状态结束时)则返回真，失败(包括不能执行命令)则返回伪。可参照变量$?来获取结束状态值(status)。
当不能执行命令时，大多数的shell会返回状态值127。(所以$?的值为0x7f00)若没有使用shell时，Ruby子进程以状态值127结束。通常，查看$?的值即可区分是不能执行命令还是命令失败。
ruby 1.9 特性:不能执行命令时会引发Errno::EXXX异常。若使用了shell，则同上所述。
请参考exec以获取更多资讯。
另外，请参考`command`,open。
test(cmd, file1 [, file2])
进行文件测试。cmd可以是下列数值字面值或字符串(只把字符串的首字符当成命令)。
?r
可以使用有效 uid 读取文件
?w
可以使用有效 uid 写入文件
?x
可以使用有效 uid 执行文件
?o
文件的所有者是有效 uid
?G
文件的所有者group是有效 gid
?R
可以使用实 uid 读取文件
?W
可以使用实 uid 写入文件
?X
可以使用实 uid 执行文件
?O
文件的所有者是实 uid
?e
文件存在
?z
文件大小为 0
?s
文件大小非 0 (返回文件大小)
?f
文件是无格式(plain)文件
?d
文件是目录
?l
文件是符号连接
?p
文件是带名的管道(FIFO)
?S
文件是socket
?b
文件是特殊块文件
?c
文件是特殊字符文件
?u
文件中有 setuid bit
?g
文件中有 setgid bit
?k
文件中有 sticky bit
?M
返回最近更新文件时刻
?A
返回最近访问文件时刻
?C
返回文件的 inode 变更时刻
?=
文件1和文件2的最近更新时刻相同
?>
文件1的最近更新时刻要比文件2的新
?<
文件1的最近更新时刻要比文件2的旧
?-
文件2对文件1发出了硬连接指令
throw(tag[, value=nil])
跳到使用了相同的tag的catch块的终点(跳过方法)。若没有使用相同tag的catch的话，就以NameError结束线程。tag可以是字符串或符号。value将变为catch的返回值。
例:
ret = catch(:exit) {
throw :exit, 25
some_process() # 决不会被执行
10
}
p ret #=> 25
trace_var(varname, hook)
trace_var(varname) {|newval| .... }
注册钩子以监视对全局变量varname所进行的赋值。varname可以是字符串或Symbol。
这里所说的“全局变量”是指以“$”开头的变量，包括特殊变量。
调用之后，只要varname所指的全局变量被赋值，就会计算字符串或Proc对象hook。若钩子是Proc对象的话，将把块参数中的值向外传递。另外，可注册多个钩子。
若想解除跟踪的话，可以把hook设为nil，还可以使用untrace_var。
例:
trace_var(:$v) {|val| puts "$v=#{val.inspect}" }
$v = "foo" #=> $v="foo"
$v = 1 #=> $v=1
若hook为nil，将返回hook的数组(若是以块注册的话，将以Proc对象返回)。除此之外，将返回nil。
trap(signal, command)
trap(signal) { ... }
※ 在Ruby 1.8 以后的版本中，推荐使用Signal.trap。
将command注册为signal所指的中断的处理程序。signal可以是信号名字符串、Symbol或信号编号。
command可以是字符串或块。若将其设为nil、空字符串""、"SIG_IGN"或者"IGNORE"时，将忽略该信号(若可能的话)。若将其设为"SIG_DFL"或"DEFAULT"时，将进行默认的动作。若设为"EXIT"时，在接到信号之后将进行结束时的相关处理，然后以status 0 的状态结束。
还可以将signal设为0或"EXIT"等特殊值。这表示“程序结束时”。
Ruby解释器会为一些特定的信号引发异常Interrupt或SignalException。还可以使用异常处理来捕捉这些信号。
begin Process.kill :QUIT, $$ # 对自己发出SIGQUIT rescue SignalException puts "rescue #$!" end # => rescue SIGQUIT
用trap()捕捉到的信号不会引发异常。
若注册了与信号相对应的command时，trap将返回它(若是块的话，将被当作Proc对象返回。若是"IGNORE"或"DEFAULT"则返回nil)。若没有注册的话则返回nil。
ruby 1.8 特性：在执行trap之前，若注册了"IGNORE"或"DEFAULT"的话，则返回"IGNORE"、"DEFAULT"。若注册了ruby解释器无法识别的信号处理程序时将返回nil。
p trap(:INT, "p true") # => nil
p trap(:INT) { } # => "p true"
p trap(:INT, "SIG_IGN") # => #<Proc:0x401b1328>
p trap(:INT, "DEFAULT") # => nil
p trap(:INT, "EXIT") # => nil
p trap(:INT, nil) # => "EXIT"
若指定了并不存在的信号时，将引发ArgumentError异常。
untrace_var(varname[, hook])
取消与全局变量varname有关的钩子。若指定了hook的话，将只会取消该钩子。若省略hook或将其设为nil时，将取消varname所有的钩子。返回取消钩子的数组。
例:
$v = nil
trace_var(:$v) {|val| puts "$v=#{val.inspect}" }
$v = 'str' #=> $v="str"
untrace_var :$v
$v = 'str' # 不输出任何信息
warn(mesg)
ruby 1.8 特性
依次输出mesg和换行符到$stderr之中。若内部变量$VERBOSE为nil时，则不会输出。这等同于
$stderr.print mesg, "\n" unless $VERBOSE.nil?
返回nil。