內(nèi)部函數(shù)

嚴(yán)格說來,Ruby中沒有函數(shù).但Kernel模塊中定義的方法(可以在任何地方用做函數(shù),因此)可被其他語言當(dāng)做函數(shù)來調(diào)用.若您對這些方法進(jìn)行再定義時,就必需考慮到對其他方面的影響.

` str

把字符串str當(dāng)做外部命令來運行,并以字符串方式返回命令的輸出.使用`str`形式來調(diào)用該方法(還可以使用%x(...)表示法進(jìn)行調(diào)用.請參考命令輸出).

可以使用$?來了解命令的結(jié)束狀態(tài).

若您只想執(zhí)行命令,而不需要得到命令輸出時,可以使用system.如果是那些終端控制命令的話,`command`可能會運行失敗.

Array(arg)

調(diào)用 arg.to_ary 或 arg.to_a 將參數(shù)轉(zhuǎn)為數(shù)組并返回結(jié)果.若變換后沒有得到數(shù)組就會引發(fā)TypeError異常.

若arg中沒有to_ary或to_a方法的話,就返回只包含一個元素的數(shù)組[arg].

Float(arg)

將參數(shù)變?yōu)楦↑c數(shù)(Float)并返回結(jié)果.

若將不能轉(zhuǎn)為整數(shù)或浮點數(shù)的字符串傳遞給參數(shù)的話,會引發(fā)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     # `_' 也被看做是數(shù)值要素
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)

將參數(shù)變?yōu)檎麛?shù)(Fixnum,Bignum)并返回結(jié)果.對數(shù)值,字符串以外的對象使用to_i方法(Ruby 1.7 特性:在1.7中是to_int).若變換結(jié)果不是整數(shù)(Integer的子類)就會引發(fā)TypeError異常.

若參數(shù)是字符串的話,將按其前綴,如0x,0b,0等分別決定要按照16進(jìn)制,2進(jìn)制或是8進(jìn)制的標(biāo)準(zhǔn)來處理該字符串.

若把不能變?yōu)檎麛?shù)的字符串傳遞給參數(shù)時,將引發(fā)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)

調(diào)用arg.to_s將參數(shù)變?yōu)樽址⒎祷亟Y(jié)果。若變換后的結(jié)果并非字符串的話，會引發(fā)TypeError異常。若arg已經(jīng)是字符串的話，則不作任何處理直接返回arg。

abort

abort(message) ((<ruby 1.7 特性>))

以非正常方式結(jié)束Ruby程序的運行。它與Exit的區(qū)別在于，調(diào)用時若$!不為nil的話，就將異常消息輸出到標(biāo)準(zhǔn)錯誤輸出當(dāng)中；另外，程序的結(jié)束status始終都是EXIT_FAILURE(在絕大多數(shù)環(huán)境中都是1)。

ruby 1.7 特性:若指定了message參數(shù)的話，就將message賦值給SystemExit#message后輸出到標(biāo)準(zhǔn)錯誤輸出中。

at_exit { .... }

在解釋器結(jié)束工作之前執(zhí)行指定的塊。除去at_exit是個方法這點差異之外，它與END塊所進(jìn)行工作基本相同。一旦注冊了要進(jìn)行的處理內(nèi)容之后就不能取消。請參考結(jié)束時的相關(guān)處理。

Proc對象返回注冊的處理內(nèi)容。

autoload(const_name, feature)

autoload?(const_name) ((<ruby 1.8 feature>))

在首次調(diào)用常數(shù)const_name時會require feature。const_name可以是字符串或Symbol。而且const_name中不能包含"::"操作符(即只能指定頂層的常數(shù))。

返回nil。

ruby 1.8 特性：可以autoload任何類／模塊的常數(shù)。const_name中還是不能有"::"操作符，可以像下面這樣定義。(實際上是調(diào)用了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常數(shù)尚未定義(沒被load)時，返回其路徑名。另外，若已經(jīng)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的庫中，嵌套內(nèi)的常數(shù)還沒有被定義。乍看起來好像會正常運行，實則不然(出現(xiàn)了警告消息)。

------- /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對象。該對象包含變量、方法等的環(huán)境信息，它通常用作Eval的第二參數(shù)。

caller([level])

以$@的back trace(字符串?dāng)?shù)組)形式返回level層上(省略參數(shù)時為1)的調(diào)用者的信息。若是頂層的話就返回空數(shù)組。將caller的返回值代入$@就可以設(shè)定異常的發(fā)生位置。

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"]
   []

