`
withyou
  • 浏览: 436864 次
社区版块
存档分类
最新评论
阅读更多
内部函数

严格说来,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可以是下列数值字面值或字符串(只把字符串的首字符当成命令)。

        * 带一个参数时
              o

                ?r

                可以使用有效 uid 读取文件
              o

                ?w

                可以使用有效 uid 写入文件
              o

                ?x

                可以使用有效 uid 执行文件
              o

                ?o

                文件的所有者是有效 uid
              o

                ?G

                文件的所有者group是有效 gid
              o

                ?R

                可以使用实 uid 读取文件
              o

                ?W

                可以使用实 uid 写入文件
              o

                ?X

                可以使用实 uid 执行文件
              o

                ?O

                文件的所有者是实 uid
              o

                ?e

                文件存在
              o

                ?z

                文件大小为 0
              o

                ?s

                文件大小非 0 (返回文件大小)
              o

                ?f

                文件是无格式(plain)文件
              o

                ?d

                文件是目录
              o

                ?l

                文件是符号连接
              o

                ?p

                文件是带名的管道(FIFO)
              o

                ?S

                文件是socket
              o

                ?b

                文件是特殊块文件
              o

                ?c

                文件是特殊字符文件
              o

                ?u

                文件中有 setuid bit
              o

                ?g

                文件中有 setgid bit
              o

                ?k

                文件中有 sticky bit
              o

                ?M

                返回最近更新文件时刻
              o

                ?A

                返回最近访问文件时刻
              o

                ?C

                返回文件的 inode 变更时刻
        * 带两个参数时
              o

                ?=

                文件1和文件2的最近更新时刻相同
              o

                ?>

                文件1的最近更新时刻要比文件2的新
              o

                ?<

                文件1的最近更新时刻要比文件2的旧
              o

                ?-

                文件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。



内部变量

本参考手册使用下列术语.

全局变量

    所有以`$'开头的变量
内部变量

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

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

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

有时,内部变量(有特殊的功能和用途)的有效作用域不只限于全局,尽管如此,上述定义还是把它们划入到全局变量的范畴中(可以在任何地方使用内部变量,从这种意义上说它们是全局的,但它们的值并不只限于全局).

根据变量值的作用域的不同,大致将内部变量划分如下.
局部域

下列也可看做是线程内的局部变量.

$_

    gets或readline最后读入的字符串.若遇到EOF则为nil.该变量的作用域是局部域.(记忆方法:与 Perl相同)
$&

    在当前作用域中,正则表达式最后一次匹配成功的字符串.若最后一次匹配失败,则为nil.(记忆方法: 它和某些编辑器中的&是相同的)

    等同于Regexp.last_match[0].
$~

    在当前作用域中,最后一次匹配成功的相关信息(MatchData对象).若对其进行设定的话, 则$&以及$1 ... $9等的值也会发生变化.

    可以使用$~[n]的形式从该数据中抽取第n个匹配结果($n).(记忆方法: ~ 是用来进行匹配的)

    等同于Regexp.last_match.
$`

    在当前作用域中,正则表达式最后一次匹配成功的字符串前面的字符串.若最后的匹配失败则为nil.(记忆方法: `被放在字符串前面)

    等同于Regexp.last_match.pre_match.
