内部函数（转）

严格说来,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之间存在以下区别。

• chop先拷贝$_的值，然后对拷贝进行修改，最后把这个拷贝的值重新赋值 给$_。

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

去掉位于内部变量$_ 末尾且由rs 指定的字符。chomp!将改变字符串本身并返回结果。若没有可被去掉的字符串则返回nil。rs 的默认值为$/

请参考String#chomp 了解详情。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之间存在以下差异.

• 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".

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

若有"+"的话,就以读写两用模式(RDWR)打开文件.

• "r+": 将文件的读写位置设在开头.
• "w+": 与"r+"一样.打开文件时,若文件已存在就清空其内容.
• "a+": 与"r+"一样.打开文件时,若文件已存在,就把读写位置设在文件结尾.

可在上述任意一项后面添加"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 。

另外，请参考print , warn 。

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

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

• "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 , ...]) ((<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之间存在以下差异.

• 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 。

---