下列函數(shù)可以從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

當(dāng)$DEBUG為真時，debug函數(shù)非常有用。以下是該函數(shù)例程。

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的第二參數(shù)的值作為返回值。

例如下例代碼在運行過程中不會調(diào)用some_process，同時catch的值是25，而并非10。

ret = catch(:exit) {
   throw :exit, 25
   some_process()
   10
}
p ret   #=> 25

嵌套的循環(huán)不會因為遇到break就一下子跳出。這時可使用catch或異常。

catch(:loop1) {
  for i in 1..2
    for j in 1..2
      throw :loop1, j
    end
  end
}

chop

chop!

將內(nèi)部變量$_末尾的字符去掉(若末尾是"\r\n"則去掉2個字符)。chop!將改變字符串本身并返回結(jié)果。若沒有可以去掉的字符則返回nil。

請參考String#chop了解詳情。chop函數(shù)與$_.chop之間存在以下區(qū)別。

• chop先拷貝$_的值，然后對拷貝進(jìn)行修改，最后把這個拷貝的值重新賦值給$_。

chomp([rs])

chomp!([rs])

去掉位于內(nèi)部變量$_末尾且由rs指定的字符。chomp!將改變字符串本身并返回結(jié)果。若沒有可被去掉的字符串則返回nil。rs的默認(rèn)值為$/

請參考String#chomp了解詳情。chomp函數(shù)與$_.chomp之間存在以下區(qū)別。

• chomp先拷貝$_的值，然后對拷貝進(jìn)行修改，最后把這個拷貝的值重新賦值給$_。

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

把字符串expr當(dāng)作Ruby程序來運行并返回其結(jié)果。若給第二參數(shù)傳遞Proc對象或Binding對象的話，將在生成該對象的環(huán)境中對字符串進(jìn)行計算。請參考binding。

def foo
  a = 1
  binding
end

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

若指定了fname 和 lineno的話，將假定字符串位于fname文件lineno行，并且進(jìn)行編譯。這時可以顯示棧跟蹤(stack trace)等信息。

exec(command)

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

執(zhí)行由command指定的命令.該命令(或shell,詳見下文)將變成進(jìn)程執(zhí)行的代碼,所以一旦啟動成功,就不會再從該函數(shù)中返回.若啟動失敗,控制權(quán)重新回歸ruby解釋器,然后會引發(fā)Errno::EXXX異常.

在第一種語句中,若command中包含shell的元字符(* ? {} [] <> () ~ & | \ $ ; ' ` " \n)的話,則經(jīng)由shell執(zhí)行命令.除此之外,將由解釋器直接執(zhí)行.

使用第二種語句時,通常不經(jīng)過shell就執(zhí)行命令.此時,將把空字符或shell的元字符等原般不動地傳遞給program的參數(shù).若首個參數(shù)是包含兩個元素的數(shù)組時,第一個元素的字符串將成為啟動程序時的路徑,而第二個元素將成為程序名的"別名".

ruby 1.8 特性:即使第一個元素不是完整路徑,也會自動從環(huán)境變量PATH中開始搜索.

exit([status])

終止Ruby程序的運行.若向status傳遞了一個整數(shù)的話,該整數(shù)就將成為Ruby命令的結(jié)束狀態(tài)值.默認(rèn)的結(jié)束狀態(tài)值是0.

exit通過引發(fā)SystemExit異常來結(jié)束程序的運行.若有必要的話,可以使用rescue部分來捕捉到它.

ruby 1.8 特性:若status為true的話,就以EXIT_SUCCESS作為結(jié)束狀態(tài)值.若status為false的話,就以EXIT_FAILURE作為結(jié)束狀態(tài)值.默認(rèn)的結(jié)束狀態(tài)值已被改為EXIT_SUCCESS.

exit!([status])

以整數(shù)status為結(jié)束狀態(tài)值來終止Ruby程序的運行.默認(rèn)的結(jié)束狀態(tài)值為-1.

exit!與exit不同,它不會進(jìn)行異常處理.在fork之后,若想終止子進(jìn)程時可以使用該語句.

ruby 1.8 特性:若status為true的話,就以EXIT_SUCCESS作為結(jié)束狀態(tài)值.若status為false的話,就以EXIT_FAILURE作為結(jié)束狀態(tài)值.默認(rèn)的結(jié)束狀態(tài)值已被改為EXIT_FAILURE.

fork

fork { ... }

使用fork(2)系統(tǒng)調(diào)用來制作進(jìn)程的拷貝.若在父進(jìn)程中將返回子進(jìn)程的進(jìn)程ID,若在子進(jìn)程中則返回nil.若指定一個塊之后再進(jìn)行調(diào)用,則會在生成的子進(jìn)程中對該塊進(jìn)行計算.

gets([rs])

readline([rs])

Ruby解釋器在運行時,會把從參數(shù)那里得到的文件(若沒有的話,就利用標(biāo)準(zhǔn)輸入)假設(shè)成一個虛擬文件(可以使用內(nèi)部變量$<或ARGF訪問該虛擬文件),然后從該虛擬文件中讀入一行,并返回字符串.若到達(dá)文件尾部時返回nil.

使用rs指定的字符串作為行的切分符號.rs的默認(rèn)值取自內(nèi)部變量$/.讀入的字符串也被存入內(nèi)部變量$_中.

若將rs設(shè)為nil的話,則意味著讀入文件的全部內(nèi)容而忽略行的切分.若設(shè)為空字符串""的話,會把連續(xù)的換行當(dāng)做行的切分符(段落模式).

readline的功能與gets相同,但是當(dāng)它遇到文件結(jié)尾時會引發(fā)EOFError異常.

global_variables

返回程序中已定義的全局變量(以'$'開頭的變量)名的數(shù)組.

另外請參考local_variables, Object#instance_variables, Module.constants, Module#constants, Module#class_variables.

gsub(pattern[, replace])

gsub!(pattern[, replace])

gsub(pattern) {|matched| ... }

gsub!(pattern) {|matched| ... }

在內(nèi)部變量$_所包含的字符串中,將符合pattern的部分替換為replace,然后返回結(jié)果.若省略參數(shù)replace時,該方法將演變?yōu)榈?以塊的計算值進(jìn)行替換操作.將匹配的字符串以參數(shù)的形式傳遞給塊.

$_ = "foobar"
p gsub(/o+/) {|m|
  m.upcase
}
# => "fOObar"

gsub!將改寫$_所包含的字符串本身.請參考String#gsub來獲得更多資訊.String#gsub和gsub之間存在以下差異.

• gsub方法會拷貝$_的值,然后對拷貝進(jìn)行更新,最后再賦值給$_.

iterator? ((<obsolete>))

block_given?

若某方法帶塊則返回真,否則返回偽.

load(file[, priv])

加載Ruby程序file并予以執(zhí)行.若file是絕對路徑,則從file開始加載.若file是相對路徑,則依次搜索內(nèi)部變量$:所指定的路徑,并加載第一個搜索到的文件.此時,若$:中的元素是以"~"(tilde)開頭的話,就把它擴展為環(huán)境變量HOME的值.

若可選參數(shù)priv的值為真,則在內(nèi)部生成一個無名模塊作為頂層來進(jìn)行加載和運行,這便不會污染全局名字空間了.

若加載成功則返回true,若失敗則引發(fā)LoadError異常.

[require與load之間的區(qū)別]

require對于相同的文件只會加載一次,而load則是無條件的加載.另外,require會自動補全擴展名,如.rb或.so等.而load則沒有該功能.一般的典型用法是,使用require加載庫,而使用load加載配置文件等.

# 用例
load "#{ENV['HOME']}/.myapprc"
load "/etc/myapprc"

另外,如果想在特定目錄中加載文件的話,寫成 load 'filename' 就不恰當(dāng)了.這時請務(wù)必使用絕對路徑.

local_variables

返回當(dāng)前作用域中已定義的局部變量名的數(shù)組.

另外,請參考global_variables, Object#instance_variables, Module.constants, Module#constants, Module#class_variables.

loop { ... }

(只要不被中斷就)反復(fù)對塊進(jìn)行計算.

open(file[, mode[, perm]])

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

打開file并返回File對象.mode可以是下列字符串或者整數(shù)(File::Constants模塊的常數(shù)的邏輯和).省略時默認(rèn)為"r".