$'

    在当前作用域中,正则表达式最后一次匹配成功的字符串后面的字符串.若最后的匹配失败则为nil.(记忆方法: '被放在字符串后面)

    等同于Regexp.last_match.post_match.
$+

    在当前作用域中,正则表达式最后一次匹配成功的字符串部分中,与最后一个括号相对应的那部分字符串.若最后的匹配失败则为nil.在多项选择型匹配模型中,若您无法断定是哪个部分匹配成功时,该变量将会非常有用.(记忆方法: be positive and forward looking.)
$1
$2
$3 ...

    分别存储着最后一次模型匹配成功时与第n个括号相匹配的值.若没有相应的括号时,其值为nil.(记忆方法: 类似于 \数字)

    等同于Regexp.last_match[1], Regexp.last_match[2],...

线程局部域

下列变量在一个线程内部时是全局域变量,但在不同的线程之间是彼此独立的.

$?

    本线程中最后结束的子进程的状态值. 1.6版本以前是整数,从1.7版本开始变为Process::Status对象.另外,请参考Process#wait等.

    整数值就是使用wait()系统调用所获得的值,要想得到子进程的exit status的话,还得除以256($?/256). 1.7版本以后还可以使用Process::Status#exitstatus.
$!

    最近发生的异常的信息.由raise设定.
$@

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

    "filename:line"

    或

    "filename:line:in `methodname'"

    这和caller的返回值形式一致。

    在向$@赋值时,$!不能为nil。调用$@的方法与$!.backtrace相同。而赋值方法与$!.set_backtrace相同。

    (记忆方法:where exception occurred at.)
$SAFE

    当前线程的安全等级。关于安全等级,请参考安全模型。

    与Thread.current.safe_level相同。

全局域

$=

    obsolete: 该变量将被废止。

    说明在模式匹配或字符串比较中是否要区分大小写字母的标识。默认值为nil。
$/

    输入记录分隔符。默认值为"\n"。其运作类似于awk的RS变量。

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

    不能在$/中使用正则表达式。

    (记忆方法: 在诗歌中使用 / 作为行的切分)
$\

    输出记录分隔符。print会在最后输出该字符串。

    默认值为nil,此时不会输出任何字符。
$,

    默认的切分字符。若Array#join中省略了参数时或在print的各个参数间将会输出它。

    默认值为 nil ,等同于空字符串。
$;

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

    ruby 1.8 feature:在1.6版本中只能把字符串赋值给$;。在1.8版本中则可以将任何对象代入其中,但考虑到String#split的变更问题,还是应该使用正则表达式。

    同时,为了提供兼容性,最好不要依赖于 $; 。
$.

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

    与ARGF.lineno相同。若需要取得每个参数文件的行号时,需要使用ARGF.file.lineno。
$<

    由参数(若没的话就使用标准输入)构成的虚拟文件。也就是常数ARGF的别名。(记忆方法: <指定了shell的输入源)
$deferr ((<ruby 1.8 特性>)) ((<obsolete>))

    Ruby解释器输出错误信息、警告信息和warn时的输出对象。

    只能将内部带有write方法的对象赋值给该变量。(warn 等内部方法最终将调用$deferr.write方法)。

    $deferr 是 $stderr 的别名。$deferr (尽管它刚出现不久) 将被废止。
$>
$defout ((<obsolete>))

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

    只能将内部带有write方法的对象赋值给该变量(print等内部方法最终将调用write方法)。

    若想改变print等Ruby内部函数的输出对象时,可以将该变量的值设定为别的IO即可。若想要改变子进程或C语言扩展库的标准输出时,则必须使用IO#reopen将标准输出重定向(redirect)到别的IO。请参考$stdout。

    ruby 1.8 特性:

    $defout 是 $stdout 的别名。$defout 是obsolete。
$0
$PROGRAM_NAME ((<ruby 1.8 特性>))

    当前运行中的Ruby脚本名.根据OS的不同,有时向该变量赋值后,ps(1)的输出会发生变化.该功能适合于用来表示当前程序的状态.(记忆方法: 与sh 或 ksh 相同)
$*

    传递给Ruby脚本的参数.内部常数ARGV的别名.Ruby自身用的参数已经被摘除.(记忆方法: 与sh 或 ksh 相同)
$$

    当前运行中的Ruby进程的pid。(记忆方法: 与shell相同)

    与Process.pid相同.
$:
$LOAD_PATH

    包含一个数组,其内容是load或require加载文件时用的搜索目录列表.(记忆方法: 冒号是环境变量PATH的切分符)

    包含下列内容:启动时-I directory 选项所指定的目录,环境变量RUBYLIB的值,编译时指定的默认值还有"."(当前目录).下列就是典型的UNIX系统上的加载路径.

    -I 指定的路径
    环境变量 RUBYLIB 的值
    /usr/local/lib/ruby/site_ruby/VERSION        site固有的,取决于VERSION的库
    /usr/local/lib/ruby/site_ruby/VERSION/ARCH   site固有的,取决于系统的扩展库
    /usr/local/lib/ruby/site_ruby                site固有的库
    /usr/local/lib/ruby/VERSION                  标准库
    /usr/local/lib/ruby/VERSION/ARCH             标准的,取决于系统的扩展库
    .                                            当前目录

    上表中的VERSION是表示Ruby版本的字符串,如"1.6"或"1.8"等.ARCH是表示硬件和OS的字符串,如"i686-linux"或"alpha-osf5.1"等.可以从Config::CONFIG['arch']中得到这些信息.

    在多数UNIX系统中,编译时的默认路径是"/usr/local/lib/ruby".在mswin32,mingw32,cygwin,bccwin32,mswince这些环境中,是以ruby.dll所在位置为起点的相对路径.而在djgpp,emx(OS/2)中,则是以ruby.exe所在位置为起点的相对路径.

    在使用-T 选项启动时,若将$SAFE设为1以上的值的话,则"." (当前目录)不会被纳入加载路径.

    如require 'foo'时,将交互搜索.rb和.so.

    /usr/local/lib/ruby/site_ruby/VERSION/foo.rb
    /usr/local/lib/ruby/site_ruby/VERSION/foo.so
    /usr/local/lib/ruby/site_ruby/VERSION/ARCH/foo.rb
    /usr/local/lib/ruby/site_ruby/VERSION/ARCH/foo.so
      :
      :

    有的系统的共享库扩展名并非.so,此时将自动使用新的扩展名.例如在HP-UX上require 'foo.so'时将搜索foo.sl.因此在Ruby内部,可以一直使用.so.

    若想用命令行查看加载路径的话,可以这样

    $ ruby -e 'puts $:'

    即可.
$"
$LOADED_FEATURES ((<ruby 1.8 特性>))

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

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

    调试模式与普通的运行有以下不同。

        *

          若某线程因发生异常而结束时,整个解释器也将中止工作。这等同于将Thread.abort_on_exception设置为true的效果,但是在调试模式中,即使在脚本中使用 abort_on_exception= 类方法来重置标识也无法取消该效果。

          在通常的运行中,若某线程发生了异常却并没有被Thread#join等检测到的话,该线程将被无警告地终止。
        * 不管有没有捕捉到异常,只要它一旦发生就会被报告到 $stderr 。处理会继续进行。

$FILENAME

    虚拟文件ARGF中,当前正在读入的(gets方法正在读的)文件名。与ARGF.filename相同。
$LOAD_PATH

    $:的别名。
$stdin
$stdout
$stderr

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

    ruby 1.8 特性

    $stdout, $stderr 是 $defout,$deferr 的别名。($defout, $deferr 已经废止)

    $stdout, $stderr的对应对象中必须要有名为write的方法。详细情况请参考defout,deferr。

    $stdin同$stdout、$stderr一样,即使没有特定的方法也可以对其赋值。若执行gets等方法时,该方法将被投射到$stdin对应的对象中。(将执行$stdin.gets)

    $stdin所对应的对象中应该定义下列方法。(请根据需要取舍)

    gets, readline, readlines, getc, readchar, tell, seek,
    pos=, rewind, fileno, to_io, eof, each_line, each_byte,
    binmode, closed?

    例:

    $stdin = Object.new
    def $stdin.gets
      "foo"
    end
    p gets

    # => "foo"

    若想对标准输入、输出、错误输出等进行重定向(redirect)时,可以使用IO#reopen(1.6版也是如此)。例如

    $stdout = File.open("/tmp/foo", "w")

    写成这样

    STDOUT.reopen("/tmp/foo", "w")

    就可以了。若想取消重定向时

    stdout_sv = STDOUT.dup          # 保存 STDOUT
    STDOUT.reopen("/tmp/foo")       # 将 STDOUT 重定向到 /tmp/foo

    puts "foo"                      # 输出到 /tmp/foo

    STDOUT.flush                    # 必须(?)
    STDOUT.reopen(stdout_sv)        # 恢复原状

    就可以了。若您不想让重定向影响到子进程的话,只要向$stdout等赋值就足够了。

    # 改变输出方法的默认输出对象
    $stdout = File.open("/tmp/foo", "w")

    puts "foo"

    # 取回输出方法的默认输出对象。
    $stdout = STDOUT

    ruby 1.6 特性: 向$stdin、$stdout、$stderr赋值时,会进行重定向。

    ruby 1.7 特性: 暂时修改了重定向的运作方式[ruby-dev:14601]。
$VERBOSE

    冗长消息标识。由面向Ruby解释器的-v选项进行设定。

    ruby 1.8 特性

    警告等级分为三级,分别如下。

        * nil: 不输出警告
        * false: 只输出重要警告(默认)
        * true: 输出所有警告

    可以使用命令行选项-W[level]来指定警告等级,分别为-W0、-W1、-W2 (or -W)。指定-v或-w时,等同于-W2。

    若设定为nil、false之外的值时,其值为变为true。
$KCODE

    Ruby可识别的多字节字符串的编码。变量值为"EUC" "SJIS" "UTF8" "NONE"之一。

    当$KCODE的值为"EUC"时,将假定字符串或正则表达式的编码为EUC-JP。同样地,若为"SJIS"时则认定为Shift JIS。若为"UTF8"时则认定为UTF-8。若为"NONE"时,将不会识别多字节字符串。

    在向该变量赋值时,只有第1个字节起作用,且不区分大小写字母。"e" "E" 代表 "EUC","s" "S" 代表 "SJIS","u" "U" 代表 "UTF8",而"n" "N" 则代表 "NONE"。

    默认值为"NONE"。

    [参考]

    目前$KCODE将对Ruby的下列动作产生影响。

        * 解释器的字句解析器
        * Regexp的编码标识的默认值
        * (正则表达式字面值
        * Regexp.new)
        * upcase
        * downcase
        * swapcase
        * capitalize
        * inspect
        * split
        * gsub
        * scan

选项变量

用来显示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
$-w

    $VERBOSE 的别名。
$-W ((<ruby 1.9 特性>))

    返回由-W[level]指定的值。

    也就是说,根据$VERBOSE的取值不同

        * nil: 不输出警告 -> 0
        * false: 只输出重要警告(默认) -> 1
        * true: 输出所有警告 -> 2

    而返回上述诸值之一。只读变量。


内部常数

TRUE ((<obsolete>))

    真值的代表。与true相同。Ruby中把所有非伪值(即非false又非nil的值)都看作真。(请参考obsolete。)
FALSE ((<obsolete>))

    伪值。与false相同。(请参考obsolete。)
NIL ((<obsolete>))

    与nil相同。(请参考obsolete。)
STDIN

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

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

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

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

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

    传给Ruby脚本的参数。内部变量$*的别名。而面向Ruby自身的参数已经被摘除。
DATA

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

    注意:

        * 使用DATA.rewind后的读取位置不再是__END__后面,而是脚本文件的开头。
        * 若读入脚本时使用的是标准输入的话,则为标准输入。
        * 如果读入脚本时并没有使用文件或标准输入,或者脚本并非以__END__结束时,则该定义将不再适用。
        * 即使用require或load加载文件时,也并不是指该文件(_FILE_),而是指运行文件($0)。

TOPLEVEL_BINDING

    顶层中的Binding对象。
RUBY_VERSION

    显示Ruby版本的字符串。Ruby版本信息的形式为major.minor.teeny。(当前)各个号码的位数不会超过2位,因此

    if RUBY_VERSION >= '1.6.7'
      # 在1.6.7以后的版本中有效的操作
    else
      # 在此之前的版本中有效地操作
    end

    按照版本信息的不同来进行分支处理。

    在1.8以前的版本中,minor是奇数时则为开发版,minor是偶数时则为稳定版。在1.9.0以后的版本中,teeny为0的版本是开发版。
RUBY_RELEASE_DATE

    显示Ruby发布日期的字符串。
RUBY_PLATFORM

    显示平台信息的字符串。
VERSION ((<obsolete>))
RELEASE_DATE ((<obsolete>))
PLATFORM ((<obsolete>))

    这些都是前面那些常数RUBY_XXX的旧名称。请参考obsolete。

    ruby 1.9 特性: 这些常数已经停用。
SCRIPT_LINES__

    默认情况下,该常数不会被定义。

    若将该常数定义为哈希表后,在编译源代码时,源文件名将成为哈希表元素的索引,而源文件的内容会被按行切分后转化为数组,该数组将成为哈希表元素的内容。在调试(debug.rb)等场合会用到该常数。

    SCRIPT_LINES__ = {}
    require 'English'
    p SCRIPT_LINES__

    # 注: 输出内容被处理过。
    # => {"/usr/local/lib/ruby/1.6/English.rb"=>
          ["alias $ERROR_INFO              $!\n",
           "alias $ERROR_POSITION          $@\n",
           "alias $LOADED_FEATURES         $\"\n",
                    :
                    :
           "alias $POSTMATCH               $'\n",
           "alias $LAST_PAREN_MATCH        $+\n"]}

    另外,只有在$SAFE等级为0时才有效。同时,也不能由eval进行编译。

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics