Ruby 1.8.7 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Kernelモジュール
クラスの継承リスト: Kernel
全てのクラスから参照できるメソッドを定義しているモジュール。 Object クラスはこのモジュールをインクルードしています。
Object クラスのメソッドは実際にはこのモジュールで定義されていま す。これはトップレベルでのメソッドの再定義に対応するためです。
Array(arg) -> Array[permalink][rdoc]引数を配列(Array)に変換した結果を返します。
arg.to_ary と arg.to_a をこの順に呼び出して、返ってきた配列を変換結果とします。
arg に to_ary, to_a のいずれのメソッドもない場合は Object#to_aによって一要素の配列 [arg] を返します。
p Array({:it => 3}) #=> [[:it, 3]]
p Array(nil) #=> []
p Array("fefe") #=> ["fefe"]
[SEE_ALSO] Object#to_a,Object#to_ary,Array
Float(arg) -> Float[permalink][rdoc]引数を浮動小数点数(Float)に変換した結果を返します。
引数が数値の場合は素直に変換し、文字列の場合 は整数や浮動小数点数と見なせるもののみ変換します。
メソッド Float は文字列に対し String#to_f よりも厳密な変換を行います。
p Float(4) #=> 4.0
p Float(4_000) #=> 4000.0
p Float(9.88) #=> 9.88
p Float(Time.gm(1986)) #=> 504921600.0
p Float(Object.new) # cannot convert Object into Float (TypeError)
p Float(nil) # cannot convert nil into Float (TypeError)
p Float("10") #=> 10.0
p Float("10e2") #=> 1000.0
p Float("1e-2") #=> 0.01
p Float(".1") #=> 0.1
p Float("nan") # invalid value (ArgumentError)
p Float("INF") # invalid value (ArgumentError)
p Float("-Inf") # invalid value (ArgumentError)
p Float(("10" * 1000)) #=> Infinity
p Float("0xa.a") # invalid value (ArgumentError)
p Float(" \n10\s \t") #=> 10.0 # 先頭と末尾の空白類は無視される
p Float("1\n0") # invalid value (ArgumentError)
p Float("") # invalid value (ArgumentError)
[SEE_ALSO] String#to_f,Float
Integer(arg) -> Integer[permalink][rdoc]引数を整数(Fixnum,Bignum)に変換した結果を返します。
引数が数値の場合は直接変換し（小数点以下切り落とし）、 文字列の場合は、進数を表す接頭辞を含む整数表現とみなせる文字列のみ 変換します。
数値と文字列以外のオブジェクトに対しては arg.to_int, arg.to_i を この順に使用して変換します。
p Integer(4) #=> 4
p Integer(4_000) #=> 4000
p Integer(9.88) #=> 9
p Integer(nil) #=> 0
p Integer(Object.new) # cannot convert Object into Integer (TypeError)
p Integer("10") #=> 10
p Integer("0d10") #=> 10
p Integer("010") #=> 8
p Integer("0o10") #=> 8
p Integer("0x10") #=> 16
p Integer("0b10") #=> 2
p Integer(" \n10\t ") #=> 10 # 先頭と末尾の空白類は無視される
p Integer("1\n0") # `Integer': invalid value for Integer: "1\n0" (ArgumentError)
p Integer("hoge") # `Integer': invalid value for Integer: "hoge" (ArgumentError)
p Integer("") # `Integer': invalid value for Integer: "" (ArgumentError)
[SEE_ALSO] String#hex,String#oct,String#to_i,Integer
String(arg) -> String[permalink][rdoc]引数を文字列(String)に変換した結果を返します。
arg.to_s を呼び出して文字列に変換します。 arg が文字列の場合、何もせず arg を返します。
class Foo def to_s "hogehoge" end end arg = Foo.new p String(arg) #=> "hogehoge"
[SEE_ALSO] Object#to_s,String
__method__ -> Symbol | nil[permalink][rdoc]現在のメソッド名を返します。 メソッドの外で呼ばれると nil を返します。
def foo p __method__ end alias :bar :foo foo #=> :foo bar #=> :foo p __method__ #=> nil
現在のメソッド名が alias されたメソッドの場合でも alias 元のメソッド名 を返します。
`command` -> String[permalink][rdoc]command を外部コマンドとして実行し、その標準出力を文字列として 返します。このメソッドは `command` の形式で呼ばれます。
引数 command に対しダブルクォートで囲まれた文字列と同様の解釈と式展開を行った後、 コマンドとして実行します。 コマンドは評価されるたびに実行されます。コマンドの終了ステータスを得るには、$? を参照します。
コマンドの出力を得る必要がなく、単にコマンドを実行したいだけなら Kernel.#system を使います。特に端末を制御するコマンドでは `command` は失敗するかもしれません。
リテラル/コマンド出力 も参照。
puts `ruby -v` #=> ruby 1.8.6 (2007-03-13 patchlevel 0) [i386-mswin32] puts $?.inspect #=> #<Process::Status: pid=3580,exited(0)>
[SEE_ALSO] Kernel.#system,Kernel.#exec
abort(message = $!.message) -> ()[permalink][rdoc]Ruby プログラムをエラーメッセージ付きで終了します。終了ステータスは 1 固定です。
このメソッドと Kernel.#exit との違いは、プログラムの終了ステー タスが 1 (正確にはCレベルの定数 EXIT_FAILURE の値)固定であることと、 引数を省略した呼び出し時に $! が nil でなければその例外の メッセージを標準エラー出力 $stderr に出力することです。
引数 message を指定すると SystemExit クラスの Exception#message に message を設定し て標準エラー出力に出力します。
puts 'start'
begin
puts 'start1...'
abort "error1"
rescue SystemExit => err
puts "end1 with #{err.inspect}"
end
begin
puts 'start2...'
$! = RuntimeError.new
abort
ensure
puts 'end2...'
end
puts 'end' #実行されない
#=> start
# start1...
# end1 with #<SystemExit: error1>
# start2...
# end2...
#終了ステータス:1
#(標準エラー出力)
#=> error1
# ..:12: RuntimeError (RuntimeError)
[SEE_ALSO] Kernel.#exit,Kernel.#exit!
at_exit { ... } -> Proc[permalink][rdoc]与えられたブロックをインタプリタ終了時に実行します。
at_exitがメソッドである点を除けば、END ブロックによる終了 処理の登録と同等です。登録した処理を取り消すことはできません。 終了処理も参照してください。
3.times do |i|
at_exit{puts "at_exit#{i}"}
end
END{puts "END"}
at_exit{puts "at_exit"}
puts "main_end"
#=> main_end
# at_exit
# END
# at_exit2
# at_exit1
# at_exit0
[SEE_ALSO] 制御構造/END
autoload(const_name, feature) -> nil[permalink][rdoc]定数 const_name を最初に参照した時に feature を Kernel.#require するように設定します。
const_name には、 "::" 演算子を含めることはできません （ネストした定数を指定する方法は後述）。
------- /tmp/foo.rb --------- class Bar end ----- end of /tmp/foo.rb ---- autoload :Bar, '/tmp/foo' p Bar #=> Bar
const_name には、 "::" 演算子を含めることはできないので、 Kernel.#autoload ではトップレベルの定数しか指定できません。
Module#autoload と組み合わせることで、任意のクラス／モジュールの定数を autoload できます。 やはりconst_name に "::" 演算子を含めることはで きませんが、以下のように定義する事ができます。
------- /tmp/foo.rb --------- class Foo class Bar end end ----- end of /tmp/foo.rb ---- class Foo autoload :Bar, '/tmp/foo' end p Foo::Bar #=> Foo::Bar
あるいは、以下のようにもできます。
class Foo end Foo.autoload :Bar, '/tmp/foo' p Foo::Bar #=> Foo::Bar
以下のように、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
[SEE_ALSO] Kernel.#autoload?,Module#autoload,Kernel.#require
autoload?(const_name) -> String | nil[permalink][rdoc]const_name が Kernel.#autoload 設定されているか調べます。
autoload 設定されていて、autoload 定数がまだ定義されてない(ロードされていない) ときにそのパス名を返します。
autoload 設定されていないか、ロード済みなら nil を返します。
------- /tmp/foo.rb --------- class Foo class Bar end end ----- end of /tmp/foo.rb ---- class Foo end p Foo.autoload?(:Bar) #=> nil Foo.autoload :Bar, '/tmp/foo' p Foo.autoload?(:Bar) #=> "/tmp/foo" p Foo::Bar #=> Foo::Bar p Foo.autoload?(:Bar) #=> nil
[SEE_ALSO] Kernel.#autoload
binding -> Binding[permalink][rdoc]変数・メソッドなどの環境情報を含んだ Binding オブジェクトを 生成して返します。通常、Kernel.#eval の第二引数として使います。
def foo
a = 1
binding
end
eval("p a", foo) #=> 1
[SEE_ALSO] Kernel.#eval,Object::TOPLEVEL_BINDING
block_given? -> bool[permalink][rdoc]iterator? -> boolメソッドにブロックが与えられていれば真を返します。
このメソッドはカレントコンテキストにブロックが与えられているかを調べるので、 メソッド内部以外で使っても単に false を返します。
iterator? は （ブロックが必ずイテレートするとはいえないので）推奨されていないの で block_given? を使ってください。
def check
if block_given?
puts "Block is given."
else
puts "Block isn't given."
end
end
check{} #=> Block is given.
check #=> Block isn't given.
callcc {|cont| .... } -> object[permalink][rdoc]継続を作成します。 Continuation を参照してください。
caller(start = 1) -> [String] | nil[permalink][rdoc]start 段上の呼び出し元の情報を $@ の形式のバックトレース(文字列の配列)として返します。
トップレベルでは空の配列を返します。caller の戻り値を $@ に代入することで 例外の発生位置を設定できます。
引数で指定した値が範囲外の場合は nil を返します。
[SEE_ALSO] Kernel.#set_trace_func,Kernel.#raise
def foo p caller(0) p caller(1) p caller(2) p caller(3) p caller(4) end def bar foo end bar #=> ["-:2:in `foo'", "-:10:in `bar'", "-:13"] # ["-:10:in `bar'", "-:13"] # ["-:13"] # [] # nil
以下の関数は、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 関数 のサンプルです。
$DEBUG = true def debug(*args) p [caller.first, *args] if $DEBUG end debug "debug information" #=> ["-:7", "debug information"]
catch(tag) {|tag| .... } -> object[permalink][rdoc]Kernel.#throwとの組み合わせで大域脱出を行います。 catch はブロックを実行します。
ブロックの実行中に tag と同じ名前の Kernel.#throw が行われた 場合は、その throw の第二引数を戻り値として、ブロックの実行を終了します。
主にネストしたループから一気に脱出するのに使用します。
result = catch(:tag) do
for i in 1..2
for j in 1..2
for k in 1..2
throw :tag, k
end
end
end
end
p result #=> 1
[SEE_ALSO] Kernel.#throw
chomp(rs = $/) -> String[permalink][rdoc]chomp!(rs = $/) -> String | nil組み込み変数 $_ を rs で指定される末尾 の文字列を取り除いたものにします。
chomp! は文字列そのものを変更しその結果を返しますが、 取り除く文字列がなければ nil を返します。 rs のデフォルト値は $/ です。
$_.chomp, $_.chomp! とほぼ同じです。
暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。 今後はより明示的な $_.chomp, $_.chomp!を使ってください。
$_.chomp とこのメソッド chomp は以下の点で違いがあります。
[SEE_ALSO] String#chomp,$_,$/
chop -> String[permalink][rdoc]chop! -> String | nil組み込み変数 $_ を最後の文字を取り除いたものにし ます(終端が"\r\n"であれば2文字取り除きます)。
chop! は文字列そのものを変更しその結果を返しますが、 取り除く文字列がなければ nil を返します。
$_.chop, $_.chop! とほぼ同じです。
暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。 今後はより明示的な $_.chop, $_.chop! を使ってください。
$_.chopとこのメソッド chop は以下の点で違いがあります。
[SEE_ALSO] String#chop,$_
eval(expr) -> object[permalink][rdoc]eval(expr, bind, fname = "(eval)", lineno = 1) -> object文字列 expr を Ruby プログラムとして評価してその結果を返しま す。第2引数に Proc オブジェクトまたは Binding オブジェクトを与えた場合、 そのオブジェクトを生成したコンテキストで文字列を評価します。
expr の中のローカル変数の扱いはブロックの場合と同じです。すなわち、eval 実行前に補足されていた変数は eval 実行後にブロック外に持ち出せます。
fname と lineno が与えられた場合には、ファイル fname の行番号 lineno から文字列 expr が書かれているかのように コンパイルされます。スタックトレースの表示などを差し替えることが できます。
bind によらずに特定のオブジェクトのコンテキストで expr を評価したい場合、 Module#module_eval, Object#instance_eval が使えます。
a = nil
eval('a = RUBY_RELEASE_DATE')
p a #=> "2007-03-13"
eval('def fuga;p 777 end')
fuga #=> 777
eval('raise RuntimeError', binding, 'XXX.rb', 4)
#=> XXX.rb:4: RuntimeError (RuntimeError)
# from ..:9
[SEE_ALSO] Kernel.#binding,Module#module_eval,Object#instance_eval,Object#method,Object#send
exec(command) -> ()[permalink][rdoc]引数で指定されたコマンドを実行します。
プロセスの実行コードはそのコマンド(あるいは shell)になるので、 起動に成功した場合、このメソッドからは戻りません。
この形式では command が shell のメタ文字
* ? {} [] <> () ~ & | \ $ ; ' ` " \n
を含む場合、shell 経由で実行されます。 そうでなければインタプリタから直接実行されます。
# a.rb puts '実行前' exec 'echo "実行中"' puts '実行後'
上記のスクリプトを実行すると以下のようになります。
$ ruby a.rb 実行前 実行中 # '実行後' は表示されない
exec(program, *args) -> ()[permalink][rdoc]引数で指定されたコマンドを実行します。
プロセスの実行コードはそのコマンド(あるいは shell)になるので、 起動に成功した場合、このメソッドからは戻りません。
この形式では、常に shell を経由せずに実行されます。
この形式で呼び出した場合、空白や shell のメタキャラクタも そのまま program の引数に渡されます。 先頭の引数が2要素の配列であった場合、第1要素の文字列が実際に 起動するプログラムのパスであり、第2要素が「みせかけ」のプロ グラム名になります。 また、第1要素はフルパスで指定しなくても環境変数 PATH から探します。
例
# a.rb exec ['sleep', 'mysleep'], '600'
上記スクリプトを実行すると以下のようになります。
$ ruby a.rb ## sleep してるので制御が戻ってこない。別の仮想端末に切替えて以下を実行 $ ps aux|grep sleep xxxx 32754 0.0 0.0 2580 468 pts/3 S+ 22:01 0:00 mysleep 600 xxxx 32761 0.0 0.0 2824 792 pts/6 S+ 22:01 0:00 grep sleep
[SEE_ALSO] Kernel.#system,Kernel.#`,Kernel.#fork,IO.popen,IO.pipe,Kernel.#open,exec(3)
exit(status = true) -> ()[permalink][rdoc]Rubyプログラムの実行を終了します。status として整 数が与えられた場合、その値を Ruby コマンドの終了ステータスとします。 デフォルトの終了ステータスは 0(正常終了)です。
status が true の場合 0、 false の場合 1 を引数に指定したとみなされます。この値はCレベルの定数 EXIT_SUCCESS、EXIT_FAILURE の値なので、正確には環境依存です。
exit は例外 SystemExit を発生させ ることによってプログラムの実行を終了させますので、 必要に応じて begin 節で捕捉することができます。
puts 'start'
begin
puts 'start1...'
exit
rescue SystemExit => err
puts "end1 with #{err.inspect}"
end
begin
puts 'start2...'
exit
ensure
puts 'end2...'
end
puts 'end' #実行されない
#=> start
# start1...
# end1 with #<SystemExit: exit>
# start2...
# end2...
#終了ステータス:0
[SEE_ALSO] Kernel.#exit!,Kernel.#abort, 制御構造/begin
exit!(status = false) -> ()[permalink][rdoc]Rubyプログラムの実行を即座に終了します。 status として整数が与えられた場合、その値を Ruby コマンドの終了ステータスとします。 デフォルトの終了ステータスは 1 です。
status が true の場合 0、 false の場合 1 を引数に指定したとみなされます。この値はCレベルの定数 EXIT_SUCCESS、EXIT_FAILURE の値なので、正確には環境依存です。
exit! は exit とは違って、例外処理などは一切行ないませ ん。 Kernel.#fork の後、子プロセスを終了させる時などに用 いられます。
STDOUT.sync = true #表示前に終了しないようにする puts 'start' begin puts 'start1...' exit! ensure puts 'end1...' #実行されない end puts 'end' #実行されない #=> start # start1... #終了ステータス:1
[SEE_ALSO] Kernel.#exit,Kernel.#abort
raise -> ()[permalink][rdoc]fail -> ()raise(message) -> ()fail(message) -> ()raise(error_type, message = nil, backtrace = caller(0)) -> ()fail(error_type, message = nil, backtrace = caller(0)) -> ()例外を発生させます。 発生した例外は変数 $! に格納されます。また例外が 発生した時のスタックトレースは変数 $@ に格納され ます。発生した例外は rescue 節で捕捉できます。
引数無しの場合は、同スレッドの同じブロック内で最後に rescue された 例外オブジェクト ($!) を再発生させます。そのような 例外が存在しないが自身は捕捉されている時には例外 RuntimeError を発生させます。
begin
open("nonexist")
rescue
raise #=> `open': No such file or directory - "nonexist" (Errno::ENOENT)
end
引数を渡した場合は、例外メッセージ message を持った error_type の示す例外(省略時 RuntimeError)を 発生させます。
error_type として例外ではないクラスやオブジェクトを指定した場合、 そのオブジェクトの exception メソッドが返す値を発生する例外にします。 その際、exception メソッドに引数として変数 message を渡すことができます。
例外の捕捉の例を示します。
#例1
begin
raise NameError,"!!error!!"
rescue ArgumentError => err
rescue NameError => err
rescue TypeError => err
ensure
p err #=> #<NameError: !!error!!>
end
#例2
def foo num
print 'in method.'
raise "error!!" if num <= 9
rescue RuntimeError
num += 10
print 'in rescue.'
retry
else
print 'in else.'
ensure
print "in ensure.\n"
end
foo(4) #=> in method.in rescue.in method.in else.in ensure.
#例3
class MyException
def exception(mesg=nil)
SecurityError.new(mesg)
end
end
begin
raise MyException.new
rescue SecurityError
p $! #=> #<SecurityError: SecurityError>
end
[SEE_ALSO] Kernel.#caller
fork -> Integer | nil[permalink][rdoc]fork { ... } -> Integer | nilfork(2) システムコールを使ってプロセスの複製を作 ります。親プロセスでは子プロセスのプロセスIDを、子プロセスでは nil を返します。ブロックを指定して呼び出した場合には、生成し た子プロセスでブロックを評価します。
fork 前に STDOUT と STDERR を IO#flush します。
sprintf(format, *arg) -> String[permalink][rdoc]format(format, *arg) -> Stringformat 文字列を C 言語の sprintf と同じように解釈し、 引数をフォーマットした文字列を返します。
[SEE_ALSO] Kernel.#printf,Time#strftime,Date.strptime
Ruby の sprintf フォーマットは基本的に C 言語の sprintf(3) のものと同じです。ただし、short や long などの C 特有の型に対する修飾子が ないこと、2進数の指示子(%b, %B)が存在すること、sprintf のすべての方言をサ ポートしていないこと(%': 3桁区切り)などの違いがあります。
Ruby には整数の大きさに上限がないので、%b, %B, %o, %x, %X に負の数を与えると (左側に無限に1が続くとみなせるので) ..f のような表示をします。絶対値に符号を付けた形式 で出力するためには %+x、% x のように指定します。
以下は sprintf フォーマットの書式です。[] で囲まれた部分は省略可 能であることを示しています。
%[nth$][フラグ][幅][.精度]指示子
`%' 自身を出力するには `%%' とします。
以下それぞれの要素に関して説明します。
フラグには #, +, ' '(スペース), -, 0 の5種類があります。
2進、8進、16進の指示子(b, B, o, x, X) ではそれぞれプレフィック スとして "0b", "0B", "0", "0x", "0X" を付加します。 C 言語とは異なり引数が 0 の場合にもプレフィックスが付加されます。
p sprintf("%#b", 10) #=> "0b1010"
p sprintf("%#B", 10) #=> "0B1010"
p sprintf("%#b", 0) #=> "0b0"
p sprintf("%#o", 10) #=> "012"
p sprintf("%#x", 10) #=> "0xa"
p sprintf("%#X", 10) #=> "0XA"
浮動小数点数 (f, e, E, g, G) に対しては必ず出力に"."をつけます。
p sprintf("%.0f", 10) #=> "10"
p sprintf("%#.0f", 10) #=> "10."
p sprintf("%.0e", 10) #=> "1e+01"
p sprintf("%#.0e", 10) #=> "1.e+01"
また g, G では上記に加えて末尾の余分な0が残ります。
p sprintf("%.05g", 10) #=> "10"
p sprintf("%#.05g", 10) #=> "10.000"
出力文字列を符号付きにします。特に正の数では`+'が付加されます。 数値の指示子 (d, i, b, B, o, x, X, u, f, e, E, g, G) に対してだけ意味を持ちます。 また、特に b, B, o, x, X, u に対しては、負数に対して "-" を付加することを示します。
p sprintf("%d", 1) #=> "1"
p sprintf("%+d", 1) #=> "+1"
p sprintf("%x", -1) #=> "..f" # ".." は無限に f が続くことを表している
p sprintf("%+x", -1) #=> "-1"
`+' と同じですが正の符号 `+' の代わりに空白を用います。数値の指示子 (d, i, b, B, o, x, X, u, f, e, E, g, G) に対してだけ意味を持ちます。
p sprintf("%d", 1) #=> "1"
p sprintf("%+d", 1) #=> "+1"
p sprintf("% d", 1) #=> " 1"
p sprintf("%x", -1) #=> "..f"
p sprintf("% x", 1) #=> " 1"
p sprintf("% x", -1) #=> "-1"
出力を左詰めにします幅の指定がなければ 意味がありません。
出力が右詰めの場合に余った部分に空白の代わりに "0" を詰めます。
数値の指示子の一部(d, i, b, B, o, x, X, u, f, g, G)に対し てだけ意味を持ちます(e, E には意味がない)
p sprintf("%010d", 10) #=> "0000000010"
`#' と一緒に指定した場合の出力は以下のようになります。
p sprintf("%#010x", 10) #=> "0x0000000a"
p sprintf("%#010o", 10) #=> "0000000012"
p sprintf("%#010b", 10) #=> "0b00001010"
これは、以下と同じです。
p sprintf("%#10.8x", 10) #=> "0x0000000a"
p sprintf("%#10.9o", 10) #=> "0000000012"
p sprintf("%#10.8b", 10) #=> "0b00001010"
通常は、以下のようになります。
p sprintf("%#10x", 10) #=> " 0xa"
p sprintf("%#10o", 10) #=> " 012"
p sprintf("%#10b", 10) #=> " 0b1010"
0以外の数字で始まる数字列は幅指定になります。幅は生成文字列の長さを示 します。後述の精度の値によらずこの幅分だ けの文字列が生成されます。
幅の指定はフラグで付与される " ", "+", "-", "0b", "0B", "0", "0x", "0X" の長さも考慮されます。
p sprintf("%+5d", 11) #=> " +11"
p sprintf("%+-5d", 11) #=> "+11 "
p sprintf("%+05d", 11) #=> "+0011"
幅は「最低限必要な幅」の指定になります。結果の文字列が指定した幅を超 える場合は幅の指定は無効になります。
幅として `*' を指定すると幅の値を引数から得ることになります。
p sprintf("%#05x", 10) #=> "0x00a"
p sprintf("%#0*x", 5, 10) #=> "0x00a"
"." の後に続く数字列は精度を表します("." のみの場合 ".0" と同じです)。精度は 整数の指示子 (d, i, b, B, o, x, X, u) に対しては、数値列部分の長さを意味します。
p sprintf("%10.5d", 1) #=> " 00001"
p sprintf("%#10.5x", 1) #=> " 0x00001"
p sprintf("%+10.5x", 1) #=> " +00001"
浮動小数点数の指示子 (f) に対しては小数部の桁数を意味します。
p sprintf("%10.5f", 1) #=> " 1.00000"
p sprintf("%10.5f", 10) #=> " 10.00000"
浮動小数点数の指示子 (e, E, g, G) に対しては有効桁数を意味します。
p sprintf("%10.5e", 1) #=> "1.00000e+00"
p sprintf("%10.5e", 10) #=> "1.00000e+01"
p sprintf("%10.5g", 10) #=> " 10"
p sprintf("%#10.5G", 10) #=> " 10.000"
文字列の指示子(s, p) に対しては引数の文字列のうち指定した数を超える分を切り捨てます。 幅と精度を同じ値にすれば、どのような引数に対してもその 長さだけの出力を行うことになります。
p sprintf("%10.2s", "foo") #=> " fo"
p sprintf("%5.5s", "foo") #=> " foo"
p sprintf("%5.5s", "foobar") #=> "fooba"
精度として `*' を指定すると精度の値を引数から得ることになります。
p sprintf("%.5s", "foobar") #=> "fooba"
p sprintf("%.*s", 5, "foobar") #=> "fooba"
指示子は引数の型の解釈を示します。指示子を省略することはできません。 指示子には大きく分けて
があります
引数の数値(0〜255)を文字コードとみなして対応する文字を出力します。 引数が数値以外のオブジェクトの場合 to_int メソッドによる変換を試みます。
p sprintf("%c", 97) #=> "a"
フラグ `-' と幅 の指定だけが意味を持ちます。
文字列を出力します。
引数が String オブジェクトでなければ to_s メソッドにより文字列化 したものを引数として扱います。
Object#inspect の結果を出力します。
p sprintf("%s", /e+/) #=> "(?-mix:e+)"
p sprintf("%p", /e+/) #=> "/e+/"
引数の数値を10進表現の整数として出力します。
引数が整数でなければ関数 Kernel.#Integer と同じ規則で整数に 変換されます。
p sprintf("%d", -1) #=> "-1"
p sprintf("%d", 3.1) #=> "3"
p sprintf("%d", '0b1010') #=> "10"
引数の数値を符号なし整数とみなして10進表現の整数として出力します。
p sprintf("%u", '0b1010') #=> "10"
p sprintf("%u", -1) #=> "..4294967295" (warning)
整数をそれぞれ2進、2進(大文字)、8進、16進、16進(大文字)表現の文字列で出力します。
`#' フラグを指定すれば "0b", "0B", "0", "0x", "0X" を先頭に付加します。
`+', ` ' フラグがない場合、負の数には ".." が先頭(`#' フラグがあれば "0x" などの後)に付加されます。これは最上位桁の文字が無限に続くことを 意味し、2の補数表現で負の数を表しています。
p sprintf("%#b", 10) #=> "0b1010"
p sprintf("%#B", 10) #=> "0B1010"
p sprintf("%#o", 10) #=> "012"
p sprintf("%#x", 10) #=> "0xa"
p sprintf("%#X", 10) #=> "0XA"
# 負の数に対して ".." が付加されます
p sprintf("%#b", -1) #=> "0b..1"
p sprintf("%#o", -1) #=> "0..7"
p sprintf("%#x", -1) #=> "0x..f"
p sprintf("%10x", -1) #=> " ..f"
p sprintf("%-10x", -1) #=> "..f "
# 「精度」を指定した場合、".." は付加されません
p sprintf("%.10x", -1) #=> "ffffffffff"
f は小数点表現(xxx.xxx)で数値を出力します。
e は指数表現(x.xxxe+xx)で数値を出力します。
g は 指数が -4 より小さいか精度以上の場合に e と同じ出力を、それ以 外では f と同じ出力を行います。ただし、小数部の末尾の0は取り除かれ ます。
大文字の指示子(E, G)は出力のアルファベットを大文字にします。
p sprintf("%f", 1.0) #=> "1.000000"
p sprintf("%e", 1.0) #=> "1.000000e+00"
p sprintf("%g", 1.0) #=> "1"
p sprintf("%f", 10.1) #=> "10.100000"
p sprintf("%e", 10.1) #=> "1.010000e+01"
p sprintf("%g", 10.1) #=> "10.1"
p sprintf("%g", 10 ** 6) #=> "1e+06"
p sprintf("%g", 10 ** -5) #=> "1e-05"
精度の省略値は 6 です。
無限大、NaN(Not a Number) に対する出力は以下のとおりです。
p sprintf("%f", 1.0/0) #=> "inf"
p sprintf("%f", -1.0/0) #=> "-inf"
p sprintf("%f", 0.0/0) #=> "nan"
p sprintf("%E", 1.0/0) #=> "INF"
p sprintf("%E", -1.0/0) #=> "-INF"
p sprintf("%E", 0.0/0) #=> "NAN"
f, e, E, g, G に関しては sprintf(3) の結果を利用しています。従って出力結果は 実際にはシステムに依存することになります。
利用頻度が低いので最後に説明します。
nth 番目の引数のフォーマットを行うことを示します。
p sprintf("%d, %x, %o", 1, 2, 3) #=> "1, 2, 3"
p sprintf("%3$d, %2$x, %1$o", 1, 2, 3) #=> "3, 2, 1"
p sprintf("%1$d, %1$x, %1$o", 10) #=> "10, a, 12"
状況によってフォーマットを変えたいが引数の順序を変えたくない場合に使 用します。
case ENV['LC_TIME']
when /^ja_JP/
fmt = "%1$d年%2$d月%3$d日"
else
fmt = "%2$02d/%03$2d/%1$02d"
end
p sprintf(fmt, 1, 4, 22) #=> "04/22/01"
"*" の後に指定することで幅や 精度を引数で指定することもできます。
p sprintf("%5.2f", 1) #=> " 1.00"
p sprintf("%*.*f", 5, 2, 1) #=> " 1.00"
p sprintf("%1$*2$.*3$f", 1, 5, 2) #=> " 1.00"
getc -> Fixnum | nil[permalink][rdoc]このメソッドは廃止予定です。代わりに STDIN.getc を使ってください。
[SEE_ALSO] IO#getc
gets(rs = $/) -> String | nil[permalink][rdoc]ARGFから一行読み込んで、それを返します。 行の区切りは引数 rs で指定した文字列になります。
rs に nil を指定すると行区切りなしとみなしてファイルの内容を すべて読み込みます。ARGVに複数のファイル名が存在する場合は1度に1ファイルずつ読み込みます。 空文字列 "" を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。
読み込んだ文字列は組み込み変数 $_ にもセットされます。
---main.rb---
ARGV << 'b.txt' << 'c.txt'
p gets #=> "hello\n"
p gets(nil) #=> "it\ncommon\n"
p gets("") #=> "ARGF\n\n"
p gets('、') #=> "スクリプトに指定した引数 (Object::ARGV を参照) をファイル名と\nみなして、"
p gets #=> "それらのファイルを連結した 1 つの仮想ファイルを表すオブジェクトです。 \n"
p gets #=> nil
p readline # end of file reached (EOFError)
--- b.txt ---
hello
it
common
--- c.txt ---
ARGF
スクリプトに指定した引数 (Object::ARGV を参照) をファイル名と
みなして、それらのファイルを連結した 1 つの仮想ファイルを表すオブジェクトです。
[SEE_ALSO] $/,ARGF,Kernel.#readlines,Kernel.#readline
global_variables -> [String][permalink][rdoc]プログラム中で定義されているグローバル変数(`$'で始まる変数)名の 配列を返します。
p global_variables #=> ["$-p", "$-I", "$-v" ... ]
[SEE_ALSO] Kernel.#local_variables,Object#instance_variables,Module.constants,Module#constants,Module#class_variables
gsub(pattern, replace) -> String[permalink][rdoc]gsub!(pattern, replace) -> Stringgsub(pattern) {|matched| ... } -> Stringgsub!(pattern) {|matched| ... } -> String組み込み変数 $_ の指す文字列内で pattern に マッチする部分を全て replace に置き換えます。$_ を返します。
$_.gsub, $_.gsub! とほぼ同じです。
暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。 今後はより明示的な $_.gsub, $_.gsub! を使ってください。
$_.gsub とこのメソッド gsub は以下の点で違いがあります。
[SEE_ALSO] String#gsub,$_
proc { ... } -> Proc[permalink][rdoc]lambda { ... } -> Procproc -> Proclambda -> Proc与えられたブロックから手続きオブジェクト (Proc のインスタンス) を生成して返します。Proc.new に近い働きをします。
ブロックが指定されなければ、呼び出し元のメソッドで指定されたブロック を手続きオブジェクトとして返します。呼び出し元のメソッドがブロックなし で呼ばれると ArgumentError 例外が発生します。
ただし、ブロックを指定しない呼び出しは推奨されていません。呼び出し元のメソッドで指定されたブロック を得たい場合は明示的に & 引数でうけるべきです。
def foo &block
lambda(&block)
end
it = foo{p 12}
it.call #=> 12
手続きオブジェクトを中断して、呼出し元(呼び出しブロックでは yield、それ以外では Proc#call) へジャンプし値を返すには next を使います。break や return ではありません。
例:
def foo
f = Proc.new{
next 1
2
}
end
p foo().call #=> 1
ブロック付きメソッドに対して Proc オブジェクトを `&' を指定して渡すと 呼び出しブロックのように動作します。 しかし、厳密には以下の違いがあります これらは、Proc オブジェクトが呼び出しブロックとして振舞う際の制限です。
# 問題なし
(1..5).each { break }
# LocalJumpError が発生します。
pr = Proc.new { break }
(1..5).each(&pr)
# each 再実行
pr = Proc.new { retry }
(1..5).each(&pr)
Kernel.#lambda と Proc.new はどちらも Proc クラスのインスタンス(手続きオブジェクト)を生成しますが、 生成された手続きオブジェクトはいくつかの場面で挙動が異なります。 lambda の生成する手続きオブジェクトのほうが よりメソッドに近い働きをするように設計されています。
Kernel.#proc は lambda と同じになります。 引数に & を付けることで手続きオブジェクト化したブロックは、Proc.new で生成されたそれと 同じにように振る舞います。
lambda のほうがより厳密です。引数の数が違っていると（メソッドのように）エラーになります。 Proc.new は引数を多重代入に近い扱い方をします。
例:
b1 = Proc.new{|a,b,c|
p a,b,c
}
b1.call(2, 4)
#=> 2
4
nil
b2 = lambda{|a,b,c|
p a,b,c
}
b2.call(2, 4)
#=> wrong number of arguments (2 for 3) (ArgumentError)
メソッド呼び出し(super・ブロック付き・yield)/ブロックパラメータの挙動 も参照してください。
return と break は、lambda と Proc.new では挙動が異なります。 例えば return を行った場合、lambda では手続きオブジェクト自身を抜けますが、 Proc.new では手続きオブジェクトを囲むメソッドを抜けます。
例:
def foo
f = Proc.new { return :foo }
f.call
return
end
def bar
f = lambda { return :bar }
f.call
return
end
def h
yield
end
def hoge
h{ return :hoge }
nil
end
p foo() #=> :foo
p bar() #=> nil
p hoge() #=> :hoge
以下の表は、手続きオブジェクトの実行を上の例と同じように、手続きオブジェクトが定義されたのと 同じメソッド内で行った場合の結果です。
return next break
Proc.new メソッドを抜ける 手続きオブジェクトを抜ける 例外が発生する
proc 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける
lambda 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける
イテレータ メソッドを抜ける 手続きオブジェクトを抜ける メソッドを抜ける
Proc を生成したメソッドから脱出した後、手続きオブジェクトからの return, retry, break は例外 LocalJumpError を発生させます。 ただし、上でも説明した通り lambda で生成した手続きオブジェクトはメソッドと同じように振る舞う ことを意図されているため、例外 LocalJumpError は発生しません。
例:
def foo
Proc.new { return }
end
foo.call
# => in `call': return from proc-closure (LocalJumpError)
def foo
Proc.new { retry }
end
foo.call
# => in `call': retry from proc-closure (LocalJumpError)
以下の表は、手続きオブジェクトの実行を上の例と同じように、手続きオブジェクトが定義されたメソッドを 脱出してから行った場合の結果です。
return next break
Proc.new 例外が発生する 手続きオブジェクトを抜ける 例外が発生する
proc 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける
lambda 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける 手続きオブジェクトを抜ける
load(file, priv = false) -> true[permalink][rdoc]Ruby プログラム file をロードして実行します。再ロード可能です。
file が絶対パスのときは file からロードします。 file が相対パスのときは組み込み変数 $: に示されるパスとカレントディレクトリを順番に探し、最初に見付かったファイルを ロードします。このとき、$: の要素文字列の先頭文字が `~' (チルダ) だと、環境変数 HOME の値に展開されます。 また `~USER' はそのユーザのホームディレクトリに展開されます。
ロードに成功した場合は true を返します。
[SEE_ALSO] Kernel.#require
Kernel.#require は同じファイルは一度だけしかロードしませんが、 Kernel.#load は無条件にロードします。 また、require は拡張子.rb や .so を自動的に補完しますが、 load は行いません。 require はライブラリのロード、load は 設定ファイルの読み込みなどに使うのが典型的な用途です。
# 使用例
load "#{ENV['HOME']}/.myapprc"
load "/etc/myapprc"
なお、特定のディレクトリからファイルをロードしたい場合、 load 'filename' とするのは不適切です。必ず絶対パスを 使ってください。
local_variables -> [String][permalink][rdoc]現在のスコープで定義されているローカル変数名の配列を返します。
yuyu = 0 p local_variables #=> ["yuyu"]
[SEE_ALSO] Kernel.#global_variables,Object#instance_variables,Module.constants,Module#constants,Module#class_variables
loop { ... } -> object[permalink][rdoc](中断されない限り)永遠にブロックの評価を繰り返します。
与えられたブロック内で StopIteration を Kernel.#raise すると ループを終了して nil を返します。 ループを終了させる場合、通常は break を使用してください。
def try int
n = 0
loop do
n += 1
break(n) if rand(n) > int
end
end
puts "end on #{try(400)}" #=> end on ???
open(name, mode = 'r', perm = nil, options = {}) -> StringIO | File[permalink][rdoc] [redefined by open-uri]
open(name, mode = 'r', perm = nil, options = {}) {|ouri| ...} -> nil [redefined by open-uri]
name が http:// や ftp:// で始まっている文字列なら URI のリソースを 取得した上で StringIO オブジェクトとして返します。 StringIO オブジェクトは OpenURI::Meta モジュールで extend されています。
name に open メソッドが定義されている場合は、*rest を引数として渡し name.open(*rest, &block) のように name の open メソッドが呼ばれます。
これ以外の場合は、name はファイル名として扱われ、従来の Kernel.#open(name, *rest) が呼ばれます。
ブロックを与えた場合は上の場合と同様、name が http:// や ftp:// で 始まっている文字列なら URI のリソースを取得した上で StringIO オブジェクトを 引数としてブロックを評価します。後は同様です。 StringIO オブジェクトは OpenURI::Meta モジュールで extend されています。
例:
require 'open-uri'
sio = open('http://www.example.com')
p sio.is_a?(OpenURI::Meta) # => true
p sio.content_type
puts sio.read
[SEE_ALSO] OpenURI.open_uri
open(file, mode = "r", perm = 0666) -> IO[permalink][rdoc]open(file, mode = "r", perm = 0666) {|io| ... } -> objectfile をオープンして、IO（Fileを含む）クラスのインスタンスを返します。
ブロックが与えられた場合、指定されたファイルをオープンし、 生成した IO オブジェクトを引数としてブロックを実行します。 ブロックの終了時や例外によりブロックを脱出するとき、 ファイルをクローズします。ブロックを評価した結果を返します。
ファイル名 file が `|' で始まる時には続く文字列をコマンドとして起動し、 コマンドの標準入出力に対してパイプラインを生成します
ファイル名が "|-" である時、open は Ruby の子プロセス を生成し、その子プロセスとの間のパイプ(IOオブジェクト)を返し ます。(このときの動作は、IO.popen と同じです。 File.open にはパイプラインを生成する機能はありません)。
Perlと異なりコマンドは常に `|' で始まります。
[SEE_ALSO] File.open,IO.popen,IO.open
文字列("mode" か "mode:ext_enc" か "mode:ext_enc:int_enc" という形式)か 整数(File::Constants モジュールの定数の論理和)を組み合わせて指定します。
mode は以下の三つのうちのいずれかです。
ファイルを読み込みモードでオープンします。（デフォルトのモード）
ファイルを書き込みモードでオープンします。 オープン時にファイルがすでに存在していれば その内容を空にします。
ファイルを書き込みモードでオープンします。 出力は 常に ファイルの末尾に追加されます。 例えば、ファイルオープン中にファイルのサイズが小さ くなってもその末尾に出力されます。
以上の3つの後に "+" があれば、ファイルは読み書き両用モード (RDWR) でオープンされます。
ファイルの読み書き位置は先頭にセットされます。
"r+" と同じですが、オープン時にファイルがすでに 存在していればその内容を空にします。
"r+"と同様、ファイルの読み込み位置は先頭にセットされますが、 書き込みは常にファイル末尾に行われます。書き込みは IO#seek などの影響を受けません。
これらのいずれに対しても "b" フラグを ("r+b"のように) つけることがで きます (整数なら File::BINARY )。この場合、バイナリモードでオープン します (ただし、DOS/Windowsのようにシステムがテキスト／バイナリでファイルを区別する場 合に限ります)
p(*arg) -> nil[permalink][rdoc]引数を人間に読みやすい形に整形して改行と順番に標準出力 $stdout に出力します。主にデバッグに使用します。
引数の inspect メソッドの返り値と改行を順番に出力します。つまり以下のコードと同じです。
print arg[0].inspect, "\n", arg[1].inspect, "\n", ...
整形に用いられるObject#inspectは普通に文字列に変換すると 区別がつかなくなるようなクラス間の差異も表現できるように工夫されています。
p に引数を与えずに呼び出した場合は特に何もしません。
puts "" #=> （空行） p "" #=> "" puts 50,"50" #=> 50 #=> 50 p 50,"50" #=> 50 #=> "50"
[SEE_ALSO] Object#inspect,Kernel.#puts,Kernel.#print
print(*arg) -> nil[permalink][rdoc]引数を順に標準出力 $stdout に出力します。引数が与えられない時には変数 $_ の値を出力します。
文字列以外のオブジェクトが引数として与えられた場合には、 to_s メソッドにより文字列に変換してから出力します。 ただし、nil に対しては文字列 "nil" を出力します
変数 $, (出力フィールドセパレータ)に nil で ない値がセットされている時には、各引数の間にその文字列を出力します。 変数 $\ (出力レコードセパレータ)に nil でな い値がセットされている時には、最後にそれを出力します。
print "Hello, world!" print "Regexp is",/ant/ print nil print "\n" #=> Hello, world!Regexp is(?-mix:ant)nil $_ = "input" $, = "<and>" $\ = "<end>\n" print print "AA","BB" #=> input<end> #=> AA<and>BB<end>
[SEE_ALSO] Kernel.#puts,Kernel.#p
printf(format, *arg) -> nil[permalink][rdoc]printf(port, format, *arg) -> nilC 言語の printf と同じように、format に従い引数を文字列に変 換して port に出力します。
port を省略した場合は標準出力 $stdout に出力します。
引数を 1 つも指定しなければ何もしません。
Ruby における format 文字列の拡張については Kernel.#sprintfの項を参照してください。
printf("calculate%3s%-6s%.15f", 'PI', '...', Math::PI)
#=> calculate PI... 3.141592653589793
printf("%d %04x", 123, 123) #=> "123 007b"
printf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'"
printf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello"
printf("%1$*2$s %2$d", "hello", -8) #=> "hello -8"
printf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23"
printf("%u", -123) #=> "..4294967173"
[SEE_ALSO] Kernel.#sprintf,IO#printf
putc(ch) -> object[permalink][rdoc]文字 ch を 標準出力 $stdout に出力します。
ch が数値なら 0 〜 255 の範囲の対応する文字を出力します。 ch が文字列なら、その先頭 1byte を出力します。 どちらでもない場合は、ch.to_int で整数に変換を試みます。
putc("ch")
putc(?c)
putc(99)
putc(355)
#=> cccc
putc(99.00) #=> c
putc(33333333333333333333333333333333333) # bignum too big to convert into `long' (RangeError)
[SEE_ALSO] IO#putc
puts(*arg) -> nil[permalink][rdoc]引数と改行を順番に 標準出力 $stdout に出力します。 引数がなければ改行のみを出力します。
引数が配列の場合、その要素と改行を順に出力します。 配列や文字列以外のオブジェクトが引数として与えられた場合には、 当該オブジェクトを最初に to_ary により配列へ、 次に to_s メソッドにより文字列へ変換を試みます。 ただし、nil に対しては文字列 "nil" を出力します 末尾が改行で終っている引数や配列の要素に対しては puts 自身 は改行を出力しません。
puts "foo", "bar\n", "baz" puts "" # 改行のみ出力 puts # 改行のみ出力 puts nil puts ["oui", "non"] #=> foo # bar # baz # # # nil # oui # non
[SEE_ALSO] Kernel.#print, Kernel.#p, IO#puts
rand(max = 0) -> Integer | Float[permalink][rdoc]擬似乱数を発生させます。
max が 0 の場合は 0.0 以上 1.0 未満の実数を、正の整数の場合は 0 以上 max 未満の整数を返します。 それ以外の値を指定した場合は max.to_int の絶対値が指定されたものとして扱います。
まだ Kernel.#srand が呼ばれていなければ自動的に呼び出します。
srand(1234) # 乱数の種を設定する。
rand #=> 0.1915194503788923
rand #=> 0.6221087710398319
rand(10) #=> 4
rand(5.5) #=> 0
# rand(5) と同じ。 5 が乱数値の範囲に含まれないことに注意。
[SEE_ALSO] Kernel.#srand
readline(rs = $/) -> String[permalink][rdoc]ARGFから一行読み込んで、それを返します。 行の区切りは引数 rs で指定した文字列になります。
rs に nil を指定すると行区切りなしとみなしてファイルの内容を すべて読み込みます。ARGVに複数のファイル名が存在する場合は1度に1ファイルずつ読み込みます。 空文字列 "" を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。
読み込んだ文字列は組み込み変数 $_ にもセットされます。
---main.rb---
ARGV << 'b.txt' << 'c.txt'
p readline #=> "hello\n"
p readline(nil) #=> "it\ncommon\n"
p readline("") #=> "ARGF\n\n"
p readline('、') #=> "スクリプトに指定した引数 (Object::ARGV を参照) をファイル名と\nみなして、"
p readline #=> "それらのファイルを連結した 1 つの仮想ファイルを表すオブジェクトです。 \n"
p readline # end of file reached (EOFError)
--- b.txt ---
hello
it
common
--- c.txt ---
ARGF
スクリプトに指定した引数 (Object::ARGV を参照) をファイル名と
みなして、それらのファイルを連結した 1 つの仮想ファイルを表すオブジェクトです。
[SEE_ALSO] $/,ARGF,Kernel.#readlines,Kernel.#gets
readlines(rs = $/) -> [String] | nil[permalink][rdoc]ARGFを Kernel.#gets(rs) でEOFまで読み込んで、その各行を要素としてもつ配列を返します。 行の区切りは引数 rs で指定した文字列になります。
rs に nil を指定すると行区切りなしとみなします。 空文字列 "" を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。
---main.rb---
ARGV << 'b.txt' << 'b.txt'
p readlines #=> ["hello\n", "it\n", "\n", "common\n", "hello\n", "it\n", "\n", "common\n"]
ARGV << 'b.txt' << 'b.txt'
p readlines(nil) #=> ["hello\nit\n\ncommon\n", "hello\nit\n\ncommon\n"]
ARGV << 'b.txt' << 'b.txt'
p readlines("") #=> ["hello\nit\n\n", "common\n", "hello\nit\n\n", "common\n"]
ARGV << 'b.txt' << 'b.txt'
p readlines('it') #=> ["hello\nit", "\n\ncommon\n", "hello\nit", "\n\ncommon\n"]
p readlines #=> nil
--- b.txt ---
hello
it
common
[SEE_ALSO] $/,ARGF,Kernel.#gets
require(feature) -> bool[permalink][rdoc]Ruby ライブラリ feature をロードします。拡張子補完を行い、 同じファイルの複数回ロードはしません。
feature が絶対パスのときは feature からロードします。 feature が相対パスのときは組み込み変数 $: に示されるパスを順番に探し、最初に見付かったファイルを ロードします。このとき、$: の要素文字列の先頭文字が `~' (チルダ) だと、環境変数 HOME の値に展開されます。 また `~USER' はそのユーザのホームディレクトリに展開されます。
Ruby ライブラリとは Ruby スクリプト (*.rb) か拡張ライブラリ (*.so,*.o,*.dll など) であり、feature の拡張子が省略された場合はその 両方から探します( *.rb が優先されます)。 省略されなかった場合は指定された種別のみを探します。 また、feature の拡張子にはアーキテクチャで実際に使われる拡張子に 関らず拡張ライブラリの拡張子として常に .so を用いることができます（内部で適切に変換されます）。
ライブラリのロードに成功した時には true を返し、ロードした feature の名前を(拡 張子も含めて) 変数 $" に追加します。ただし、feature の名前が既に $" に含まれていた場合はロードせずに false を返します。
[SEE_ALSO] Kernel.#load,Kernel.#autoload
ローカル変数はファイル間では共有されません。ですので、 ロードしたライブラリのローカル変数を ロード元のスクリプトから直接取得することはできません。 このスコープの扱い方はKernel.#loadでも同様です。
---------- some.rb ----------- $a = 1 @a = 1 A = 1 a = 1 ---------- end some.rb ------- require 'some' p $a #=> 1 p @a #=> 1 p A #=> 1 p a # undefined local variable or method `a' for #<Object:0x294f9ec @a=1> (NameError)
scan(pattern) -> [String] | [[String]][permalink][rdoc]scan(pattern) {|matched| ... } -> [String] | [[String]]$_.scan と同じです。
暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。 今後はより明示的な $_.scan を使ってください。
[SEE_ALSO] String#scan,$_
select(reads, writes = [], excepts = [], timeout = nil) -> [[IO]] | nil[permalink][rdoc]IO.select と同じです。
[SEE_ALSO] IO.select
set_trace_func(proc) -> Proc[permalink][rdoc]Ruby インタプリタのイベントをトレースする Proc オブジェクトとして 指定された proc を登録します。 nil を指定するとトレースがオフになります。
Ruby インタプリタがプログラムを実行する過程で、メソッドの呼び出しや 式の評価などのイベントが発生する度に、以下で説明する6個の引数とともに 登録された Proc オブジェクトを実行します。
標準添付の debug、tracer、 profile はこの組み込み関数を利用して実現されています。
渡す Proc オブジェクトのパラメータは
proc{|event, file, line, id, binding, klass| ... }
で、意味は以下の通りです。
実行のタイプを表す、以下のいずれかの文字列。
"line": 式の評価。 "call": メソッドの呼び出し。 "return": メソッド呼び出しからのリターン。 "c-call": Cで記述されたメソッドの呼び出し。 "c-return": Cで記述されたメソッド呼び出しからのリターン。 "class": クラス定義、特異クラス定義、モジュール定義への突入。 "end": クラス定義、特異クラス定義、モジュール定義の終了。 "raise": 例外の発生。
実行中のプログラムのソースファイル名 (文字列)。
実行中のプログラムのソースファイル上の行番号 (整数)。
event に応じ、以下のものが渡されます。 第六ブロック引数の klass と対応しています。
line
最後に呼び出されたメソッドを表す Symbol オブジェクト。
トップレベルでは nil。
call/return/c-call/c-return
呼び出された/リターンするメソッドを表す Symbol オブジェクト。
class/end
nil。
raise
最後に呼び出されたメソッドを表す Symbol オブジェクト。
トップレベルでは nil。
実行中のプログラムのコンテキストを表す Binding オブジェクト。
event に応じ、以下のものが渡されます。 第四ブロック引数の id と対応しています。
line
最後に呼び出されたメソッドが属するクラスを表す
Class オブジェクト。トップレベルでは nil。
call/return/c-call/c-return
呼び出された/リターンするメソッドが属するクラス
を表す Class オブジェクト。
class/end
nil。
raise
最後に呼び出されたメソッドが属するクラスを表す
Class オブジェクト。トップレベルでは nil。
例:
set_trace_func lambda {|*arg|
p arg
}
class Foo
end
43.to_s
# ----結果----
# ["c-return", "..", 3, :set_trace_func, #<Binding:0xf6ceb8>, Kernel]
# ["line", "..", 4, nil, #<Binding:0x10cbcd8>, nil]
# ["c-call", "..", 4, :inherited, #<Binding:0x10cba98>, Class]
# ["c-return", "..", 4, :inherited, #<Binding:0x10cb858>, Class]
# ["class", "..", 4, nil, #<Binding:0x10cb600>, nil]
# ["end", "..", 5, nil, #<Binding:0x10cb3f0>, nil]
# ["line", "..", 6, nil, #<Binding:0x10cb1e0>, nil]
# ["c-call", "..", 6, :to_s, #<Binding:0x10cafd0>, Fixnum]
# ["c-return", "..", 6, :to_s, #<Binding:0x10cad78>, Fixnum]
[SEE_ALSO] Kernel.#caller
sleep -> Integer[permalink][rdoc]sleep(sec) -> Integersec 秒だけプログラムの実行を停止します。
sec が省略された場合、他スレッドからの Thread#run などで明示的に起こさない限り永久にスリープします。Thread#runを呼ぶとその時点で sleepの実行が中断されます。
it = Thread.new do sleep puts 'it_end' end re = sleep 2.11 puts re it.run re2 = sleep 0.76 puts re2 #=> 2 # it_end # 1
split(sep = $/, limit = 0) -> [String][permalink][rdoc]$_.split と同じです。
暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。 今後はより明示的な $_.split を使ってください。
[SEE_ALSO] String#split,$_
srand -> Integer[permalink][rdoc]srand(seed) -> IntegerKernel.#rand の乱数の種を設定し、古い種を返します。
seed に整数を指定するとそれを乱数の種に設定します。 それ以外の値を指定した場合は seed.to_int が指定されたものとして扱います。 seed に既知の値を与えると、以前の Kernel.#rand の値を再現できます。
seed が省略された時には 現在の時刻やプロセス ID、srand を呼び出した回数、 また可能なら /dev/urandom から読み出したデータなどを元に種を作ります。
num = 455675 seeds = [] srand(num) p rand(6) #=> 3 p rand(6) #=> 0 p rand(0) #=> 0.445804380918972 p rand(0) #=> 0.422248634121701 seeds << srand p rand(6) #=> 3 p rand(6) #=> 3 p rand(0) #=> 0.938911141393347 p rand(0) #=> 0.915824970865251 seeds << srand(num) p rand(6) #=> 3 p rand(6) #=> 0 p rand(0) #=> 0.445804380918972 p rand(0) #=> 0.422248634121701 seeds << srand p seeds #=> [455675, 2995620310703489221660585195204777696, 455675]
[SEE_ALSO] Kernel.#rand
sub(pattern, replace) -> String[permalink][rdoc]sub!(pattern, replace) -> Stringsub(pattern) {|matched| ... } -> Stringsub!(pattern) {|matched| ... } -> String組み込み変数 $_ の指す文字列内で pattern に マッチする最初の部分を replace に置き換えます。$_ を返します。
$_.sub, $_.sub! とほぼ同じです。
暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。 今後はより明示的な $_.sub, $_.sub! を使ってください。
$_.sub とこのメソッド sub は以下の点で違いがあります。
[SEE_ALSO] String#sub,$_
syscall(num, *arg) -> Integer[permalink][rdoc]numで指定された番号のシステムコールを実行します。 第2引数以降をシステムコールの引数として渡します。
どの数値がどのシステムコールに対応するかは、 syscall(2) や /usr/include/sys/syscall.h を参照してください。
システムコールの慣習に従い、syscall(2) が -1 を返す場合には例外 Errno::EXXX が発生します。 それ以外では、返した値をそのまま数値で返します。
ライブラリ dl を使えばより高レベルな操作ができます。
[SEE_ALSO] dl, syscall(2freebsd), syscall(2linux)
system(command) -> bool[permalink][rdoc]引数を外部コマンドとして実行して、成功した時に真を返します。
子プロセスが終了ステータス 0 で終了すると成功とみなし true を返します。 それ以外の終了ステータスの場合 (コマンドを実行できなかった場合も含む)は false を返します。
終了ステータスは変数 $? で参照できます。
この形式では command が shell のメタ文字
* ? {} [] <> () ~ & | \ $ ; ' ` " \n
を含む場合、shell 経由で実行されます。 そうでなければインタプリタから直接実行されます。
[SEE_ALSO] Kernel.#`,Kernel.#exec,system(3)
system(program, *args) -> bool[permalink][rdoc]引数を外部コマンドとして実行して、成功した時に真を返します。
子プロセスが終了ステータス 0 で終了すると成功とみなし true を返します。 それ以外の終了ステータスの場合は false を返します。 コマンドを実行できなかった場合は nil を返します。
終了ステータスは変数 $? で参照できます。
この形式で呼び出した場合、空白や shell のメタキャラクタも そのまま program の引数に渡されます。 先頭の引数が2要素の配列であった場合、第1要素の文字列が実際に 起動するプログラムのパスであり、第2要素が「みせかけ」のプロ グラム名になります。 また、第1要素はフルパスで指定しなくても環境変数 PATH から探します。
[SEE_ALSO] Kernel.#`,Kernel.#exec,system(3)
test(cmd, file) -> bool | Time | Integer | nil[permalink][rdoc]単体のファイルでファイルテストを行います。
以下は cmd として指定できる数値リテラルとその意味です。
ファイルを実効 uid で読むことができる
ファイルに実効 uid で書くことができる
ファイルを実効 uid で実行することができる
ファイルの所有者が実効 uid である
ファイルのグループ所有者が実効 gid である
ファイルを実 uid で読むことができる
ファイルに実 uid で書くことができる
ファイルを実 uid で実行することができる
ファイルの所有者が実 uid である
ファイルが存在する
ファイルサイズが 0 である
ファイルサイズが 0 でない (ファイルサイズを返す、0 ならば nil) -> Integer|nil
ファイルはプレーンファイルである
ファイルはディレクトリである
ファイルはシンボリックリンクである
ファイルは名前つきパイプ(FIFO)である
ファイルはソケットである
ファイルはブロック特殊ファイルである
ファイルはキャラクター特殊ファイルである
ファイルに setuid ビットがセットされている
ファイルに setgid ビットがセットされている
ファイルに sticky ビットがセットされている
ファイルの最終更新時刻を返す -> Time
ファイルの最終アクセス時刻を返す -> Time
ファイルの inode 変更時刻を返す -> Time
test(cmd, file1, file2) -> bool[permalink][rdoc]２ファイル間のファイルテストを行います。
以下は cmd として指定できる数値リテラルとその意味です。
ファイル1とファイル2の最終更新時刻が等しい
ファイル1の方がファイル2より最終更新時刻が新しい
ファイル1の方がファイル2より最終更新時刻が古い
ファイル1とファイル2が同一のファイルである
throw(tag, value = nil) -> ()[permalink][rdoc]Kernel.#catchとの組み合わせで大域脱出を行います。 throw は同じ tag を指定した catch のブロックの終わりまでジャンプします。
throw は探索時に呼び出しスタックをさかのぼるので、 ジャンプ先は同じメソッド内にあるとは限りません。 もし ensure節 が存在するならジャンプ前に実行します。
同じ tag で待っている catch が存在しない場合は、例外で スレッドが終了します。
def foo
throw :exit, 25
end
ret = catch(:exit) do
begin
foo
some_process() # 絶対に実行されない
10
ensure
puts "ensure"
end
end
puts ret
#=> ensure
# 25
[SEE_ALSO] Kernel.#catch
trace_var(varname, hook) -> nil[permalink][rdoc]trace_var(varname) {|new_val| .... } -> niltrace_var(varname, hook) -> [String|Proc]グローバル変数 varname への代入のフックを登録します。
ここでの「グローバル変数」は、特殊変数 (変数と定数/組み込み変数 を参照)も含めた `$' で始まる変数のこ とです。
この呼び出し以降、varname で指定したグローバル変数に 値が代入されるたびに hook かブロックが評価されます。hook が Proc オブジェクトの場合 代入された値がブロック引数に渡されます。文字列の場合はRubyコードとして評価されます。
trace_var がフックするのは明示的な代入だけです。 フックは複数登録できます。
フックを解除するには、hook に nil を 指定するか、Kernel.#untrace_var を用います。
hook が nil ならば、設定されていた hook をすべて解除してその配列を返します(ブロックで登録されていれば Proc オブジェクトで返されます) それ以外は、nil を返します。
trace_var(:$v){|val| puts "hook: $v=#{val.inspect}" }
$v = 1 #=> hook: $v=1
$v = "foo" #=> hook: $v="foo"
$v.upcase!
p $v #=> "FOO"
[SEE_ALSO] Kernel.#untrace_var
trap(signal, command) -> String | Proc | nil[permalink][rdoc]trap(signal) { ... } -> String | Proc | nilsignal で指定された割り込みにたいするハンドラとして command を登録します。Signal.#trapと同じです。
Signal.#trapの使用を推奨します。
[SEE_ALSO] Signal.#trap,Signal
untrace_var(varname, hook = nil) -> [String|Proc][permalink][rdoc]グローバル変数 varname に関連付けられたフックを解除します。
hook が指定された場合にはそのフックだけを解除します。 省略するか nil を与えた場合は varname のフックを全て解除します。
trace_var(:$v){|val| print "hookA.#{val.inspect},\n" }
block = proc{|val| print "hookB.#{val.inspect}," }
trace_var(:$v,&block)
$v = 'str' #=> hookB."str",hookA."str",
untrace_var(:$v,block)
$v = 'str' #=> hookA."str",
trace_var(:$v){|val| print "hookC.#{val.inspect}," }
p untrace_var(:$v) #=> [#<Proc:0x02b68f58@..:9>, #<Proc:0x02b6978c@..:3>]
$v = 'str' # なにも出力されない
[SEE_ALSO] Kernel.#trace_var
warn(message) -> nil[permalink][rdoc]message を 標準エラー出力 $stderr に出力します。 $VERBOSE フラグ が nil のときは何も出力しません。
文字列以外のオブジェクトが引数として与えられた場合には、 to_s メソッドにより文字列に変換してから出力します。
このメソッドは以下と同じです。
$stderr.print message, "\n" unless $VERBOSE.nil? nil
warn "caution!" #=> caution! $VERBOSE = nil warn "caution!" # 何もしない
$! -> Exception | nil[permalink][rdoc]最後に例外が発生したときの Exception オブジェクトです。 該当する例外がないときは nil です。
Kernel.#raise によって設定されます。
この変数はスレッドローカルです。
$" -> [String][permalink][rdoc]$LOADED_FEATURES -> [String]Kernel.#require でロードされたファイル名を含む配列です。
Kernel.#require で同じファイルを 複数回ロードしないようにするためのロックとして使われます。
この変数はグローバルスコープです。
$$ -> Fixnum[permalink][rdoc]現在実行中の Ruby プロセスのプロセス ID です。 Process.#pid と同じです。
この変数はグローバルスコープです。
$& -> String | nil[permalink][rdoc]現在のスコープで最後に成功した正規表現のパターンマッチでマッチした文字列です。 最後のマッチが失敗していた場合には nil となります。
Regexp.last_match[0] と同じです。
この変数はローカルスコープかつスレッドローカル、読み取り専用です。 Ruby起動時の初期値は nil です。
str = '<p><a href="http://example.com">example.com</a></p>' if %r[<a href="(.*?)">(.*?)</a>] =~ str p $& end #=> "<a href=\"http://example.com\">example.com</a>"
$' -> String | nil[permalink][rdoc]現在のスコープで最後に成功した正規表現のパターンマッチでマッチした 部分より後ろの文字列です。 最後のマッチが失敗していた場合には nil となります。
Regexp.last_match.post_match と同じです。
この変数はローカルスコープかつスレッドローカル、読み取り専用です。 Ruby起動時の初期値は nil です。
str = '<p><a href="http://example.com">example.com</a></p>' if %r[<a href="(.*?)">(.*?)</a>] =~ str p $' end #=> "</p>"
$* -> [String][permalink][rdoc]Rubyスクリプトに与えられた引数を表す配列です。 組み込み定数 Object::ARGV の別名です。
Ruby 自身に対する引数は取り除かれています。
この変数はグローバルスコープです。
$+ -> String | nil[permalink][rdoc]現在のスコープで最後に成功した正規表現のパターンマッチで マッチした中で最後の括弧に対応する部分文字列です。
最後のマッチが失敗していた場合には nil。 いくつかある選択型のパターンのどれがマッチしたのか分からない時に便利です。
この変数はローカルスコープかつスレッドローカルです。
$, -> String | nil[permalink][rdoc]デフォルトの出力フィールド区切り文字列です。 Array#join で引数を省略した場合と、 Kernel.#print の各引数の間で出力されます。
デフォルト値は nil で、空文字列と同じ結果になります。
この変数はグローバルスコープです。
$/ -> String | nil[permalink][rdoc]$-0 -> String | nil入力レコード区切りを表す文字列です。 awk の RS 変数のように働きます。
Kernel.#gets のような「行」単位の読み込みメソッドが「行」の区切りとして使用します。 Rubyがコマンドオプション -0 付きで起動されたときには -0 で指定された値が規定値となります。そうでないとき、規定値は "\n" です。
この変数に nil を設定すると読み込みメソッドはファイル全体を一度に読み込みます。 空文字列 "" を設定するとパラグラフモードとみなされ、 2 つ以上連続した改行が「行」の区切りになります。
$/ には正規表現は使えません。
この変数はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$; -> Regexp | String | nil[permalink][rdoc]$-F -> Regexp | String | nilString#split で引数を省略した場合の区切り文字です。
nilを設定すると特殊な分割を行います。 詳細は String#split を参照してください。
コマンドラインオプション -F を指定して Ruby を起動した場合、 初期値は -F で指定した値です。 それ以外の時には初期値は nil です。
$; には任意のオブジェクトを代入できます。 ただし、String#split の仕様変更を考慮すると 常に正規表現を指定すべきです。
Ruby のバージョンによらず動作するプログラムを書くときは $; に頼らないコードを書くべきです。
この変数はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$: -> [String][permalink][rdoc]$LOAD_PATH -> [String]$-I -> [String]Rubyライブラリをロードするときの検索パスです。
Kernel.#load や Kernel.#require がファイルをロードする時に検索するディレクトリのリストを含む配列です。
起動時にはコマンドラインオプション -I で指定したディレクトリ、 環境変数 RUBYLIB の値、 コンパイル時に指定したデフォルト値 、"." (カレントディレクトリ) をこの順番で含みます。
以下に典型的な UNIX システム上でのロードパスを示します。
-I で指定したパス 環境変数 RUBYLIB の値 /usr/local/lib/ruby/site_ruby/VERSION サイト固有、バージョン依存のライブラリ /usr/local/lib/ruby/site_ruby/VERSION/ARCH サイト固有、システム依存、拡張ライブラリ /usr/local/lib/ruby/site_ruby サイト固有ライブラリ /usr/local/lib/ruby/VERSION 標準ライブラリ /usr/local/lib/ruby/VERSION/ARCH 標準、システム依存、拡張ライブラリ . カレントディレクトリ
上記表中の VERSION は Ruby のバージョンを表す文字列で、 「1.6」や「1.8」です。 ARCH はハードウェアと OS を表す文字列で、 「i686-linux」や「alpha-osf5.1」などです。 ARCH の値は 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' を実行すると、 以下のように foo.rb と foo.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 でないシステムでは 「.so」が適切な拡張子に変更されます。 例えば HP-UX では require 'foo.so' とすると foo.sl を検索します。 したがって Ruby で記述されたコードでは常に .so を使うべきです。
なお、ロードパスをコマンドラインから調べるには
$ ruby -e 'puts $:'
とします。
この変数はグローバルスコープです。
$KCODE -> String[permalink][rdoc]$-K -> StringRuby の認識するマルチバイト文字列エンコーディングです。 変数の値は "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 の以下の動作に影響します。
$KCODE はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$-a -> bool[permalink][rdoc]自動 split モードを表すフラグです。
コマンドラインオプション -a を使ったとき true に設定されます。 この変数には代入できません。
この変数はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$DEBUG -> bool[permalink][rdoc]$-d -> boolこの値が真のときはインタプリタがデバッグモードになります。
コマンドラインオプション -d でセットされます。 スクリプトから代入することもできます。
デバッグモードでは、通常モードに比べて以下の違いがあります。
この変数はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$-i -> bool[permalink][rdoc]in-place 置換モードで用いられます。
コマンドラインオプション -i を指定したとき、空文字列になります。 -i オプションに拡張子を渡した場合にはその拡張子が文字列として格納されます。
-i オプションが指定されていない時の値は nil です。
スクリプト内で $-i に代入することもでき、 その場合は Object::ARGV の次の ファイルを読み込み始めるタイミングで in-place 置換を開始します。
この変数はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$-l -> bool[permalink][rdoc]コマンドラインオプション -l を指定したとき true に設定されます。 この変数には代入できません。
この変数はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$-p -> bool[permalink][rdoc]コマンドラインオプション -p を指定したとき true に設定されます。 この変数には代入できません。
この変数はグローバルスコープです。
$VERBOSE -> bool | nil[permalink][rdoc]$-v -> bool | nil$-w -> bool | nil冗長メッセージフラグです。Rubyインタプリタへの コマンドラインオプション -v でセットされます。
警告レベルは三段階あり、それぞれ以下の通りです。
警告を出力しない
重要な警告のみ出力 (デフォルト)
すべての警告を出力する
$VERBOSE に nil, false 以外を代入すると値は true になります。
$VERBOSE の値はコマンドラインオプション -W でも設定できます。 -W0 オプションで nil、 -W1 オプションで false、 -W2, -W オプションで true が設定されます。 -v オプションや -w オプションを指定した場合は true が設定されます。
$VERBOSE はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$. -> Fixnum[permalink][rdoc]いずれかの IO オブジェクトが最後に読んだ行の行番号です。 Object::ARGF などの IO 互換のオブジェクトも $. を更新します。
IO からの読み込みが起きるタイミングが予測不能であるような複雑なプログラムでは使用すべきではありません。特に、マルチスレッドプログラムではスレッド間で競合を起こす可能性があります。 そのような場合には、 IO#lineno を使用してください。
この変数はグローバルスコープです。 Ruby起動時の初期値は 0 です。
$0 -> String[permalink][rdoc]$PROGRAM_NAME -> String現在実行中の Ruby スクリプトの名前を表す文字列です。
OS と Ruby のバージョンによっては、この変数に代入すると ps(1) の出力が変化します。 この機能はプログラムの現在の状態を表示するのに便利です。
この変数はグローバルスコープです。
$1 -> String | nil[permalink][rdoc]$2 -> String | nil$3 -> String | nil$4 -> String | nil$5 -> String | nil$6 -> String | nil$7 -> String | nil$8 -> String | nil$9 -> String | nil$10 -> String | nil$11 -> String | nil最後に成功したパターンマッチで n 番目の括弧にマッチした値が格納されます。 該当する括弧がなければ nil が入っています。(覚え方: \数字 のようなもの)
番号 n はいくらでも大きな正整数を利用できます。
Regexp.last_match[1], Regexp.last_match[2], ... と同じ。
これらの変数はローカルスコープかつスレッドローカル、読み取り専用です。
str = '<p><a href="http://example.com">example.com</a></p>' if %r[<a href="(.*?)">(.*?)</a>] =~ str print $1 print $2 end #=> "http://example.com" #=> "example.com"
$< -> IO[permalink][rdoc]すべての引数または標準入力で構成される仮想ファイルです。 定数 Object::ARGF の別名です。
この変数はグローバルスコープ、読み取り専用です。
$= -> bool[permalink][rdoc]非推奨(obsolete): この変数は将来のバージョンで削除される予定です。
パターンマッチや文字列の比較でアルファベットの大文字小文字を 区別するかどうかのフラグです。
過去との互換性のために残されています。Ruby 1.9 以降では意味を持たなくなります。また、将来のバージョンでは文法エラーになる可能性もあります。新規に作成するプログラムでは利用すべきでありません。 この変数はグローバルスコープです。
$> -> object[permalink][rdoc]$stdout -> object$defout -> object標準出力です。
組み込み関数 Kernel.#print、Kernel.#puts や Kernel.#p などのデフォルトの出力先となります。 初期値は Object::STDOUT です。 コマンドラインオプションオプション -i を指定した場合には 読み込み元と同じ名前のファイルを表します。
$stdout には $defout という別名がありますが、 $defout は非推奨(obsolete)になったので、 新しいコードでは常に $stdout を使ってください。
$stdout に代入するオブジェクトには write という名前のメソッドが定義されていなければいけません。
自プロセスの標準出力をリダイレクトしたいときには、 以下のように $stdout に代入すれば十分です。
# 標準出力の出力先を /tmp/foo に変更
$stdout = File.open("/tmp/foo", "w")
puts "foo" # 出力する
$stdout = STDOUT # 元に戻す
自プロセスだけでなく、子プロセスの標準出力もリダイレクトしたいときは 以下のように IO#reopen を使います。
STDOUT.reopen("/tmp/foo", "w")
また、リダイレクトしたあと 出力先をまた元に戻したい場合は以下のようにします。
stdout_old = $stdout.dup # 元の $stdout を保存する
$stdout.reopen("/tmp/foo") # $stdout を /tmp/foo にリダイレクトする
puts "foo" # /tmp/foo に出力
$stdout.flush # 念のためフラッシュする
$stdout.reopen stdout_old # 元に戻す
$stdout はグローバルスコープです。
[SEE_ALSO] Rubyの起動
$? -> Process::Status | nil[permalink][rdoc]このスレッドで最後に終了した子プロセスのステータスです。
Process::Status オブジェクトが入っています。 子プロセスの終了時ステータスは Process::Status#exitstatus で得られます。
この変数はスレッドローカルで読み取り専用です。
[SEE_ALSO] Process.#wait
$@ -> [String] | nil[permalink][rdoc]最後に例外が発生した時のバックトレースを表す配列です。 Kernel.#raise によって設定されます。
配列の各要素はメソッドの呼び出し位置を示す文字列で形式は
"filename:line"
または
"filename:line:in `methodname'"
です。これは Kernel.#caller が返す値と同じ形式です。
$@ へ値を代入するときは、$! が nil であってはいけません。 $@ の値は、$!.backtrace の値と同じです。 また、$@ への代入は $!.set_backtrace 呼び出しと同じです。
文字列の配列でも nil でもない値を代入しようとすると、 TypeError 例外が発生します。
この変数はスレッドローカルです。
$FILENAME -> String[permalink][rdoc]仮想ファイル Object::ARGF で現在読み込み中のファイル名です。 ARGF.filename と同じです。
この変数はグローバルスコープです。
$SAFE -> Fixnum[permalink][rdoc]カレントスレッドのセーフレベルを表す整数です。セーフレベルについては セキュリティモデル を参照してください。
Thread.current.safe_level と同じです。 非整数を代入しようとすると TypeError が発生します。
この変数はスレッドローカルです。 Ruby起動時の初期値は 0 です。
$\ -> String | nil[permalink][rdoc]出力レコード区切りを表す文字列です。 Kernel.#print が最後にこの文字列を出力します。
デフォルトは nil で、何も出力しません。
この変数はグローバルスコープです。
$_ -> String | nil[permalink][rdoc]最後に Kernel.#gets または Kernel.#readline で読み込んだ文字列です。 EOF に達した場合には、 nil になります。 (覚え方: Perlと同じ)
Kernel.#print のような Perl 由来の幾つかのメソッドは、引数を省略すると代わりに $_ を利用します。
この変数はローカルスコープかつスレッドローカルです。 Ruby起動時の初期値は nil です。
[SEE_ALSO] Kernel.#print, Kernel.#gets, Kernel.#readline, Object::ARGF
example.txt:
foo bar baz
このとき、コマンド ruby -e 'print while gets' example.txt は次を出力します
foo bar baz
ただし、このプログラムは次のように書く方がよりRuby的です。
ARGF.each do |line| print line end
$` -> String | nil[permalink][rdoc]現在のスコープで最後に成功した正規表現のパターンマッチでマッチした 部分より前の文字列です。 最後のマッチが失敗していた場合には nil となります。
Regexp.last_match.pre_match と同じです。
この変数はローカルスコープかつスレッドローカル、読み取り専用です。 Ruby起動時の初期値は nil です。
str = '<p><a href="http://example.com">example.com</a></p>' if %r[<a href="(.*?)">(.*?)</a>] =~ str p $` end #=> "<p>"
$stderr -> object[permalink][rdoc]$deferr -> object標準エラー出力です。
Ruby インタプリタが出力するエラーメッセージや 警告メッセージ、Kernel.#warn の出力先となります。 初期値は Object::STDERR です。
$stderr には $deferr という別名がありますが、 $deferr は非推奨(obsolete)になったので、 新しいコードでは常に $stderr を使ってください。
$stderr に代入するオブジェクトには write という名前のメソッドが定義されていなければいけません。
自プロセスの標準エラー出力をリダイレクトしたいときには、 $stderr に代入すれば十分です。
# 標準エラー出力の出力先を /tmp/foo に変更
$stderr = File.open("/tmp/foo", "w")
puts "foo" # 出力する
$stderr = STDERR # 元に戻す
自プロセスだけでなく、子プロセスの標準エラー出力も リダイレクトしたいときは以下のように IO#reopen を使います。
$stderr.reopen("/tmp/foo", "w")
また、リダイレクトしたあと 出力先をまた元に戻したい場合は以下のようにします。
stderr_old = $stderr.dup # 元の $stderr を保存する
$stderr.reopen("/tmp/foo") # $stderr を /tmp/foo にリダイレクトする
puts "foo" # /tmp/foo に出力
$stderr.flush # 念のためフラッシュする
$stderr.reopen stderr_old # 元に戻す
$stderr はグローバルスコープです。
$stdin -> object[permalink][rdoc]標準入力です。
自プロセスの標準入力をリダイレクトしたいときは $stdin に代入すれば十分です。
# 標準入力の入力元 /tmp/foo に変更
$stdin = File.open("/tmp/foo", "w")
gets # 入力する
$stdin = STDIN # 元に戻す
ただし、Kernel.#gets など、特定の組み込みメソッドは $stdin オブジェクトにメソッドを転送して実装されています。 従って、Kernel.#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"
自プロセスだけでなく、子プロセスの標準入力もリダイレクトしたいときは 以下のように IO#reopen を使います。
$stdin.reopen("/tmp/foo")
また、リダイレクトしたあと 出力先をまた元に戻したい場合は以下のようにします。
stdin_old = $stdin.dup # 元の $stdin を保存する
$stdout.reopen("/tmp/foo") # $stdin を /tmp/foo にリダイレクトする
gets # /tmp/foo から入力
$stdin.reopen stdin_old # 元に戻す
$stdin はグローバルスコープです。
$~ -> MatchData | nil[permalink][rdoc]現在のスコープで最後に成功したマッチに関する MatchDataオブジェクトです。 Regexp.last_match の別名です。
このデータから n 番目のマッチ ($n) を取り出すためには $~[n] を使います。
この値に代入すると Regexp.last_match や、 $&, $1, $2, ... などの関連する組み込み変数の値が変化します。 MatchData オブジェクトでも nil でもない値を代入しようとすると TypeError が発生します。
この変数はローカルスコープかつスレッドローカルです。 Ruby起動時の初期値は nil です。
str = '<p><a href="http://example.com">example.com</a></p>' if %r[<a href="(.*?)">(.*?)</a>] =~ str p $~[1] end #=> "http://example.com"