• "r", RDONLY: 以讀取模式打開文件.
• "w", WRONLY|CREAT|TRUNC: 以寫入模式打開文件.打開文件時,若文件已存在就清空文件內(nèi)容.
• "a", WRONLY|CREAT|APPEND: 以寫入模式打開文件.通常把寫入內(nèi)容添加到文件結(jié)尾.

若有"+"的話,就以讀寫兩用模式(RDWR)打開文件.

• "r+": 將文件的讀寫位置設(shè)在開頭.
• "w+": 與"r+"一樣.打開文件時,若文件已存在就清空其內(nèi)容.
• "a+": 與"r+"一樣.打開文件時,若文件已存在,就把讀寫位置設(shè)在文件結(jié)尾.

可在上述任意一項后面添加"b"(如"r+b")標(biāo)志(如果是整數(shù)就是File::BINARY).此時,將以二進(jìn)制方式打開文件(只限于以文本/二進(jìn)制方式來區(qū)分文件的系統(tǒng)).

第三參數(shù)perm與open(2)的第三參數(shù)是一樣的，它以整數(shù)的形式說明了文件在CREAT時的訪問權(quán)限。若第二參數(shù)不是數(shù)值形式的話，該參數(shù)將被忽略。它的默認(rèn)值是0666。

若文件名以`|'開頭時，其后的字符串會被當(dāng)作命令來執(zhí)行。另外，將生成管線(pipeline)來應(yīng)對命令的標(biāo)準(zhǔn)輸入輸出。

若文件名為"|-"的話，open將生成Ruby的子進(jìn)程，并返回與子進(jìn)程之間的管道(pipe)(IO對象)。(此時的運作與IO.popen相同。File.open沒有生成管線的功能)。

注意: 與Perl不同的是，命令通常是以`|'開頭的。

當(dāng)open與塊同時被調(diào)用時，open將打開文件并執(zhí)行塊，當(dāng)塊的運行終止后就關(guān)閉文件。此時返回塊的計算結(jié)果。請看下例。

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, ...]])

依次輸出參數(shù)。若沒有得到參數(shù)則輸出變量$_的值。若把非字符串對象傳給參數(shù)的話，將對該對象使用to_s方法將其變?yōu)樽址筝敵?。若是nil的話則輸出字符串"nil"。

若給變量$;(輸出字段分隔符)指定了一個非nil的值的話，將在各個參數(shù)之間輸出該分隔符。若給變量$\(輸出記錄分隔符)指定了一個非nil的值的話，將在最后輸出它。

返回nil。

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

類似于C語言的printf，它將按照format將參數(shù)格式化為字符串，然后輸出到$>。當(dāng)?shù)谝粎?shù)是IO的子類的實例時，將對該對象進(jìn)行輸出。若沒有任何參數(shù)時，將不作反應(yīng)。

請參考sprintf格式來了解Ruby中format字符串的擴展問題。

返回nil。

proc { ... }

lambda { ... }

proc

lambda

在給出的塊中生成過程對象(Proc的實例)并返回它(等同于Proc.new)。

若沒有給出塊的話，將返回主調(diào)(caller)方法所指的塊。若主調(diào)方法沒有塊時，將引發(fā)ArgumentError異常。

putc(ch)

將字符ch輸出到$>。若ch是數(shù)字的話，將輸出對應(yīng)于0～255的字符。若ch是字符串的話，將輸出字符串中的第一個字符。

返回ch。

putc("ch")
putc(?c)
putc(99)
# => ccc

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

依次將obj和換行符輸出到$>。若沒有參數(shù)的話則只會輸出換行符。

若參數(shù)是數(shù)組，則依次輸出數(shù)組元素和換行符。若將既非數(shù)組又非字符串的對象傳遞給參數(shù)時，將嘗試使用to_ary方法將其化為數(shù)組，再使用to_s方法將其化為字符串。若是nil則輸出字符串"nil"。

若參數(shù)是以換行符結(jié)尾時，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])

引發(fā)異常。

若沒有參數(shù)時，將再次引發(fā)本線程本塊內(nèi)最后被rescue的異常對象($!)。若沒有這樣的異常時，將引發(fā)RuntimeError異常。

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

若只有一個參數(shù)，且該參數(shù)為字符串時，將以該字符串為message來引發(fā)RuntimeError異常。若該參數(shù)為異常類或異常對象時，將引發(fā)該異常。

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

raise ArgumentError      # => -:1: ArgumentError (ArgumentError)

raise ArgumentError.new  # => -:1: ArgumentError (ArgumentError)

若有2或3個參數(shù)時，將以第二參數(shù)為message來引發(fā)第一參數(shù)所指的異常。此時是以異常類或異常對象來指定異常的。而第三參數(shù)則是發(fā)生異常時的棧跟蹤(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'

若將非異常的類或?qū)ο筚x予第一參數(shù)時，實際上發(fā)生的異常正是該對象的exception方法的返回值。

class MyException
  def exception
    ArgumentError.new
  end
end

raise MyException.new

# => -:7: ArgumentError (ArgumentError)

若采用第二種形式來指定參數(shù)時，該參數(shù)將被賦予exception方法。

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

raise MyException.new, "error message"

# => -:7: error message (ArgumentError)

exception方法必定返回異常對象。否則將引發(fā)TypeError。

發(fā)生的異常會被存入變量$!中。而發(fā)生異常時的棧跟蹤信息將被存入變量$@中。

rand([max=0])

產(chǎn)生一個0至max(不含)之間的隨機數(shù)。若未調(diào)用srand的話，就自動調(diào)用它。

若將max設(shè)為nil或0的話，將返回一個0至1(不含)的實數(shù)型Float隨機數(shù)。

readlines([rs])

把從命令行參數(shù)那里得到的文件(若沒有的話,就利用標(biāo)準(zhǔn)輸入)假設(shè)成一個虛擬文件(ARGF)，再讀入該文件的所有內(nèi)容，然后以行為單位將這些內(nèi)容轉(zhuǎn)換為數(shù)組，最后返回該數(shù)組。

以rs所指的字符串為行的切分符。rs的默認(rèn)值取自內(nèi)部變量$/。

若將rs設(shè)為nil則意味著沒有行切分符。若設(shè)定為空字符串""，則把連續(xù)換行當(dāng)作行切分符(段落模式)。

require(feature)

從加載路徑$:開始搜索Ruby庫feature，若該庫尚未被加載就立即加載。

Ruby庫就是指Ruby腳本(*.rb)或擴展庫(*.so)，若feature的擴展名被省略時，則會同時搜索這兩種文件(欲知具體的搜索順序，請參考$:)。若給出擴展名時，則只會搜索這種文件。另外，擴展庫的擴展名不僅限于常用的那些，還常常使用.so。

加載庫后返回true。若該庫已被加載則不會重復(fù)加載，此時返回false。若加載失敗則引發(fā)LoadError異常。feature被加載后，它的名字(包括擴展名)會被追加到變量$"中。

scan(re)

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

與$_.scan一樣。

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

與IO.select一樣。

set_trace_func(trace_proc)

在Ruby解釋器執(zhí)行程序的過程中，每當(dāng)發(fā)生方法調(diào)用或?qū)Ρ磉_(dá)式進(jìn)行計算等事件時都將執(zhí)行trace_proc過程對象。、以及等標(biāo)準(zhǔn)附件就是使用該內(nèi)部函數(shù)來實現(xiàn)的。

例:

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

塊參數(shù)的意義如下。

event

表示發(fā)生事件的類別。詳細(xì)內(nèi)容如下。

• "line" ... 表達(dá)式的計算。
• "call" ... 方法調(diào)用。
• "return" ... 從方法調(diào)用中返回。
• "c-call" ... C(語言)方法的調(diào)用。
• "c-return" ... 從C(語言)方法調(diào)用中返回。
• "class" ... 進(jìn)入類定義、特殊類定義或模塊定義中。
• "end" ... 類定義、特殊類定義或模塊定義的結(jié)束。
• "raise" ... 發(fā)生異常。

file

運行中的程序的源文件名(字符串)。

line

運行中的程序的源文件行號(整數(shù))。

id

根據(jù)event的不同，將使用下列之一。與第六個塊參數(shù)klass相對應(yīng)。

line

Symbol對象，它表示最后被調(diào)用的方法。在頂層中則為nil。

call/return/c-call/c-return

Symbol對象，它表示被調(diào)用／return的方法。

class/end

nil。

raise

Symbol對象，它表示最后被調(diào)用的方法。在頂層中則為nil。

binding

Binding對象，它表示運行中的程序的狀況(context)。

klass

根據(jù)event的不同，將使用下列之一。與第四個塊參數(shù)id相對應(yīng)。

line

Class對象，它表示最后被調(diào)用的方法的所屬類。在頂層中則為false。

call/return/c-call/c-return

Class對象，它表示被調(diào)用／return的方法的所屬類。

class/end

false。

raise

Class對象，它表示最后被調(diào)用的方法的所屬類。在頂層中則為false。

sleep([sec])

使程序暫停sec秒。也可以將sec設(shè)為浮點數(shù)。省略sec時，若沒有顯式地(SIGALRM或其他線程發(fā)出的Thread#run)終止睡眠的話，將一直sleep下去。返回值是實際睡眠的秒數(shù)(整數(shù))。

spawn(cmd, [arg, ...]) ((<ruby 1.9 特性>))

基本上等同于system，但它不會等待子進(jìn)程的結(jié)束。返回生成的子進(jìn)程的進(jìn)程ID。

split([sep[, limit]])

使用sep模型將$_中的字符串分割成limit個部分后轉(zhuǎn)化為數(shù)組，然后返回該數(shù)組。請參考String#split以獲得更多的資訊。

sprintf(format ... )

format(format ... )

采用同C語言sprintf一樣的方法對format字符串進(jìn)行解釋，格式化參數(shù)后返回結(jié)果。使用format時，就好像使用C語言sprintf一樣。

Ruby對整數(shù)的大小沒有上限，因此把負(fù)數(shù)指定給%b, %o, %x時(可看作左邊有無數(shù)個1)，就會顯示成..f。若想以“符號加絕對值”的形式進(jìn)行輸出的話，就得寫成%+x、% x這樣。

請參考sprintf格式化來獲取更多資訊。

srand([seed])

設(shè)定rand的隨機數(shù)的種子，返回舊的初始值(第一次返回0)。若省略初始值時，則以當(dāng)前時刻、進(jìn)程ID或srand的調(diào)用次數(shù)為基礎(chǔ)生成一個種子。

sub(pattern[, replace])

sub!(pattern[, replace])

sub(pattern) {|matched| ... }

sub!(pattern) {|matched| ... }

在內(nèi)部變量$_所指的字符串中,將首個匹配pattern的部分替換為replace,然后返回結(jié)果.若省略參數(shù)replace時,該方法將變?yōu)榈?以塊的計算值進(jìn)行替換操作.將匹配的字符串以參數(shù)的形式傳遞給塊.

sub!將改寫$_所包含的字符串本身.請參考String#sub來獲得更多資訊.String#sub和sub之間存在以下差異.

• sub方法會拷貝$_的值,然后對拷貝進(jìn)行更新,最后再賦值給$_.

syscall(num, arg ... )

執(zhí)行num號碼所對應(yīng)的系統(tǒng)調(diào)用。將第二參數(shù)以后的部分傳給系統(tǒng)調(diào)用作為其參數(shù)。參數(shù)必須是字符串或整數(shù)。

請參考syscall(2)或 /usr/include/sys/syscall.h 以了解數(shù)值與系統(tǒng)調(diào)用的對應(yīng)關(guān)系。

Ruby遵從系統(tǒng)調(diào)用的習(xí)慣，若syscall(2)返回-1時，引發(fā)Errno::EXXX異常。若返回其他值則不作變動。

system(command)

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

執(zhí)行command，成功(子進(jìn)程以 status 0 的狀態(tài)結(jié)束時)則返回真，失敗(包括不能執(zhí)行命令)則返回偽?？蓞⒄兆兞?font color="blue">$?來獲取結(jié)束狀態(tài)值(status)。

當(dāng)不能執(zhí)行命令時，大多數(shù)的shell會返回狀態(tài)值127。(所以$?的值為0x7f00)若沒有使用shell時，Ruby子進(jìn)程以狀態(tài)值127結(jié)束。通常，查看$?的值即可區(qū)分是不能執(zhí)行命令還是命令失敗。

ruby 1.9 特性:不能執(zhí)行命令時會引發(fā)Errno::EXXX異常。若使用了shell，則同上所述。

請參考exec以獲取更多資訊。

另外，請參考`command`,open。

test(cmd, file1 [, file2])

進(jìn)行文件測試。cmd可以是下列數(shù)值字面值或字符串(只把字符串的首字符當(dāng)成命令)。

• 帶一個參數(shù)時

  • ?r

    可以使用有效 uid 讀取文件

  • ?w

    可以使用有效 uid 寫入文件

  • ?x

    可以使用有效 uid 執(zhí)行文件

  • ?o

    文件的所有者是有效 uid

  • ?G

    文件的所有者group是有效 gid

  • ?R

    可以使用實 uid 讀取文件

  • ?W

    可以使用實 uid 寫入文件

  • ?X

    可以使用實 uid 執(zhí)行文件

  • ?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 變更時刻

• 帶兩個參數(shù)時

  • ?=

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

  • ?>

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

  • ?<

    文件1的最近更新時刻要比文件2的舊

  • ?-

    文件2對文件1發(fā)出了硬連接指令

throw(tag[, value=nil])

跳到使用了相同的tag的catch塊的終點(跳過方法)。若沒有使用相同tag的catch的話，就以NameError結(jié)束線程。tag可以是字符串或符號。value將變?yōu)?code>catch的返回值。

例:

ret = catch(:exit) {
   throw :exit, 25
   some_process()    # 決不會被執(zhí)行
   10
}
p ret   #=> 25

trace_var(varname, hook)

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

注冊鉤子以監(jiān)視對全局變量varname所進(jìn)行的賦值。varname可以是字符串或Symbol。

這里所說的“全局變量”是指以“$”開頭的變量，包括特殊變量。

調(diào)用之后，只要varname所指的全局變量被賦值，就會計算字符串或Proc對象hook。若鉤子是Proc對象的話，將把塊參數(shù)中的值向外傳遞。另外，可注冊多個鉤子。

若想解除跟蹤的話，可以把hook設(shè)為nil，還可以使用untrace_var。

例:

trace_var(:$v) {|val| puts "$v=#{val.inspect}" }
$v = "foo"   #=> $v="foo"
$v = 1       #=> $v=1

若hook為nil，將返回hook的數(shù)組(若是以塊注冊的話，將以Proc對象返回)。除此之外，將返回nil。

trap(signal, command)

trap(signal) { ... }

※ 在Ruby 1.8 以后的版本中，推薦使用Signal.trap。

將command注冊為signal所指的中斷的處理程序。signal可以是信號名字符串、Symbol或信號編號。

command可以是字符串或塊。若將其設(shè)為nil、空字符串""、"SIG_IGN"或者"IGNORE"時，將忽略該信號(若可能的話)。若將其設(shè)為"SIG_DFL"或"DEFAULT"時，將進(jìn)行默認(rèn)的動作。若設(shè)為"EXIT"時，在接到信號之后將進(jìn)行結(jié)束時的相關(guān)處理，然后以status 0 的狀態(tài)結(jié)束。

還可以將signal設(shè)為0或"EXIT"等特殊值。這表示“程序結(jié)束時”。

Ruby解釋器會為一些特定的信號引發(fā)異常Interrupt或SignalException。還可以使用異常處理來捕捉這些信號。

begin
  Process.kill :QUIT, $$   # 對自己發(fā)出SIGQUIT
rescue SignalException
  puts "rescue #$!"
end
# => rescue SIGQUIT

用trap()捕捉到的信號不會引發(fā)異常。

若注冊了與信號相對應(yīng)的command時，trap將返回它(若是塊的話，將被當(dāng)作Proc對象返回。若是"IGNORE"或"DEFAULT"則返回nil)。若沒有注冊的話則返回nil。

ruby 1.8 特性：在執(zhí)行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"

若指定了并不存在的信號時，將引發(fā)ArgumentError異常。

untrace_var(varname[, hook])

取消與全局變量varname有關(guān)的鉤子。若指定了hook的話，將只會取消該鉤子。若省略hook或?qū)⑵湓O(shè)為nil時，將取消varname所有的鉤子。返回取消鉤子的數(shù)組。

例:

$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之中。若內(nèi)部變量$VERBOSE為nil時，則不會輸出。這等同于

$stderr.print mesg, "\n" unless $VERBOSE.nil?

返回nil。