Ruby 4.0 リファレンスマニュアル

module Kernel

[edit]

dynamic include: RakeFileUtils (by rake)

要約

全てのクラスから参照できるメソッドを定義しているモジュール。 Object クラスはこのモジュールをインクルードしています。

Object クラスのメソッドは実際にはこのモジュールで定義されています。これはトップレベルでのメソッドの再定義に対応するためです。

目次

モジュール関数
追加されるメソッド
特殊変数

動的includeで追加されるメソッド

RakeFileUtils (by rake)

モジュール関数

Array(arg) -> Array[permalink][rdoc][edit]

引数を配列(Array)に変換した結果を返します。

arg.to_ary と arg.to_a をこの順に呼び出して、返ってきた配列を変換結果とします。

arg に to_ary, to_a のいずれのメソッドも定義されていない場合は一要素の配列 [arg] を返します。

[PARAM] arg:
変換対象のオブジェクトです。
[EXCEPTION] TypeError:
to_ary, to_a の返り値が配列でなければ発生します
例 
p Array({:it => 3}) #=> [[:it, 3]]
p Array(nil) #=> []
p Array("fefe") #=> ["fefe"]

[SEE_ALSO] Object#to_a,Object#to_ary,Array

Complex(r, i = 0, exception: true) -> Complex | nil[permalink][rdoc][edit]
Complex(s, exception: true) -> Complex | nil

実部が r、虚部が i である Complex クラスのオブジェクトを生成します。

[PARAM] r:
生成する複素数の実部。
[PARAM] i:
生成する複素数の虚部。省略した場合は 0 です。
[PARAM] s:
生成する複素数を表す文字列。
[PARAM] exception:
false を指定すると、変換できなかった場合、例外を発生する代わりに nil を返します。
[EXCEPTION] ArgumentError:
変換できないオブジェクトを指定した場合に発生します。
例 
p Complex(1)     # => (1+0i)
p Complex(1, 2)  # => (1+2i)
p Complex('1+1i')  # => (1+1i)
p Complex('1+1j')  # => (1+1i)
# Complex.polar(10, 10) と同一。
p Complex('10@10') # => (-8.390715290764524-5.440211108893697i)
Complex('_')     # ~> ArgumentError

r にも i にも複素数と解釈されるオブジェクトを指定した場合には、 Complex(a, b) を a+bi として計算した Complex オブジェクトを返します。

例 
p Complex('1+1i', '2+3i')                        # => (-2+3i)
p Complex('1+1i') + Complex('2+3i') * Complex('i') # => (-2+3i)

[SEE_ALSO] Complex.rect、Complex.rectangular

[注意] Complex.new、Complex.new! は 1.9 系では廃止されました。

Float(arg, exception: true) -> Float | nil[permalink][rdoc][edit]

引数を浮動小数点数(Float)に変換した結果を返します。

引数が数値の場合は素直に変換し、文字列の場合は整数や浮動小数点数と見なせるもののみ変換します。

メソッド Float は文字列に対し String#to_f よりも厳密な変換を行います。

Ruby 3.4 以降は "1." のように小数点以下を省略した表記も受け付けます。

[PARAM] arg:
変換対象のオブジェクトです。
[PARAM] exception:
false を指定すると、変換できなかった場合、例外を発生する代わりに nil を返します。
[EXCEPTION] ArgumentError:
整数や浮動小数点数と見なせない文字列を引数に指定した場合に発生します。
[EXCEPTION] TypeError:
nil またはメソッド to_f を持たないオブジェクトを引数に指定したか、 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)   # can't convert Object into Float (TypeError)
p Float(nil)          # can't 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("0xa")        #=> 10.0
p Float("1.")         #=> 1.0
p Float("1.e2")       #=> 100.0

p Float("nan")        # invalid value for Float(): "nan" (ArgumentError)
p Float("INF")        # invalid value for Float(): "INF" (ArgumentError)
p Float("-Inf")       # invalid value for Float(): "-Inf" (ArgumentError)
p Float(("10" * 1000)) #=> Infinity
p Float("0xa.a")      # invalid value for Float(): "0xa.a" (ArgumentError)
p Float(" \n10\s \t") #=> 10.0 # 先頭と末尾の空白類は無視される
p Float("1\n0")       # invalid value for Float(): "1\n0" (ArgumentError)
p Float("")           # invalid value for Float(): "" (ArgumentError)

[SEE_ALSO] String#to_f,Float

Hash(arg) -> HashRuby 2.0.0 から[permalink][rdoc][edit]

引数 arg で指定したオブジェクトを to_hash メソッドを呼び出す事で Hash オブジェクトに変換します。nil か [] を指定した場合は空の Hash オブジェクトを返します。

[PARAM] arg:
変換対象のオブジェクトを指定します。
例 
p Hash([])        # => {}
p Hash(nil)       # => {}
p Hash(key: :value) # => {:key => :value}
Hash([1, 2, 3])   # ~> TypeError
[EXCEPTION] TypeError:
変換できないオブジェクトを指定した場合に発生します。
Integer(arg, base = 0, exception: true) -> Integer | nil[permalink][rdoc][edit]

引数を整数に変換した結果を返します。

引数が数値の場合は直接変換し（小数点以下切り落とし）、文字列の場合は、進数を表す接頭辞を含む整数表現とみなせる文字列のみ変換します。

数値と文字列以外のオブジェクトに対しては arg.to_int, arg.to_i をこの順に使用して変換します。

[PARAM] arg:
変換対象のオブジェクトです。
[PARAM] base:
基数として0か2から36の整数を指定します(引数argに文字列を指定した場合のみ)。省略するか0を指定した場合はプリフィクスから基数を判断します。その場合に認識できるプリフィクスは、0b (2 進数)、0 (8 進数)、0o (8 進数)、0d (10 進数)、0x (16 進数) です。
[PARAM] exception:
false を指定すると、変換できなかった場合、例外を発生する代わりに nil を返します。
[EXCEPTION] ArgumentError:
整数と見なせない文字列を引数に指定した場合に発生します。
[EXCEPTION] TypeError:
メソッド to_int, to_i を持たないオブジェクトを引数に指定したか、to_int, to_i が整数(Integerのサブクラス)を返さなかった場合に発生します。
[EXCEPTION] TypeError:
引数に nil を指定した場合に発生します。
例 
p Integer(4)          #=> 4
p Integer(4_000)      #=> 4000
p Integer(9.88)       #=> 9

p Integer(nil)        # can't convert nil into Integer (TypeError)
p Integer(Object.new) # cannot convert Object into Integer (TypeError)

p Integer("10")       #=> 10
p Integer("10", 2)    #=> 2
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

Rational(x, y = 1, exception: true) -> Rational | nil[permalink][rdoc][edit]

引数を有理数(Rational)に変換した結果を返します。

[PARAM] x:
変換対象のオブジェクトです。
[PARAM] y:
変換対象のオブジェクトです。省略した場合は x だけを用いて Rational オブジェクトを作成します。
[PARAM] exception:
false を指定すると、変換できなかった場合、例外を発生する代わりに nil を返します。
[EXCEPTION] ArgumentError:
変換できない形式の文字列を指定した場合に発生します。
[EXCEPTION] TypeError:
変換できない型のオブジェクトを指定した場合に発生します。

引数 y を省略した場合は、x を Rational に変換します。引数 x、y の両方を指定した場合、x/y した Rational オブジェクトを返します。

例 
p Rational(5)             # => (5/1)
p Rational("1/3")         # => (1/3)
p Rational(1, 3)          # => (1/3)
p Rational("0.1", "0.3")  # => (1/3)
p Rational(Complex(1,2), 2) # => ((1/2)+(1/1)*i)

ただし、1.8系とは異なり、Rational オブジェクトは常に既約(それ以上約分できない状態)である事に注意してください。

例 
p Rational(2, 6)       # => (1/3)
p Rational(1, 3) * 3   # => (1/1)

引数に文字列を指定する場合、以下のいずれかの形式で指定します。

  • "1/3" のような分数の形式
  • "0.3" のような10進数の形式
  • "0.3E0" のような x.xEn の形式
  • 数字をアンダースコアで繋いだ形式

"1.2/3" や "1/3.1" のように、分子だけでなく分母も実数にする事が可能です。また、Kernel?.Integer とは違い "0x10" のような進数を表す接頭辞を含めた指定は行えません。

例 
p Rational("1/3")      # => (1/3)
p Rational("0.3")      # => (3/10)
p Rational('0.3E0')    # => (3/10)
p Rational('0.1E1/3')  # => (1/3)
p Rational('1.2/3')    # => (2/5)
p Rational('1/3.1')    # => (10/31)
p Rational('3.0', '3.0') # => (1/1)
p Rational('3/3', '3/3') # => (1/1)
p Rational('1_234_567')  # => (1234567/1)
p Rational(" \n10\t ") # => (10/1) # 空白類は無視される
Rational("0x10")       # ~> ArgumentError

文字列として不正な形式を指定した場合には ArgumentError が、 nil や変換できない型のオブジェクトを指定した場合には TypeError が発生します。

例 
Rational("")           # ~> ArgumentError
Rational("10 cents")   # ~> ArgumentError
Rational(Object.new)   # ~> TypeError
Rational(nil)          # ~> TypeError
Rational(1, nil)       # ~> TypeError

また、Rational('0.3') と Rational(0.3) は異なるオブジェクトを返す事に注意してください。前者は正確に 3/10 ですが、後者はそうではありません。ただし、Rational(0.5) のように 2 の累乗を分母とする値であれば、 Float を経由しても誤差なく変換されます。

例 
p Rational('0.3')      # => (3/10)
p Rational(0.5)        # => (1/2)
p Rational(0.3)        # => (5404319552844595/18014398509481984)

[SEE_ALSO] Rational

String(arg) -> String[permalink][rdoc][edit]

引数を文字列(String)に変換した結果を返します。

arg.to_s を呼び出して文字列に変換します。 arg が文字列の場合、何もせず arg を返します。

[PARAM] arg:
変換対象のオブジェクトです。
[EXCEPTION] TypeError:
to_s の返り値が文字列でなければ発生します。
例 
class Foo
 def to_s
   "hogehoge"
 end
end

arg = Foo.new
p String(arg) #=> "hogehoge"

[SEE_ALSO] Object#to_s,String

__callee__ -> Symbol | nilRuby 1.9.3 から[permalink][rdoc][edit]

現在のメソッド名を返します。メソッドの外で呼ばれると nil を返します。

例 
def foo
  p __callee__
end
alias :bar :foo
p foo # => :foo
p bar # => :bar
p __callee__ # => nil

Kernel?.__method__ とは異なり、現在のメソッド名が alias されたメソッドの場合には alias 先のメソッド名を返します。

[SEE_ALSO] Kernel?.__method__

__dir__ -> String | nilRuby 2.0.0 から[permalink][rdoc][edit]

現在のソースファイル(__FILE__)のあるディレクトリ名を正規化された絶対パスで返します。シンボリックリンクも解決されます。また、__FILE__ が nil の場合は nil を返します。

__method__ -> Symbol | nil[permalink][rdoc][edit]

現在のメソッド名を返します。メソッドの外で呼ばれると nil を返します。

例 
def foo
  p __method__
end
alias :bar :foo
p foo #=> :foo
p bar #=> :foo
p __method__ #=> nil

現在のメソッド名が alias されたメソッドの場合でも alias 元のメソッド名を返します。

`command` -> String[permalink][rdoc][edit]

command を外部コマンドとして実行し、その標準出力を文字列として返します。このメソッドは `command` の形式で呼ばれます。

引数 command に対しダブルクォートで囲まれた文字列と同様の解釈と式展開を行った後、コマンドとして実行します。コマンドは評価されるたびに実行されます。コマンドの終了ステータスを得るには、$? を参照します。

コマンドの出力を得る必要がなく、単にコマンドを実行したいだけなら Kernel?.system を使います。特に端末を制御するコマンドでは `command` は失敗するかもしれません。

リテラル/コマンド出力 も参照。

[PARAM] command:
コマンドとして実行する引数です。そのまま評価されるのではなく、ダブルクォート文字列と同様のバックスラッシュ記法の解釈と式展開が行われます。
[RETURN]
コマンドの出力を文字列で返します。
[EXCEPTION] Errno::EXXX:
コマンドを実行できないときや失敗した場合に発生します。
例 
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,Kernel?.spawn

abort -> ()[permalink][rdoc][edit]
abort(message) -> ()

Ruby プログラムをエラーメッセージ付きで終了します。終了ステータスは 1 固定です。

このメソッドと Kernel?.exit との違いは、プログラムの終了ステータスが 1 (正確にはCレベルの定数 EXIT_FAILURE の値)固定であることと、エラーメッセージを標準エラー出力 $stderr に出力することです。

引数 message を指定すると SystemExit クラスの Exception#message に message を設定して標準エラー出力に出力します。

引数を省略した呼び出し時に $! が nil でなければその例外のメッセージとバックトレースを表示します。

[PARAM] message:
エラーメッセージ文字列です。 
puts 'start'
begin
  puts 'start1...'
  abort "error1"
rescue SystemExit => err
  puts "end1 with #{err.inspect}"
end

begin
  puts 'start2...'
  raise RuntimeError.new
rescue
  abort
ensure
  puts 'end2...'
end
puts 'end' #実行されない

#(標準出力)
#=> start
#   start1...
#   end1 with #<SystemExit: error1>
#   start2...
#   end2...
#終了ステータス:1
#(標準エラー出力)
#=> error1
#   Traceback (most recent call last):
#   sample.rb:11:in '<main>': RuntimeError (RuntimeError)

[SEE_ALSO] Kernel?.exit,Kernel?.exit!

at_exit { ... } -> Proc[permalink][rdoc][edit]

与えられたブロックをインタプリタ終了時に実行します。

at_exitがメソッドである点を除けば、END ブロックによる終了処理の登録と同等です。登録した処理を取り消すことはできません。 終了処理も参照してください。

[RETURN]
登録した処理を Proc オブジェクトで返します。
例 
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,Kernel?.exit!,Kernel?.fork

autoload(const_name, feature) -> nil[permalink][rdoc][edit]

定数 const_name を最初に参照した時に feature を Kernel?.require するように設定します。

const_name には、 "::" 演算子を含めることはできません。ネストした定数を指定する方法は Module#autoload を参照してください。

const_name が autoload 設定されていて、まだ定義されてない(ロードされていない)ときは、 autoload する対象を置き換えます。 const_name が(autoloadではなく)既に定義されているときは何もしません。

[PARAM] const_name:
定数をString または Symbol で指定します。
[PARAM] feature:
require と同様な方法で autoload する対象を指定します。
[EXCEPTION] LoadError:
featureのロードに失敗すると発生します。 
# ------- /tmp/foo.rb ---------
class Bar
end
# ----- end of /tmp/foo.rb ----

autoload :Bar, '/tmp/foo'
p Bar #=> Bar

[SEE_ALSO] Kernel?.autoload?,Module#autoload,Kernel?.require

autoload?(const_name) -> String | nil[permalink][rdoc][edit]

const_name が Kernel?.autoload 設定されているか調べます。

autoload 設定されていて、autoload 定数がまだ定義されてない(ロードされていない) ときにそのパス名を返します。

autoload 設定されていないか、ロード済みなら nil を返します。

[PARAM] const_name:
定数をString または Symbol で指定します。
例 
# ------- /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][edit]

変数・メソッドなどの環境情報を含んだ Binding オブジェクトを生成して返します。通常、Kernel?.eval の第二引数として使います。

例 
def foo
  a = 1
  binding
end

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

[SEE_ALSO] Kernel?.eval,Object::TOPLEVEL_BINDING

block_given? -> bool[permalink][rdoc][edit]
iterator? -> bool

メソッドにブロックが与えられていれば真を返します。

このメソッドはカレントコンテキストにブロックが与えられているかを調べるので、メソッド内部以外で使っても単に false を返します。

iterator? は （ブロックが必ずイテレートするとはいえないので）推奨されていないので block_given? を使ってください。

例 
def check
  if block_given?
    puts "Block is given."
  else
    puts "Block isn't given."
  end
end
p check{} #=> Block is given.
p check #=> Block isn't given.
caller(start = 1) -> [String] | nil[permalink][rdoc][edit]
caller(start, length) -> [String] | nil
caller(range) -> [String] | nil

start 段上の呼び出し元の情報を $@ の形式のバックトレース(文字列の配列)として返します。

トップレベルでは空の配列を返します。caller の戻り値を $@ に代入することで例外の発生位置を設定できます。

引数で指定した値が範囲外の場合は nil を返します。

[PARAM] start:
long の範囲を超えない正の整数でスタックレベルを指定します。
[PARAM] length:
取得するスタックの個数を指定します。
[PARAM] range:
取得したいスタックの範囲を示す Range オブジェクトを指定します。

[SEE_ALSO] Kernel?.set_trace_func,Kernel?.raise, Kernel?.caller_locations

例 
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:in '<main>'"]
#   ["-:10:in 'bar'", "-:13:in '<main>'"]
#   ["-:13:in '<main>'"]
#   []
#   nil

caller の要素から呼び出し元のファイル名や行番号、メソッド名を取り出したい場合は、文字列を正規表現でパースするより Kernel?.caller_locations を使うほうが適切です。詳しくは後述の caller_locations の項を参照してください。

以下は、$DEBUG が真の場合に役に立つ debug 関数のサンプルです。

例 
$DEBUG = true

def debug(*args)
  p [caller.first, *args] if $DEBUG
end

debug "debug information"

#=> ["-:7", "debug information"]
caller_locations(start = 1, length = nil) -> [Thread::Backtrace::Location] | nilRuby 2.0.0 から[permalink][rdoc][edit]
caller_locations(range) -> [Thread::Backtrace::Location] | nil

現在のフレームを Thread::Backtrace::Location の配列で返します。引数で指定した値が範囲外の場合は nil を返します。

[PARAM] start:
開始フレームの位置を数値で指定します。
[PARAM] length:
取得するフレームの個数を指定します。
[PARAM] range:
取得したいフレームの範囲を示す Range オブジェクトを指定します。
例 
def test1(start, length)
  locations = caller_locations(start, length)
  p locations
  p locations.map(&:lineno)
  p locations.map(&:path)
end

def test2(start, length)
  test1(start, length)
end

def test3(start, length)
  test2(start, length)
end

p caller_locations # => []
test3(1, nil)
# => ["/Users/user/test.rb:9:in 'Object#test2'", "/Users/user/test.rb:13:in 'Object#test3'", "/Users/user/test.rb:17:in '<main>'"]
# => [9, 13, 17]
# => ["/Users/user/test.rb", "/Users/user/test.rb", "/Users/user/test.rb"]
test3(1, 2)
# => ["/Users/user/test.rb:9:in 'Object#test2'", "/Users/user/test.rb:13:in 'Object#test3'"]
# => [9, 13]
# => ["/Users/user/test.rb", "/Users/user/test.rb"]
test3(2, 1)
# => ["/Users/user/test.rb:13:in 'Object#test3'"]
# => [13]
# => ["/Users/user/test.rb"]

[SEE_ALSO] Thread::Backtrace::Location, Kernel?.caller

catch {|tag| .... } -> object[permalink][rdoc][edit]
catch(tag) {|tag| .... } -> object

Kernel?.throwとの組み合わせで大域脱出を行います。 catch はブロックを実行します。

ブロックの実行中に tag と同一のオブジェクトを引数とする Kernel?.throw が行われた場合は、その throw の第二引数を戻り値として、ブロックの実行を終了します。

主にネストしたループから一気に脱出するのに使用します。

引数を省略した場合、タグとなるオブジェクトが内部で生成され、ブロックパラメータ tag に渡されます。

[PARAM] tag:
タグとなる任意のオブジェクトです。
[RETURN]
ブロックの返り値か、対応するthrowの第二引数を返り値として返します。
例 
result = catch do |tag|
  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][edit]

$_.chomp とほぼ同じですが、置換が発生したときは、$_の内容を置き換える点が異なります。コマンドラインオプションで -p または -n を指定した時のみ定義されます。

暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。今後はより明示的な $_.chomp を使ってください。

$_.chomp とこのメソッド chomp は以下の点で違いがあります。

  • chomp は $_ の値をコピーして、コピーの方を更新し、 $_ に再代入します。
[PARAM] rs:
末尾から削除する改行コードを指定します。
例: ruby -n で "test" を入力 
p $_          # => "test\n"
p chomp       # => "test"
例: ruby -n で "test," を入力し、 rs に "," を指定 
p $_          # => "test\n"
p chomp       # => "test,"
p chomp(",")  # => "test"

[SEE_ALSO] String#chomp,$_,$/

chop -> String[permalink][rdoc][edit]

$_.chop とほぼ同じですが、置換が発生したときは、$_の内容を置き換える点が異なります。コマンドラインオプションで -p または -n を指定した時のみ定義されます。

暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。今後はより明示的な $_.chop を使ってください。

$_.chopとこのメソッド chop は以下の点で違いがあります。

  • chop は $_ の値をコピーして、コピーの方を更新し、 $_ に再代入します。
例 
$_ = "test\r\n"
p $_        # => "test\r\n"
p chop      # => "test"
$_ = "test\n"
p $_        # => "test\n"
p chop      # => "test"
$_ = "test"
p $_        # => "test"
p chop      # => "tes"

[SEE_ALSO] String#chop,$_

eval(expr) -> object[permalink][rdoc][edit]
eval(expr, bind, fname = "(eval)", lineno = 1) -> object

文字列 expr を Ruby プログラムとして評価してその結果を返します。第2引数に Binding オブジェクトを与えた場合、そのオブジェクトを生成したコンテキストで文字列を評価します。

expr の中のローカル変数の扱いはブロックの場合と同じです。すなわち、eval 実行前に定義されていた変数を eval の中で参照・変更でき、その変更は eval 実行後にも引き継がれます。

fname と lineno が与えられた場合には、ファイル fname の行番号 lineno から文字列 expr が書かれているかのようにコンパイルされます。スタックトレースの表示などを差し替えることができます。

bind によらずに特定のオブジェクトのコンテキストで expr を評価したい場合、 Module#module_eval, BasicObject#instance_eval が使えます。

[PARAM] expr:
評価する文字列です。
[PARAM] bind:
評価コンテキストです。
[PARAM] fname:
スタックトレースに表示するファイル名です。
[PARAM] lineno:
文字列 expr が書かれていると想定する先頭の行番号を整数で指定します。
例 
a = nil
eval('a = RUBY_RELEASE_DATE')
p a #=> "2007-03-13"

eval('def fuga;p 777 end')
p fuga #=> 777

eval('raise RuntimeError', binding, 'XXX.rb', 4)
#=> XXX.rb:4: RuntimeError (RuntimeError)
#       from ..:9

[SEE_ALSO] Kernel?.binding,Module#module_eval,BasicObject#instance_eval,Object#method,Object#send

exec(command, options={}) -> ()[permalink][rdoc][edit]
exec(env, command, options={}) -> ()

引数で指定されたコマンドを実行します。

プロセスの実行コードはそのコマンド(あるいは shell)になるので、起動に成功した場合、このメソッドからは戻りません。

引数の解釈

この形式では command が shell のメタ文字 

  * ? {} [] <> () ~ & | \ $ ; ' ` " \n

を含む場合、shell 経由で実行されます。そうでなければインタプリタから直接実行されます。

[PARAM] command:
コマンドを文字列で指定します。
[PARAM] env:
更新する環境変数を表す Hash
[PARAM] options:
オプションパラメータ Hash
[EXCEPTION] Errno::EXXX:
起動に失敗し、ruby インタプリタに制御が戻った場合に発生します。
例 
# a.rb
puts '実行前'
exec 'echo "実行中"'
puts '実行後'

上記のスクリプトを実行すると以下のようになります。 

$ ruby a.rb
実行前
実行中
# '実行後' は表示されない
exec(program, *args, options={}) -> ()[permalink][rdoc][edit]
exec(env, program, *args, options={}) -> ()

引数で指定されたコマンドを実行します。

プロセスの実行コードはそのコマンド(あるいは shell)になるので、起動に成功した場合、このメソッドからは戻りません。

この形式では、常に shell を経由せずに実行されます。

exec(3) でコマンドを実行すると、元々のプログラムの環境をある程度(ファイルデスクリプタなど)引き継ぎます。 Hash を options として渡すことで、この挙動を変更できます。詳しくは Kernel?.spawn を参照してください。

引数の解釈

この形式で呼び出した場合、空白や shell のメタキャラクタもそのまま program の引数に渡されます。先頭の引数が2要素の配列であった場合、第1要素の文字列が実際に起動するプログラムのパスであり、第2要素が「みせかけ」のプログラム名になります。また、第1要素はフルパスで指定しなくても環境変数 PATH から探します。

[PARAM] program:
文字列か2要素の配列を指定します。
[PARAM] args:
渡される引数です。0 個以上の文字列を指定します。
[PARAM] env:
更新する環境変数を表す Hash
[PARAM] options:
オプションパラメータ Hash
[EXCEPTION] ArgumentError:
第一引数が配列かつ要素数が 2 でない場合に発生します。
[EXCEPTION] Errno::EXXX:
起動に失敗し、ruby インタプリタに制御が戻った場合に発生します。
例 
# 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?.spawn,Kernel?.fork,IO.popen,IO.pipe,Kernel?.open,exec(3)

exit(status = true) -> ()[permalink][rdoc][edit]

Rubyプログラムの実行を終了します。status として整数が与えられた場合、その値を Ruby コマンドの終了ステータスとします。デフォルトの終了ステータスは 0(正常終了)です。

status が true の場合 0、 false の場合 1 を引数に指定したとみなされます。この値はCレベルの定数 EXIT_SUCCESS、EXIT_FAILURE の値なので、正確には環境依存です。

exit は例外 SystemExit を発生させることによってプログラムの実行を終了させますので、必要に応じて begin 節で捕捉できます。

[PARAM] status:
終了ステータスを整数か true または false で与えます。
例 
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][edit]

Rubyプログラムの実行を即座に終了します。 status として整数が与えられた場合、その値を Ruby コマンドの終了ステータスとします。デフォルトの終了ステータスは 1 です。

status が true の場合 0、 false の場合 1 を引数に指定したとみなされます。この値はCレベルの定数 EXIT_SUCCESS、EXIT_FAILURE の値なので、正確には環境依存です。

exit! は exit とは違って、例外処理などは一切行ないません。 Kernel?.fork の後、子プロセスを終了させる時などに用いられます。

[PARAM] status:
終了ステータスを整数か true または false で与えます。
例 
STDOUT.sync = true #表示前に終了しないようにする
puts 'start'
begin
  puts 'start1...'
  exit!
ensure
  puts 'end1...' #実行されない
end
puts 'end' #実行されない

#=> start
#   start1...
#終了ステータス:1

[SEE_ALSO] Kernel?.exit,Kernel?.abort,Kernel?.at_exit,Kernel?.fork

raise -> ()[permalink][rdoc][edit]
fail -> ()
raise(message, cause: $!) -> ()
fail(message, cause: $!) -> ()
raise(error_type, message = nil, backtrace = caller(0), cause: $!) -> ()
fail(error_type, message = nil, backtrace = caller(0), cause: $!) -> ()

例外を発生させます。発生した例外は変数 $! に格納されます。また例外が発生した時のスタックトレースは変数 $@ に格納されます。発生した例外は 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 を渡すことができます。

[PARAM] error_type:
発生させる例外を例外クラスまたは例外クラスのインスタンスで指定します。
[PARAM] message:
例外のメッセージとなる文字列です。
[PARAM] backtrace:
例外発生時のスタックトレースで、Kernel?.caller の戻り値と同じ形式で指定しなければいけません。 Ruby 3.4 からは、Kernel?.caller_locations の戻り値と同じ Thread::Backtrace::Location の配列も指定できます。
[PARAM] cause:
現在の例外($!)の代わりに Exception#cause に設定する例外を指定します。 Exception オブジェクトまたは nil を指定できます。
[EXCEPTION] TypeError:
exception メソッドが例外オブジェクトを返さなかった場合に発生します。

例外の捕捉の例を示します。

例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

p 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][edit]
fork { ... } -> Integer | nil

fork(2) システムコールを使ってプロセスの複製を作ります。親プロセスでは子プロセスのプロセスIDを、子プロセスでは nil を返します。ブロックを指定して呼び出した場合には、生成した子プロセスでブロックを評価します。

fork 前に STDOUT と STDERR を IO#flush します。

[EXCEPTION] NotImplementedError:
実行環境がこのメソッドに対応していないとき発生します。
ブロックを指定しなかった場合 
if child_pid = fork
  puts "parent process. pid: #{Process.pid}, child pid: #{child_pid}"
  # => parent process. pid: 81060, child pid: 81329

  # 親プロセスでの処理
  # ...

  # 子プロセスの終了を待って終了。
  Process.waitpid(child_pid)
else
  puts "child process. pid: #{Process.pid}"
  # => child process. pid: 81329

  # 子プロセスでの処理
  sleep(1)
end
ブロックを指定した場合 
child_pid = fork do
  puts "child process. pid: #{Process.pid}"
  # => child process. pid: 79602

  # 子プロセスでの処理
  sleep(1)
end

puts "parent process. pid: #{Process.pid}, child pid: #{child_pid}"
# => parent process. pid: 79055, child pid: 79602

# 親プロセスでの処理
# ...

# 子プロセスの終了を待って終了。
Process.waitpid(child_pid)

[SEE_ALSO] IO.popen,IO.pipe,Kernel?.at_exit,Kernel?.exit!, fork(2)

sprintf(format, *arg) -> String[permalink][rdoc][edit]
format(format, *arg) -> String

format 文字列を C 言語の sprintf と同じように解釈し、引数をフォーマットした文字列を返します。

[PARAM] format:
フォーマット文字列です。
[PARAM] arg:
フォーマットされる引数です。

[SEE_ALSO] Kernel?.printf,Time#strftime,Date.strptime

sprintf フォーマット

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$][フラグ][幅][.精度]指示子
%[<name>][フラグ][幅][.精度]指示子

% 自身を出力するには %% とします。

以下それぞれの要素に関して説明します。

フラグ

フラグには #, +, ' '(スペース), -, 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)  #=> "0"
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

出力が右詰めの場合に余った部分に空白の代わりに "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"

指示子

指示子は引数の型の解釈を示します。指示子を省略することはできません。指示子には大きく分けて

  • 文字列を表す指示子: c, s, p
  • 整数を表す指示子: d, i, u, b, B, o, x, X,
  • 浮動小数点数を表す指示子: f, g, e, E, G

があります

c

引数の数値(0〜255)を文字コードとみなして対応する文字を出力します。引数が数値以外のオブジェクトの場合 to_int メソッドによる変換を試みます。引数として範囲内の一文字の文字列も受けつけます。文字そのものを出力します。 

p sprintf("%c", 97)  #=> "a"
p sprintf("%c", 'a') #=> "a"

フラグ - と幅 の指定だけが意味を持ちます。

s

文字列を出力します。

引数が String オブジェクトでなければ to_s メソッドにより文字列化したものを引数として扱います。

p

Object#inspect の結果を出力します。 

p sprintf("%s", /e+/)  #=> "(?-mix:e+)"
p sprintf("%p", /e+/)  #=> "/e+/"
d
i

引数の数値を10進表現の整数として出力します。

引数が整数でなければ関数 Kernel?.Integer と同じ規則で整数に変換されます。 

p sprintf("%d", -1) #=> "-1"
p sprintf("%d", 3.1) #=> "3"
p sprintf("%d", '0b1010') #=> "10"
u

引数の数値を符号なし整数とみなして10進表現の整数として出力します。 

p sprintf("%u", '0b1010') #=> "10"
p sprintf("%u", -1) #=> "-1"
b
B
o
x
X

整数をそれぞれ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       "

# ruby 1.9.1 以降では「精度」を指定した場合も、".." は付加されます 
p sprintf("%.10x", -1) #=> "..ffffffff"
f
e
E
g
G
a
A

f は小数点表現(xxx.xxx)で数値を出力します。

e は指数表現(x.xxxe+xx)で数値を出力します。

g は 指数が -4 より小さいか精度以上の場合に e と同じ出力を、それ以外では f と同じ出力を行います。ただし、小数部の末尾の0は取り除かれます。

a, A は指数表現の16進数("-h.hhh±pd") で数値を出力します。ただし、Float::INFINITY、Float::NAN はそれぞれ 'Inf'、'NaN' になります。詳しくは [ruby-dev:40650] を参照してください。 

p sprintf("%a", -0.0)            # => "-0x0p+0"
p sprintf("%a", 729.0/10)        # => "0x1.239999999999ap+6"
p sprintf("%a", Float::INFINITY) # => "Inf"

大文字の指示子(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$

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"
%<name>

Symbol のインスタンス name をキーとする Hash を引数にした場合、対応する値をフォーマットして参照します。 

p sprintf('%<foo>f : %<bar>+d', foo: 1, bar: 2) #=> "1.000000 : +2"
%{name}

Symbol のインスタンス name をキーとする Hash を引数にした場合、対応する値をフォーマットせずに参照します。幅や精度を指定するために使用できます。 

p sprintf('%{foo}f : %{bar}+d', foo: 1, bar: 2) #=> "1f : 2+d"
gets(rs = $/) -> String | nil[permalink][rdoc][edit]

ARGFから一行読み込んで、それを返します。行の区切りは引数 rs で指定した文字列になります。

rs に nil を指定すると行区切りなしとみなしてファイルの内容をすべて読み込みます。ARGVに複数のファイル名が存在する場合は1度に1ファイルずつ読み込みます。空文字列 "" を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。

読み込んだ文字列は組み込み変数 $_ にもセットされます。

[PARAM] rs:
行の区切りとなる文字列です。
[RETURN]
ファイルの終り(EOF)に到達した時、 nil を返します。
[EXCEPTION] Errno::EXXX:
読み込みに失敗した場合に発生します。
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 -> [Symbol][permalink][rdoc][edit]

プログラム中で定義されているグローバル変数($で始まる変数)名の配列を返します。

例 
p global_variables #=> [:$;, :$-F, :$@, ... ]

[SEE_ALSO] Kernel?.local_variables,Object#instance_variables,Module.constants,Module#constants,Module#class_variables

gsub(pattern, replace) -> String[permalink][rdoc][edit]
gsub(pattern) {|matched| ... } -> String
gsub(pattern) -> Enumerator

$_.gsub とほぼ同じですが、置換が発生したときは、$_の内容を置き換える点が異なります。コマンドラインオプションで -p または -n を指定した時のみ定義されます。

暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。今後はより明示的な $_.gsub を使ってください。

$_.gsub とこのメソッド gsub は以下の点で違いがあります。

  • gsub は $_ の値をコピーして、コピーの方を更新し、 $_ に再代入します。
[PARAM] pattern:
置き換える文字列のパターンを表す文字列か正規表現。文字列を指定した場合は全く同じ文字列にだけマッチする
[PARAM] replace:
pattern で指定した文字列と置き換える文字列
例 
p $_              # => "test\n"
p gsub(/es/, '!!')  # => "t!!t\n"

[SEE_ALSO] String#gsub,$_

proc { ... } -> Proc[permalink][rdoc][edit]
lambda { ... } -> Proc

与えられたブロックから手続きオブジェクト (Proc のインスタンス) を生成して返します。Proc.new に近い働きをします。

また、lambda に & 引数を渡すのは推奨されません。& 引数ではなくてブロック記法で記述する必要があります。

& 引数(リテラルでないブロック)を渡して lambda を呼び出すと、ArgumentError 「the lambda method requires a literal block」が発生します。

[EXCEPTION] ArgumentError:
ブロックを省略した呼び出しを行ったときに発生します。
[EXCEPTION] ArgumentError:
& 引数(リテラルでないブロック)を渡して呼び出したときに発生します。
例 
def foo &block
  proc(&block)
end

it = foo{p 12}
p it.call #=> 12

[SEE_ALSO] Proc,Proc.new

Proc オブジェクトの生成

Proc オブジェクトを生成する手段には、主に以下の四つがあります。

* Proc.new * Kernel?.proc * Kernel?.lambda * ->(){ } (-> を使った lambda の短縮記法)

このうち Proc.new と Kernel?.proc は同じ性質の Proc オブジェクトを生成し、 Kernel?.lambda と ->(){ } も互いに同じ性質の Proc オブジェクトを生成しますが、前二者と後二者では、生成される Proc オブジェクトの引数の扱いや return・break の挙動などが異なります(詳細は後述)。生成された Proc オブジェクトが後二者 (lambda)に該当するかどうかは Proc#lambda? で調べることができます。

このほか、メソッド呼び出しにブロックを渡した場合、そのブロックをブロック引数 (&block など)で受け取ると Proc オブジェクトが生成されます。

手続きを中断して値を返す

手続きオブジェクトを中断して、呼出し元(呼び出しブロックでは yield、それ以外では Proc#call) へジャンプし値を返すには next を使います。break や return ではありません。

例 
def foo
  f = Proc.new{
    next 1
    2              # この行に到達することはない
  }
end

p foo().call       #=> 1

Proc オブジェクトをブロック付きメソッド呼び出しに使う

ブロック付きメソッドに対して Proc オブジェクトを `&` を指定して渡すと呼び出しブロックのように動作します。しかし、厳密には以下の違いがあります。これらは、Proc オブジェクトが呼び出しブロックとして振舞う際の制限です。

問題なし 
(1..5).each { break }
LocalJumpError が発生します。 
pr = Proc.new { break }
(1..5).each(&pr)

lambda と proc と Proc.new とイテレータの違い

Kernel?.lambda と Proc.new はどちらも Proc クラスのインスタンス(手続きオブジェクト)を生成しますが、生成された手続きオブジェクトはいくつかの場面で挙動が異なります。 lambda の生成する手続きオブジェクトのほうがよりメソッドに近い働きをするように設計されています。

Kernel?.proc は Proc.new と同じになります。引数に & を付けることで手続きオブジェクト化したブロックは、Proc.new で生成されたそれと同じように振る舞います。

引数の扱い

lambda のほうがより厳密です。引数の数が違っていると（メソッドのように）エラーになります。 Proc.new は引数を多重代入に近い扱い方をします。

Proc.new は引数の数が違っていてもエラーにならない 
b = Proc.new{|a,b,c|
  p a,b,c
}
p b.call(2, 4)
#=> 2
    4
    nil
lambda は引数の数が違うとエラーになる 
b = lambda{|a,b,c|
  p a,b,c
}
p b.call(2, 4)
# => wrong number of arguments (given 2, expected 3)

メソッド呼び出し/ブロックパラメータの挙動 も参照してください。

ジャンプ構文の挙動の違い

return と break は、lambda と Proc.new では挙動が異なります。例えば return を行った場合、lambda では手続きオブジェクト自身を抜けますが、 Proc.new では手続きオブジェクトを囲むメソッドを抜けます。

例 
def test_proc
  f = Proc.new { return :from_proc }
  f.call
  return :from_method
end

def test_lambda
  f = lambda { return :from_lambda }
  f.call
  return :from_method
end

def test_block
  tap { return :from_block }
  return :from_method
end

p test_proc()   #=> :from_proc
p test_lambda() #=> :from_method
p test_block()  #=> :from_block

以下の表は、手続きオブジェクトの実行を上の例と同じように、手続きオブジェクトが定義されたのと同じメソッド内で行った場合の結果です。 

               return                          next                        break
Proc.new   メソッドを抜ける            手続きオブジェクトを抜ける   例外が発生する
proc       メソッドを抜ける            手続きオブジェクトを抜ける   例外が発生する
lambda     手続きオブジェクトを抜ける  手続きオブジェクトを抜ける   手続きオブジェクトを抜ける
イテレータ メソッドを抜ける            手続きオブジェクトを抜ける   手続きオブジェクトを抜ける

orphan な手続きオブジェクトの挙動

Proc(lambda を除く)を生成したメソッド呼び出しが終了した後で、その手続きオブジェクトに対して return を実行すると、戻る先のメソッド呼び出しがすでに存在しないため、例外 LocalJumpError が発生します。

break の場合は条件がやや異なります。その手続きオブジェクトをブロックとして受け取ったメソッド呼び出しがすでに終了している場合に加えて、 Proc.new { break }.call のようにブロックとしてメソッドに渡されていない手続きオブジェクトで break を実行した場合にも、脱出先となるメソッド呼び出しが存在しないため例外 LocalJumpError が発生します。

ここでいう「作成元が終了している」とは、生成元のコード上の位置(レキシカルスコープ)が失われるという意味ではありません。同じメソッドを複数回呼び出した場合、それぞれの呼び出しで生成された手続きオブジェクトは、呼び出しごとに独立してこの状態になります。

ただし、上でも説明した通り lambda で生成した手続きオブジェクトはメソッドと同じように振る舞うことを意図されているため、例外 LocalJumpError は発生しません。

例 
def foo
  Proc.new { return }
end

foo.call
# => in 'block in Object#foo': unexpected return (LocalJumpError)

以下の表は、手続きオブジェクトの実行を上の例と同じように、手続きオブジェクトが定義されたメソッドを脱出してから行った場合の結果です。 

               return                          next                        break
Proc.new   例外が発生する              手続きオブジェクトを抜ける   例外が発生する
proc       例外が発生する              手続きオブジェクトを抜ける   例外が発生する
lambda     手続きオブジェクトを抜ける  手続きオブジェクトを抜ける   手続きオブジェクトを抜ける
load(file, priv = false) -> true[permalink][rdoc][edit]

Ruby プログラム file をロードして実行します。再ロード可能です。

file が絶対パスのときは file からロードします。 file が相対パスのときは組み込み変数 $: に示されるパスとカレントディレクトリを順番に探し、最初に見付かったファイルをロードします。このとき、$: の要素文字列の先頭文字が ~ (チルダ) だと、環境変数 HOME の値に展開されます。また ~USER はそのユーザのホームディレクトリに展開されます。

ロードに成功した場合は true を返します。

[PARAM] file:
ファイル名の文字列です。
[PARAM] priv:
真のとき、ロード・実行は内部的に生成される無名モジュールをトップレベルとして行われ、グローバルな名前空間を汚染しません。
[EXCEPTION] LoadError:
ロードに失敗した場合に発生します。

[SEE_ALSO] Kernel?.require

require と load の違い

Kernel?.require は同じファイルは一度だけしかロードしませんが、 Kernel?.load は無条件にロードします。また、require は拡張子.rb や .so を自動的に補完しますが、 load は行いません。 require はライブラリのロード、load は設定ファイルの読み込みなどに使うのが典型的な用途です。

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

なお、特定のディレクトリからファイルをロードしたい場合、 load 'filename' とするのは不適切です。必ず絶対パスを使ってください。

local_variables -> [Symbol][permalink][rdoc][edit]

現在のスコープで定義されているローカル変数名の配列を返します。

例 
yuyu = 0
p local_variables #=> [:yuyu]

番号指定パラメータ（_1 など）は 4.0 からローカル変数として扱われなくなり、返り値に含まれなくなりました。 

[1].each do
  p _1              # => 1
  p local_variables # => []（Ruby 3.4 以前は [:_1]）
end

番号指定パラメータ自体は従来どおり参照できます（メソッド呼び出し/番号指定パラメータ）。

[SEE_ALSO] Kernel?.global_variables,Object#instance_variables,Module.constants,Module#constants,Module#class_variables

loop -> Enumerator[permalink][rdoc][edit]
loop { ... } -> object | nil

(中断されない限り)永遠にブロックの評価を繰り返します。ブロックが指定されなければ、代わりに Enumerator を返します。

例 
loop do
  print "Input: "
  line = gets
  break if !line or line =~ /^qQ/
  # ...
end

与えられたブロック内で StopIteration を Kernel?.raise するとループを終了して Enumerator が最後に返した値を返します。ループを終了させる場合、通常は break を使用してください。

例 
enum = Enumerator.new { |y|
  y << "one"
  y << "two"
  :ok
}

result = loop {
  puts enum.next
} # => :ok
[RETURN]
break の引数など、ループ脱出時の値を返します。
open(file, mode_enc = "r", perm = 0666) -> IO[permalink][rdoc][edit]
open(file, mode_enc = "r", perm = 0666) {|io| ... } -> object

file をオープンして、IO（Fileを含む）クラスのインスタンスを返します。

ブロックが与えられた場合、指定されたファイルをオープンし、生成した IO オブジェクトを引数としてブロックを実行します。ブロックの終了時や例外によりブロックを脱出するとき、ファイルをクローズします。ブロックを評価した結果を返します。

| に続く文字列をコマンドとして起動してパイプラインを生成する機能 ("|-" による Ruby の子プロセス生成を含む)は Ruby 4.0 で削除されました。ファイル名 file が | で始まっていても、通常のファイル名として扱われます (該当するファイルが存在しなければ Errno::ENOENT が発生します)。コマンドを起動してその標準入出力をパイプで扱うには IO.popen を使用してください。

[PARAM] file:
ファイルを文字列で指定します。整数を指定した場合はファイルディスクリプタとして扱います。
[PARAM] mode_enc:
モード・エンコーディングを文字列か定数の論理和で指定します。後述。
[PARAM] perm:
open(2) の第 3 引数のように、ファイルを生成する場合のファイルのパーミッションを整数で指定します。
[EXCEPTION] Errno::EXXX:
ファイルのオープンに失敗した場合に発生します。

[SEE_ALSO] File.open,IO.popen,IO.open

第二引数のオープンモード・エンコーディング

文字列("mode" か "mode:ext_enc" か "mode:ext_enc:int_enc" という形式)か整数(File::Constants モジュールの定数の論理和)を組み合わせて指定します。

mode は以下の三つのうちのいずれかです。

"r", RDONLY

ファイルを読み込みモードでオープンします。（デフォルトのモード）

"w", WRONLY|CREAT|TRUNC

ファイルを書き込みモードでオープンします。オープン時にファイルがすでに存在していればその内容を空にします。

"a", WRONLY|CREAT|APPEND

ファイルを書き込みモードでオープンします。出力は 常に ファイルの末尾に追加されます。例えば、ファイルオープン中にファイルのサイズが小さくなってもその末尾に出力されます。

以上の3つの後に "+" があれば、ファイルは読み書き両用モード (RDWR) でオープンされます。

"r+"

ファイルの読み書き位置は先頭にセットされます。

"w+"

"r+" と同じですが、オープン時にファイルがすでに存在していればその内容を空にします。

"a+"

"r+"と同様、ファイルの読み込み位置は先頭にセットされますが、書き込みは常にファイル末尾に行われます。書き込みは IO#seek などの影響を受けません。

これらのいずれに対しても "b" フラグを ("r+b"のように) つけることができます (整数なら File::BINARY )。この場合、バイナリモードでオープンします (ただし、DOS/Windowsのようにシステムがテキスト／バイナリでファイルを区別する場合に限ります)

"w" に対しては "x" フラグを ("wx"や"wb+x"のように) つけることができます (整数なら File::EXCL)。この場合、ファイルがすでに存在すると Errno::EEXIST が発生します。ただし、全ての種類のストリームでサポートされているとは限りません (例えばパイプ)。

Universal Newline

改行をLFに揃えます。一言で言えばPEP:278 https://www.python.org/dev/peps/pep-0278/のことです。

"rt"

CR、LF、CRLFのいずれをもLFとして読み込む。

"rb"

CR、LF、CRLFはいずれもそのまま読み込まれる。

"r"

"rt"と"rb"のどちらの扱いになるかはプラットフォーム依存。 (Unix系ならばなら"rb"、mswinやmingwなら"rt"扱いとなる)

"wb"

LFはそのままLFとして書き込まれる。

"wt" または "w"

LFはLFのままか、CR+LFか、どちらかになる。どちらになるかはプラットフォーム依存。 (Unix系ならばLFのまま、mswinやmingwならばCRLFとなる)

なお、以上のCR、LF、CRLFは入力のエンコーディングを解釈した後に処理されます。例えば、UTF-16LEでは、LFはバイト列"\x0a\x00"のことになります。

エンコーディングの指定

ext_enc(外部エンコーディング)が指定されている場合、読み込まれた文字列にはこのエンコーディングが指定され、出力する文字列はそのエンコーディングに変換されます。

ext_encが'BOM|'で始まる場合、その入力に含まれるBOMはあらかじめ削られます。また、BOMがあった場合、入力された文字列にはそのBOMに対応するエンコーディングが設定されます。

BOMでUTF-16BEかLEかを判別する例 
File.open("utf16.txt", "rb:BOM|utf-16"){|file| "..." }

int_encも指定されていた場合、入力された文字列をext_encでエンコーディングされた文字列とみなしてint_encへと変換し、その結果にint_encを設定して返します。

p(*arg) -> object | Array[permalink][rdoc][edit]

引数を人間に読みやすい形に整形して改行と順番に標準出力 $stdout に出力します。主にデバッグに使用します。

引数の inspect メソッドの返り値と改行を順番に出力します。つまり以下のコードと同じです。

例 
print arg[0].inspect, "\n", arg[1].inspect, "\n" #, ...

整形に用いられるObject#inspectは普通に文字列に変換すると区別がつかなくなるようなクラス間の差異も表現できるように工夫されています。

p に引数を与えずに呼び出した場合は特に何もしません。

[PARAM] arg:
出力するオブジェクトを任意個指定します。
[EXCEPTION] IOError:
標準出力が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:
出力に失敗した場合に発生します。
[RETURN]
指定された引数 arg を返します。複数の引数が指定された場合はそれらを要素とする配列を返します。
例 
puts "" #=> （空行）
p "" #=> ""

puts 50,"50"
#=> 50
#=> 50
p 50,"50"
#=> 50
#=> "50"

[SEE_ALSO] Object#inspect,Kernel?.puts,Kernel?.print

pp(*obj) -> object[permalink][rdoc][edit]

指定されたオブジェクト obj を標準出力に見やすい形式(プリティプリント)で出力します。 obj それぞれを引数として PP.pp を呼ぶことと同等です。

初回呼び出し時に自動的に pp を require します。

[PARAM] obj:
表示したいオブジェクトを指定します。
例 
require 'pp'

b = [1, 2, 3] * 4
a = [b, b]
a << a
pp a

#=> [[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
#    [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
#    [...]]

[SEE_ALSO] PP.pp

print(*arg) -> nil[permalink][rdoc][edit]

引数を順に標準出力 $stdout に出力します。引数が与えられない時には変数 $_ の値を出力します。

文字列以外のオブジェクトが引数として与えられた場合には、 to_s メソッドにより文字列に変換してから出力します。

変数 $, (出力フィールドセパレータ)に nil でない値がセットされている時には、各引数の間にその文字列を出力します。変数 $\ (出力レコードセパレータ)に nil でない値がセットされている時には、最後にそれを出力します。

[PARAM] arg:
出力するオブジェクトを任意個指定します。
[EXCEPTION] IOError:
標準出力が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:
出力に失敗した場合に発生します。
例 
print "Hello, world!"
print "Regexp is",/ant/
print nil
print "\n"
#=> Hello, world!Regexp is(?-mix:ant)

$_ = "input"
$, = "<and>"
$\ = "<end>\n"
print
print "AA","BB"
#=> input<end>
#=> AA<and>BB<end>

[SEE_ALSO] Kernel?.puts,Kernel?.p,IO#print

printf(format, *arg) -> nil[permalink][rdoc][edit]
printf(port, format, *arg) -> nil

C 言語の printf と同じように、format に従い引数を文字列に変換して port に出力します。

port を省略した場合は標準出力 $stdout に出力します。

引数を 1 つも指定しなければ何もしません。

Ruby における format 文字列の拡張については Kernel?.sprintfの項を参照してください。

[PARAM] port:
出力先になるIO のサブクラスのインスタンスです。
[PARAM] format:
フォーマット文字列です。
[PARAM] arg:
フォーマットされる引数です。
[EXCEPTION] ArgumentError:
port を指定したのに format を省略した場合に発生します。
[EXCEPTION] IOError:
port が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:
出力に失敗した場合に発生します。
例 
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][edit]

文字 ch を 標準出力 $stdout に出力します。

ch が数値なら 0 〜 255 の範囲の対応する文字を出力します。 ch が文字列なら、その先頭1文字を出力します。どちらでもない場合は、ch.to_int で整数に変換を試みます。

[PARAM] ch:
出力する文字です。数または文字列で指定します。
[RETURN]
ch を返します
[EXCEPTION] RangeError:
Bignum を引数にした場合に発生します。
[EXCEPTION] IOError:
標準出力が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:
出力に失敗した場合に発生します。
[EXCEPTION] TypeError:
Integer に変換できないオブジェクトを引数に指定した場合に発生します。
例 
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][edit]

引数と改行を順番に 標準出力 $stdout に出力します。引数がなければ改行のみを出力します。

引数が配列の場合、その要素と改行を順に出力します。配列や文字列以外のオブジェクトが引数として与えられた場合には、当該オブジェクトを最初に to_ary により配列へ、次に to_s メソッドにより文字列へ変換を試みます。末尾が改行で終っている引数や配列の要素に対しては puts 自身は改行を出力しません。

[PARAM] arg:
出力するオブジェクトを任意個指定します。
[EXCEPTION] IOError:
標準出力が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:
出力に失敗した場合に発生します。
例 
puts "foo", "bar\n", "baz"
puts ""    # 改行のみ出力
puts       # 改行のみ出力
puts nil   # 改行のみ出力
puts ["oui", "non"]
#=> foo
#   bar
#   baz
#
#
#
#   oui
#   non

[SEE_ALSO] Kernel?.print, Kernel?.p, IO#puts

rand(max = 0) -> Integer | Float[permalink][rdoc][edit]
rand(range) -> Integer | Float | nil

擬似乱数を発生させます。

最初の形式では max が 0 の場合は 0.0 以上 1.0 未満の実数を、正の整数の場合は 0 以上 max 未満の整数を返します。それ以外の値を指定した場合は max.to_int の絶対値が指定されたものとして扱います。

二番目の形式では range で指定された範囲の値を返します。 range の始端と終端が共に整数の場合は整数を、少なくとも片方が実数の場合は実数を返します。 range に含まれる数が無い場合は nil を返します。

まだ Kernel?.srand が呼ばれていなければ自動的に呼び出します。

擬似乱数生成器として Random クラスオブジェクトを使用します。

[PARAM] max:
乱数値の上限を正の整数で指定します。 max 自体は乱数値の範囲に含まれません。 0 を指定すると実数値の乱数を返します。
[PARAM] range:
発生させる乱数値の範囲を Range オブジェクトで指定します。 range の境界は数値でなければなりません。
例 
srand(1234)     # 乱数の種を設定する。
p rand          #=> 0.1915194503788923
p rand          #=> 0.6221087710398319
p rand(10)      #=> 4
p rand(5.5)     #=> 0
                # rand(5) と同じ。 5 が乱数値の範囲に含まれないことに注意。

p rand(1..6)    #=> 2                   (1 から 6 までの整数)
p rand(0...10)  #=> 1                   (0 から 9 までの整数。終端を含まない)
p rand(1.0..1.5)  #=> 1.1362963047752432  (1.0 以上 1.5 以下の実数)
p rand(1.0...1.5) #=> 1.1382321275715483  (1.0 以上 1.5 未満の実数)
p rand(1..0)    #=> nil

[SEE_ALSO] Kernel?.srand, Random#rand, Random

readline(rs = $/) -> String[permalink][rdoc][edit]

ARGFから一行読み込んで、それを返します。行の区切りは引数 rs で指定した文字列になります。

rs に nil を指定すると行区切りなしとみなしてファイルの内容をすべて読み込みます。ARGVに複数のファイル名が存在する場合は1度に1ファイルずつ読み込みます。空文字列 "" を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。

読み込んだ文字列は組み込み変数 $_ にもセットされます。

[PARAM] rs:
行の区切りとなる文字列です。
[EXCEPTION] Errno::EXXX:
読み込みに失敗した場合に発生します。
[EXCEPTION] EOFError:
readline でファイル末端(EOF)を検出すると発生します。
例 
# ---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][permalink][rdoc][edit]

ARGFを Kernel?.gets(rs) でEOFまで読み込んで、その各行を要素としてもつ配列を返します。行の区切りは引数 rs で指定した文字列になります。

rs に nil を指定すると行区切りなしとみなします。空文字列 "" を指定すると連続する改行を行の区切りとみなします (パラグラフモード)。

[PARAM] rs:
行の区切りとなる文字列です。
[EXCEPTION] Errno::EXXX:
読み込みに失敗した場合に発生します。
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       #=> []
b.txt 
hello
it

common

[SEE_ALSO] $/,ARGF,Kernel?.gets, Kernel?.readline

require(feature) -> bool[permalink][rdoc][edit]

Ruby ライブラリ feature をロードします。拡張子補完を行い、同じファイルの複数回ロードはしません。

feature が絶対パスのときは feature からロードします。 feature が相対パスのときは組み込み変数 $: に示されるパスを順番に探し、最初に見付かったファイルをロードします。このとき、$: の要素文字列の先頭文字が ~ (チルダ) だと、環境変数 HOME の値に展開されます。また ~USER はそのユーザのホームディレクトリに展開されます。

ただし、feature が ./ や ../ で始まる場合は $: を探索せず、その時点のカレントディレクトリ (Dir.pwd) を基準に絶対パスのときと同様解決されます。ロード元のファイルの位置ではなくカレントディレクトリが基準になる点に注意してください（Kernel?.load も同様です）。ロード元のファイルからの相対パスを指定したい場合は Kernel?.require_relative を使ってください。

Ruby ライブラリとは Ruby スクリプト (*.rb) か拡張ライブラリ (*.so,*.o,*.dll など) であり、feature の拡張子が省略された場合はその両方から探します( *.rb が優先されます)。省略されなかった場合は指定された種別のみを探します。また、feature の拡張子にはアーキテクチャで実際に使われる拡張子に関らず拡張ライブラリの拡張子として常に .so を用いることができます（内部で適切に変換されます）。

ライブラリのロードに成功した時には true を返し、ロードした feature の名前を(拡張子も含めて) 変数 $" に追加します。ただし、feature の名前が既に $" に含まれていた場合はロードせずに false を返します。

[PARAM] feature:
ファイル名の文字列です。
[EXCEPTION] LoadError:
ロードに失敗した場合に発生します。
例 
p $LOADED_FEATURES.grep(/prime/).size # => 0
p require "prime"     # => true
p $LOADED_FEATURES.grep(/prime/).size # => 1
p require "prime"     # => false
begin
  require "invalid"
rescue LoadError => e
  p e.message # => "cannot load such file -- invalid"
end

[SEE_ALSO] Kernel?.load,Kernel?.autoload,Kernel?.require_relative

require_relative(relative_feature) -> boolRuby 1.9.3 から[permalink][rdoc][edit]

現在のファイルからの相対パスで require します。 

require File.expand_path(relative_feature, File.dirname(__FILE__))

とほぼ同じです。

Kernel?.eval などで文字列を評価した場合に、そこから require_relative を呼出すと必ず失敗します。

[PARAM] relative_feature:
ファイル名の文字列です。
[EXCEPTION] LoadError:
ロードに失敗した場合に発生します。

[SEE_ALSO] Kernel?.require

require と load のスコープ

ローカル変数はファイル間では共有されません。ですので、ロードしたライブラリのローカル変数をロード元のスクリプトから直接取得することはできません。このスコープの扱い方は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)
select(reads, writes = [], excepts = [], timeout = nil) -> [[IO]] | nil[permalink][rdoc][edit]

IO.select と同じです。

[PARAM] reads:
IO.select 参照
[PARAM] writes:
IO.select 参照
[PARAM] excepts:
IO.select 参照
[PARAM] timeout:
IO.select 参照

[SEE_ALSO] IO.select

set_trace_func(proc) -> Proc[permalink][rdoc][edit]

Ruby インタプリタのイベントをトレースする Proc オブジェクトとして指定された proc を登録します。 nil を指定するとトレースがオフになります。

Ruby インタプリタがプログラムを実行する過程で、メソッドの呼び出しや式の評価などのイベントが発生する度に、以下で説明する6個の引数とともに登録された Proc オブジェクトを実行します。

標準添付の debug、tracer、 profile はこの組み込み関数を利用して実現されています。

ブロックパラメータの意味

渡す Proc オブジェクトのパラメータは 

proc{|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 オブジェクト。
    class/end
        nil。
    raise
        最後に呼び出されたメソッドを表す Symbol オブジェクト。
        トップレベルでは nil。
binding

実行中のプログラムのコンテキストを表す Binding オブジェクト。

klass

event に応じ、以下のものが渡されます。第四ブロック引数の id と対応しています。 

    line
        最後に呼び出されたメソッドが属するクラスを表す
        Class オブジェクト。トップレベルでは nil。
    call/return/c-call/c-return
        呼び出された/リターンするメソッドが属するクラス
        を表す Class オブジェクト。
    class/end
        nil。
    raise
        最後に呼び出されたメソッドが属するクラスを表す
        Class オブジェクト。トップレベルでは nil。
[PARAM] proc:
トレース用 Proc オブジェクトを指定します。nil を指定した場合、トレースをオフにします。
[RETURN]
proc を返します。
例 
set_trace_func lambda {|*arg|
  p arg
}
class Foo
end
43.to_s

# ----結果----
# ["c-return", "..", 1, :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][edit]
sleep(sec) -> Integer

sec 秒だけプログラムの実行を停止します。

sec が省略された場合、他スレッドからの Thread#run などで明示的に起こさない限り永久にスリープします。Thread#runを呼ぶとその時点で sleepの実行が中断されます。

[PARAM] sec:
停止する秒数を非負の数値で指定します。浮動小数点数も指定できます。省略された場合、永久にスリープします。
[RETURN]
実際に停止していた秒数 (整数に丸められた値) です。
例 
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
spawn(command, options={}) -> IntegerRuby 1.9.3 から[permalink][rdoc][edit]
spawn(env, command, options={}) -> Integer

引数を外部コマンドとして実行しますが、生成した子プロセスの終了を待ち合わせません。生成した子プロセスのプロセスIDを返します。

引数の解釈

この形式では command が shell のメタ文字 

  * ? {} [] <> () ~ & | \ $ ; ' ` " \n

を含む場合、shell 経由で実行されます。そうでなければインタプリタから直接実行されます。

[PARAM] command:
コマンドを文字列で指定します。
[PARAM] env:
更新する環境変数を表す Hash
[PARAM] options:
オプションパラメータ Hash
[EXCEPTION] Errno::EXXX:
起動に失敗し、ruby インタプリタに制御が戻った場合に発生します。
[EXCEPTION] Errno::EXXX:
コマンドが実行できなかった場合に発生します。

[SEE_ALSO] Kernel?.system,Kernel?.exec

spawn(program, *args) -> IntegerRuby 1.9.3 から[permalink][rdoc][edit]
spawn(env, program, *args, options={}) -> Integer

引数を外部コマンドとして実行しますが、生成した子プロセスの終了を待ち合わせません。生成した子プロセスのプロセスIDを返します。

env に Hash を渡すことで、exec(2) で子プロセス内でファイルを実行する前に環境変数を変更できます。 Hash のキーは環境変数名文字列、Hash の値に設定する値とします。 nil とすることで環境変数が削除(unsetenv(3))されます。

例 
# FOO を BAR にして BAZ を削除する
pid = spawn({"FOO"=>"BAR", "BAZ"=>nil}, command)

親プロセスは Process?.waitpid で子プロセスの終了を待ち合わせるかもしくは Process?.detach で子プロセスを切り離すかしてください。そうでないとゾンビプロセスが残る場合があります。

引数の解釈

この形式で呼び出した場合、空白や shell のメタキャラクタもそのまま program の引数に渡されます。先頭の引数が2要素の配列であった場合、第1要素の文字列が実際に起動するプログラムのパスであり、第2要素が「みせかけ」のプログラム名になります。また、第1要素はフルパスで指定しなくても環境変数 PATH から探します。

option引数の概要

Hash を options として渡すことで、起動される子プロセスの

  • プロセスグループ
  • resource limit
  • カレントディレクトリ
  • umask
  • 子プロセスでのリダイレクト

などを変更できます。環境変数のクリアなども指定できます。

以下のオプションが指定できます。

:unsetenv_others

これを true にすると、envで指定した環境変数以外をすべてクリアします。 false だとクリアしません。false がデフォルトです。

:pgroup

引数に true or 0 を渡すと新しいプロセスグループを作成し、そこで動きます。整数を渡すと、指定したプロセスグループに属します。 nil を渡すとプロセスグループを変更しません。デフォルトは nil です。

:rlimit_core, :rlimit_cpu, etc

resource limit を設定します。詳しくは Process?.setrlimit を見てください。引数には整数、もしくは整数2つの配列を渡します。

:chdir

指定した文字列をカレントディレクトリにします。

:umask

指定した整数を umask に設定します。

リダイレクト関連

Hash のキーに子プロセス側のファイルデスクリプタを、対応する値に親プロセス側のファイルデスクリプタやファイル名を指定することでリダイレクトを実現できます。

:close_others

これを true に設定するとリダイレクトされていない、0(stdin), 1(stdout), 2(stderr) 以外のファイルデスクリプタをすべて閉じます。 false がデフォルトです。

:exception

Kernel?.system のみで指定できます。これを true に設定すると、nil や false を返す代わりに例外が発生します。 false がデフォルトです。

option引数によるリダイレクトの概要

Hash のキー(子プロセス側)には以下のいずれかが指定できます。

  • 単一のファイルデスクリプタ
  • ファイルデスクリプタの配列

配列を渡すことで複数のファイルデスクリプタを同時にリダイレクトできます。

Hash の値(親プロセス側)には以下のいずれかが指定できます。

  • 単一のファイルデスクリプタ
  • リダイレクト先のファイル名文字列
  • [リダイレクト先のファイル名文字列]、配列の要素にすることで File::Constants::RDONLY でファイルを開いてリダイレクトします。
  • [リダイレクト先のファイル名文字列, モード文字列] open(ファイル名, モード, 0644) でファイルを開いてリダイレクト します。
  • [リダイレクト先のファイル名文字列, モード文字列, パーミション(整数)] open(ファイル名, モード, パーミッション) でファイルを 開いてリダイレクトします。
  • [:child, ファイルデスクリプタ] 子プロセス側のファイルデスクリプタを指定できます。
  • :close キーで指定したファイルデスクリプタを子プロセス側で閉じます

ファイルデスクリプタを表すためには、以下が利用できます。

  • :in 標準入力, ファイルデスクリプタ0
  • :out 標準出力, ファイルデスクリプタ1
  • :err 標準エラー出力, ファイルデスクリプタ2
  • 整数 指定した整数が表すファイルデスクリプタ
  • IO IO#fileno で表されるファイルデスクリプタ

option引数の詳細および例

「:unsetenv_others」を使うと、envで指定したもの以外の環境変数をクリアします。 

# すべての環境変数をクリア
pid = spawn(command, :unsetenv_others=>true)
# FOO だけ
pid = spawn({"FOO"=>"BAR"}, command, :unsetenv_others=>true)

「:pgroup」でプロセスグループを指定できます。 

# true, 0 で新しいプロセスグループを作りそのリーダーになります。
pid = spawn(command, :pgroup => true)
# 整数を渡すとそのグループに所属します。
pid = spawn(command, :pgroup => 10)

「:rlimit_core」「:rlimit_cpu」などで、resource limit を指定します。詳しくは Process?.setrlimit を見てください。このオプションには 整数 or 整数2つの配列、を渡すことができます。それぞれ Process?.setrlimit の引数が2個、3個の場合に対応します。 

# 現プロセスの core の resource limit を取得
cur, max = Process.getrlimit(:CORE)
# 一時的に子プロセスの core dump を止める
pid = spawn(command, :rlimit_core=>[0,max]) # disable core temporary.
# 子プロセスで core dump を出せるようにする
pid = spawn(command, :rlimit_core=>max) # enable core dump
# 子プロセスで core dump を出せなくする
pid = spawn(command, :rlimit_core=>0) # never dump core.

「:chdir」で子プロセスのカレントディレクトリを変更できます。 

pid = spawn(command, :chdir=>"/var/tmp")

「:umask」で子プロセスの umask を指定できます。 

pid = spawn(command, :umask=>077)

リダイレクトは様々なやりかたが使えます。 Hash のキーが子プロセス側、値が親プロセス側です。 

# 以下の例はすべて stderr を stdout にリダイレクトします
pid = spawn(command, :err=>:out)
pid = spawn(command, 2=>1)
pid = spawn(command, STDERR=>:out)
pid = spawn(command, STDERR=>STDOUT)

この例では子プロセス側の stdout には触れていないので、親プロセスから引き継がれます。

Hash の値にはファイル名も指定できます。 

pid = spawn(command, :in=>"/dev/null") # read mode
pid = spawn(command, :out=>"/dev/null") # write mode
pid = spawn(command, :err=>"log") # write mode
pid = spawn(command, 3=>"/dev/null") # read mode

stdout と stderr をリダイレクトした場合は、ファイルは write mode で open されます。それ以外の場合は read mode で open されます。

ファイルのフラグ(write/read mode)やパーミッションを明示したい場合は、配列を用います。 

# なにも指定がなければデフォルトで read mode が使われる。
pid = spawn(command, :in=>["file"])
# read mode で file を open し、リダイレクトする。
pid = spawn(command, :in=>["file", "r"])
# write mode で file を open し、リダイレクトする。
# パーミッションはデフォルトで 644。
pid = spawn(command, :out=>["log", "w"]) # 0644 assumed
# write mode、パーミッション 0600 でファイルをオープンし、リダイレクトする。
pid = spawn(command, :out=>["log", "w", 0600])
# flagを文字列でなくビットで指定する
pid = spawn(command, :out=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600])

配列で複数のファイルデスクリプタを同時にリダイレクトできます。 

# stdout と stderr を "log" ファイルにリダイレクト
pid = spawn(command, [:out, :err]=>["log", "w"])

複数のファイルデスクリプタを合わせてリダイレクトするには、 [ :child, FileDescriptor ] を使うこともできます。これは子プロセス側で FileDescriptor にリダイレクトすることを意味します。これはファイルデスクリプタを直接指定するのと異なるということに注意してください。例えば、 

:err => :out

とすると、子プロセスの stderr を親プロセスの stdout にリダイレクトします。 

:err => [:child, :out]

とすると、子プロセスの stderr を子プロセスの stdout にリダイレクトします。これを用いて、IO.popen で、子プロセスの stderr と stdout を混ぜる例を以下に示します。 

io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]])
p io.read #=> "out\nerr\n

spawn と IO.popen ではデフォルトでは非標準的なファイルデスクリプタ(3以降)を閉じません。「:close_others」オプションでこの挙動を制御できます。標準的ファイルデスクリプタ(0,1,2)は :close で明示的に閉じない限り、このオプションの影響を受けません。

「:close_others」とは無関係に ruby が open する IO にはデフォルトでは close_on_exec が設定されていて、自動的に閉じられることに注意してください。 

pid = spawn(command, :close_others=>true)  # close 3,4,5,...
pid = spawn(command, :close_others=>false) # don't close 3,4,5,... (default)

これを利用して spawn を IO.popen のように使うことができます。 

# similar to r = IO.popen(command)
r, w = IO.pipe
pid = spawn(command, :out=>w)   # r は子プロセスで閉じられる
w.close

「:close」を使ってファイルデスクリプタを明示的に閉じることもできます。 

f = open(foo)
# f は継承されない
# system は :close_others=>false がデフォルトなのでそれ以外は継承される
system(command, f=>:close)        # don't inherit f.

spawn で特定のファイルデスクリプタだけを継承したい場合は、 io => io という形のオプションを指定します。 

# valgrind は --log-fd というオプションでログの出力先を指定できます。
# これで指定したファイルデスクリプタは親プロセスから
# 子プロセスに継承されなければならないため、 log_w=>log_w とします。
log_r, log_w = IO.pipe
pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w)
log_w.close
p log_r.read

ファイルデスクリプタを入れ替えることもできます。 

# stdout と stderr を入れ替えリダイレクト
pid = spawn(command, :out=>:err, :err=>:out)

このような相互参照を解決するため、spawnの内部で新しいファイルデスクリプタを作り、利用します。

:close_others と :close オプションが意味を持つのは、子プロセスに閉じていないファイルデスクリプタが全て渡される環境 (Unix 系統の環境)のみです。例えば Windows では元々子プロセスにはファイルデスクリプタ 0 1 2 のみ渡されるので :close_others や :close オプションは意味を持ちません。

[PARAM] env:
更新する環境変数を表す Hash
[PARAM] program:
文字列か2要素の配列を指定します。
[PARAM] args:
渡される引数です。0 個以上の文字列を指定します。
[PARAM] options:
オプションパラメータ Hash
[EXCEPTION] ArgumentError:
第一引数が配列かつ要素数が 2 でない場合に発生します。
[EXCEPTION] Errno::EXXX:
コマンドが実行できなかった場合に発生します。

[SEE_ALSO] Kernel?.system,Kernel?.exec

srand -> Integer[permalink][rdoc][edit]
srand(seed) -> Integer

Kernel?.rand や Random.rand で使用される擬似乱数生成器の種を設定し、古い種を返します。

seed に整数を指定するとその絶対値を乱数の種に設定します。それ以外の値を指定した場合は seed.to_int が指定されたものとして扱います。 seed に既知の値を与えると、以前の Kernel?.rand の値を再現できます。

seed が省略された時には現在の時刻やプロセス ID、srand を呼び出した回数、また可能なら /dev/urandom から読み出したデータなどを元に種を作ります。

[PARAM] seed:
乱数の種となる整数を指定します。 Bignum も指定可能です。
例 
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][edit]
sub(pattern) {|matched| ... } -> String

$_.sub とほぼ同じですが、置換が発生したときは、$_の内容を置き換える点が異なります。コマンドラインオプションで -p または -n を指定した時のみ定義されます。

暗号的になりすぎるきらいがあるため、このメソッドの使用は推奨されていません。今後はより明示的な $_.sub を使ってください。

[EXCEPTION] ArgumentError:
replace を指定しなかった場合に発生します。

$_.sub とこのメソッド sub は以下の点で違いがあります。

  • sub は $_ の値をコピーして、コピーの方を更新し、 $_ に再代入します。
[PARAM] pattern:
置き換える文字列のパターンを表す文字列か正規表現。文字列を指定した場合は全く同じ文字列にだけマッチする
[PARAM] replace:
pattern で指定した文字列と置き換える文字列
例 
p $_             # => "testtest\n"
p sub(/es/, '!!')  # => "t!!ttest\n"

[SEE_ALSO] String#sub,$_

syscall(num, *arg) -> Integer[permalink][rdoc][edit]

numで指定された番号のシステムコールを実行します。第2引数以降をシステムコールの引数として渡します。

どの数値がどのシステムコールに対応するかは、 syscall(2) や /usr/include/sys/syscall.h を参照してください。

システムコールの慣習に従い、syscall(2) が -1 を返す場合には例外 Errno::EXXX が発生します。それ以外では、返した値をそのまま数値で返します。

ライブラリ fiddle を使えばより高レベルな操作ができます。

[PARAM] num:
システムコール番号です。
[PARAM] arg:
文字列か、整数です。最大 9 個まで渡すことができます。
[EXCEPTION] Errno::EXXX:
syscall(2) が -1 を返した場合に発生します。
[EXCEPTION] NotImplementedError:
実行環境がこのメソッドに対応していないとき発生します。
例 
syscall 4, 1, "hello\n", 6   # '4' is write(2) on our box
# => hello

[SEE_ALSO] fiddle, syscall(2freebsd), syscall(2linux)

system(command, options={}) -> bool | nil[permalink][rdoc][edit]
system(env, command, options={}) -> bool | nil

引数を外部コマンドとして実行して、成功した時に真を返します。

子プロセスが終了ステータス 0 で終了すると成功とみなし true を返します。それ以外の終了ステータスの場合は false を返します。コマンドを実行できなかった場合は nil を返します。

options で :exception に true を指定することで、 nil や false を返す代わりに例外を発生するようにできます。

終了ステータスは変数 $? で参照できます。

コマンドを実行できなかった場合、多くのシェルはステータス 127 を返します。シェルを介さない場合は Ruby の子プロセスがステータス 127 で終了します。コマンドが実行できなかったのか、コマンドが失敗したのかは、普通 $? を参照することで判別可能です。

引数の解釈

この形式では command が shell のメタ文字 

  * ? {} [] <> () ~ & | \ $ ; ' ` " \n

を含む場合、shell 経由で実行されます。そうでなければインタプリタから直接実行されます。

[PARAM] command:
command コマンドを文字列で指定します。
[PARAM] env:
更新する環境変数を表す Hash
[PARAM] options:
オプションパラメータ Hash
[EXCEPTION] Errno::EXXX:
exception: true が指定されていて、コマンドの実行が失敗したときに発生します。
[EXCEPTION] RuntimeError:
exception: true が指定されていて、コマンドの終了ステータスが 0 以外のときに発生します。
シェル経由でコマンドを実行 
p system("echo *") # => true
# fileA fileB fileC ...
exceptionオプションを指定 
p system("sad", exception: true)                 # => Errno::ENOENT (No such file or directory - sad)
system('ruby -e "exit(false)"', exception: true) # ~> RuntimeError: Command failed with exit 1: ruby -e "exit(false)"
p system('ruby -e "exit(true)"', exception: true)  # => true

[SEE_ALSO] Kernel?.`,Kernel?.spawn,Kernel?.exec,system(3)

system(program, *args, options={}) -> bool | nil[permalink][rdoc][edit]
system(env, program, *args, options={}) -> bool | nil

引数を外部コマンドとして実行して、成功した時に真を返します。

子プロセスが終了ステータス 0 で終了すると成功とみなし true を返します。それ以外の終了ステータスの場合は false を返します。コマンドを実行できなかった場合は nil を返します。

options で :exception に true を指定することで、 nil や false を返す代わりに例外を発生するようにできます。

終了ステータスは変数 $? で参照できます。

コマンドを実行できなかった場合、多くのシェルはステータス 127 を返します。シェルを介さない場合は Ruby の子プロセスがステータス 127 で終了します。コマンドが実行できなかったのか、コマンドが失敗したのかは、普通 $? を参照することで判別可能です。

Hash を options として渡すことで、起動される子プロセスの

  • プロセスグループ
  • resource limit
  • カレントディレクトリ
  • umask
  • 子プロセスでのリダイレクト

などを変更できます。環境変数のクリアなども指定できます。詳しくは Kernel?.spawn を参照してください。

引数の解釈

この形式で呼び出した場合、空白や shell のメタキャラクタもそのまま program の引数に渡されます。先頭の引数が2要素の配列であった場合、第1要素の文字列が実際に起動するプログラムのパスであり、第2要素が「みせかけ」のプログラム名になります。また、第1要素はフルパスで指定しなくても環境変数 PATH から探します。

[PARAM] program:
文字列か2要素の配列です。
[PARAM] args:
program に渡す引数を 0 個以上指定する
[PARAM] env:
更新する環境変数を表す Hash
[PARAM] options:
オプションパラメータ Hash
[EXCEPTION] ArgumentError:
第一引数が配列かつ要素数が 2 でない場合に発生します。
[EXCEPTION] Errno::EXXX:
exception: true が指定されていて、コマンドの実行が失敗したときに発生します。
[EXCEPTION] RuntimeError:
exception: true が指定されていて、コマンドの終了ステータスが 0 以外のときに発生します。
インタプリタから直接コマンドを実行 
p system("echo", "*") # => true
# *

[SEE_ALSO] Kernel?.`,Kernel?.spawn,Kernel?.exec,system(3)

test(cmd, file) -> bool | Time | Integer | nil[permalink][rdoc][edit]

単体のファイルでファイルテストを行います。

[PARAM] cmd:
以下に示す文字リテラル、文字列、あるいは同じ文字を表す数値です。文字列の場合はその先頭の文字だけをコマンドとみなします。
[PARAM] file:
テストするファイルのパスを表す文字列か IO オブジェクトを指定します。
[RETURN]
下表に特に明記していないものは、真偽値を返します。

以下は cmd として指定できる文字リテラルとその意味です。

?r

ファイルを実効 uid で読むことができる

?w

ファイルに実効 uid で書くことができる

?x

ファイルを実効 uid で実行できる

?o

ファイルの所有者が実効 uid である

?G

ファイルのグループ所有者が実効 gid である

?R

ファイルを実 uid で読むことができる

?W

ファイルに実 uid で書くことができる

?X

ファイルを実 uid で実行できる

?O

ファイルの所有者が実 uid である

?e

ファイルが存在する

?z

ファイルサイズが 0 である

?s

ファイルサイズが 0 でない (ファイルサイズを返す、0 ならば nil) -> Integer|nil

?f

ファイルはプレーンファイルである

?d

ファイルはディレクトリである

?l

ファイルはシンボリックリンクである

?p

ファイルは名前つきパイプ(FIFO)である

?S

ファイルはソケットである

?b

ファイルはブロックスペシャルファイルである

?c

ファイルはキャラクタースペシャルファイルである

?u

ファイルに setuid ビットがセットされている

?g

ファイルに setgid ビットがセットされている

?k

ファイルに sticky ビットがセットされている

?M

ファイルの最終更新時刻を返す -> Time

?A

ファイルの最終アクセス時刻を返す -> Time

?C

ファイルの inode 変更時刻を返す -> Time

例 
IO.write("testfile", "test")
test("r", "testfile") # => true
test("s", "testfile") # => 4
test("M", "testfile") # => 2018-03-31 07:38:40 +0900
test(cmd, file1, file2) -> bool[permalink][rdoc][edit]

２ファイル間のファイルテストを行います。

[PARAM] cmd:
以下に示す文字リテラル、文字列、あるいは同じ文字を表す数値です。文字列の場合はその先頭の文字だけをコマンドとみなします。
[PARAM] file1:
テストするファイルのパスを表す文字列か IO オブジェクトを指定します。
[PARAM] file2:
テストするファイルのパスを表す文字列か IO オブジェクトを指定します。
[RETURN]
真偽値を返します。

以下は cmd として指定できる文字リテラルとその意味です。

?=

ファイル1とファイル2の最終更新時刻が等しい

?>

ファイル1の方がファイル2より最終更新時刻が新しい

?<

ファイル1の方がファイル2より最終更新時刻が古い

?-

ファイル1とファイル2が同一のファイルである

例 
IO.write("testfile1", "test1")
IO.write("testfile2", "test2")
%w(= < > -).each do |e|
  result = test(e, "testfile1", "testfile2")
  puts "#{e}: #{result}"
end
# => =: true
# => <: false
# => >: false
# => -: false
throw(tag, value = nil) -> ()[permalink][rdoc][edit]

Kernel?.catchとの組み合わせで大域脱出を行います。 throw は同じ tag を指定した catch のブロックの終わりまでジャンプします。

throw は探索時に呼び出しスタックをさかのぼるので、ジャンプ先は同じメソッド内にあるとは限りません。もし ensure節 が存在するならジャンプ前に実行します。

同じ tag で待っている catch が存在しない場合は、例外でスレッドが終了します。

同じ tag であるとは Object#object_id が同じであるという意味です。

[PARAM] tag:
catch の引数に対応する任意のオブジェクトです。
[PARAM] value:
catch の戻り値になります。
[EXCEPTION] UncaughtThrowError:
同じ 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][edit]
trace_var(varname) {|new_val| .... } -> nil
trace_var(varname, hook) -> [String|Proc]

グローバル変数 varname への代入のフックを登録します。

ここでの「グローバル変数」は、特殊変数 (変数と定数/組み込み変数 を参照)も含めた $ で始まる変数のことです。

この呼び出し以降、varname で指定したグローバル変数に値が代入されるたびに hook かブロックが評価されます。hook が Proc オブジェクトの場合代入された値がブロック引数に渡されます。文字列の場合はRubyコードとして評価されます。

trace_var がフックするのは明示的な代入だけです。フックは複数登録できます。

フックを解除するには、hook に nil を指定するか、Kernel?.untrace_var を用います。

hook が nil ならば、設定されていた hook をすべて解除してその配列を返します(ブロックで登録されていれば Proc オブジェクトで返されます) それ以外は、nil を返します。

[PARAM] varname:
グローバル変数名を文字列か Symbol で指定します。
[PARAM] hook:
フックになる文字列または Proc オブジェクトです。
[RETURN]
フックを登録した場合は 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][edit]
trap(signal) { ... } -> String | Proc | nil

signal で指定された割り込みにたいするハンドラとして command を登録します。Signal?.trapと同じです。

Signal?.trapの使用を推奨します。

[PARAM] signal:
Signal?.trap 参照
[PARAM] command:
Signal?.trap 参照

[SEE_ALSO] Signal?.trap,Signal

untrace_var(varname, hook = nil) -> [String|Proc][permalink][rdoc][edit]

グローバル変数 varname に関連付けられたフックを解除します。

hook が指定された場合にはそのフックだけを解除します。省略するか nil を与えた場合は varname のフックを全て解除します。

[PARAM] varname:
グローバル変数名を文字列か Symbol で指定します。
[PARAM] hook:
文字列または Proc オブジェクトです。
[RETURN]
解除されたフックの配列を返します。
例 
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, uplevel: nil, category: nil) -> nil[permalink][rdoc][edit]

message を 標準エラー出力 $stderr に出力します。 $VERBOSE フラグ が nil のときは何も出力しません。

文字列以外のオブジェクトが引数として与えられた場合には、 to_s メソッドにより文字列に変換してから出力します。

uplevel を指定しない場合は、このメソッドは以下と同じです。 

$stderr.puts(*message) if !$VERBOSE.nil? && !message.empty?
nil
[PARAM] message:
出力するオブジェクトを任意個指定します。
[PARAM] uplevel:
いくつ前の呼び出し元のファイル名と行番号を表示するかを0以上の数値で指定します。 nil の場合は表示しません。
[PARAM] category:
警告のカテゴリを指定します。サポートされている category については Warning.[] を参照してください。
[EXCEPTION] IOError:
標準エラー出力が書き込み用にオープンされていなければ発生します。
[EXCEPTION] Errno::EXXX:
出力に失敗した場合に発生します。
例 
warn "caution!" #=> caution!
$VERBOSE = nil
warn "caution!" # 何もしない
uplevel の例 
def foo
  warn("test message", uplevel: 0) # => test.rb:2: warning: test message
  warn("test message", uplevel: 1) # => test.rb:6: warning: test message
  warn("test message", uplevel: 2) # => test message
end
foo
category の例 
Warning[:deprecated] = true # 非推奨の警告を表示する
warn("deprecated!!", category: :deprecated)
# => deprecated!

Warning[:deprecated] = false # 非推奨の警告を表示しない
warn("deprecated!!", category: :deprecated)
# 警告は出力されない

[SEE_ALSO] Warning#warn, $stderr,$VERBOSE

追加されるメソッド

$ARGV -> [String][permalink][rdoc][edit] [added by English]

$* の別名 

require "English"
p $ARGV
# end of sample.rb

ruby sample.rb 31 /home/hoge/fuga.txt
#=> ["31", "/home/hoge/fuga.txt"]
BigDecimal(s, exception: true) -> BigDecimal | nil[permalink][rdoc][edit] [added by bigdecimal]
BigDecimal(s, n, exception: true) -> BigDecimal | nil [added by bigdecimal]

引数で指定した値を表す BigDecimal オブジェクトを生成します。

[PARAM] s:
数値を表現する初期値を文字列、Integer、 Float、Rational、BigDecimal オブジェクトのいずれかで指定します。文字列中のスペースは無視されます。また、判断できない文字が出現した時点で文字列は終了したものとみなされます。
[PARAM] n:
必要な有効桁数(self の最大有効桁数)を整数で指定します。 n が 0 または省略されたときは、n の値は s の有効桁数とみなされます。 s の有効桁数より n が小さいときもn = 0 のときと同じです。 self の最大有効桁数は n より若干大きい値が採用されます。最大有効桁数は以下のような割り算を実行するとき等に意味を持ちます。 
require "bigdecimal"
p BigDecimal("1")    / BigDecimal("3")  # => 0.333333333333333333e0
p BigDecimal("1",10) / BigDecimal("3",10) # => 0.333333333333333333e0
ただし、個々の演算における最大有効桁数 n の取り扱いは将来のバージョンで若干変更される可能性があります。
[PARAM] exception:
false を指定すると、変換できなかった場合、例外を発生する代わりに nil を返します。
[EXCEPTION] ArgumentError:
s に Float オブジェクトを指定し、n に Float::DIG + 2 以上の値を指定した場合に発生します。 s に Float、Rational オブジェクトを指定し、n を省略した場合に発生します。
[EXCEPTION] ArgumentError:
n に負の数を指定した場合に発生します。
$CFLAGS -> String[permalink][rdoc][edit] [added by mkmf]

拡張ライブラリをコンパイルするときの C コンパイラのオプションや、ヘッダファイルのディレクトリを指定する文字列です。

Kernel#dir_config の検査が成功すると、この変数の値に " -Idir" が追加されます。

$CHILD_STATUS -> Process::Status | nil[permalink][rdoc][edit] [added by English]

$? の別名 

require "English"

out = `wget https://www.ruby-lang.org/en/about/license.txt -O - 2>/dev/null`

if $CHILD_STATUS.to_i == 0
  print "wget success\n"
  out.split(/\n/).each { |line|
    printf "%s\n", line
  }
else
  print "wget failed\n"
end
CONFIG -> Hash[permalink][rdoc][edit] [added by mkmf]

RbConfig::MAKEFILE_CONFIG と同じです。

$DEFAULT_INPUT -> IO[permalink][rdoc][edit] [added by English]

$< の別名 

require "English"
while line = $DEFAULT_INPUT.gets
  p line
end
# end of sample.rb

ruby sample.rb < /etc/passwd
# => "hoge:x:500:501::/home/hoge:/bin/bash\n"
     ...
$DEFAULT_OUTPUT -> IO[permalink][rdoc][edit] [added by English]

$> の別名 

require "English"

dout = $DEFAULT_OUTPUT.dup
$DEFAULT_OUTPUT.reopen("out.txt", "w")
print "foo"
$DEFAULT_OUTPUT.close
$DEFAULT_OUTPUT = dout
p "bar" # => bar
p File.read("out.txt") #=> foo
DelegateClass(superclass) -> object[permalink][rdoc][edit] [added by delegate]

クラス superclass のインスタンスへメソッドを委譲するクラスを定義し、そのクラスを返します。

[PARAM] superclass:
委譲先となるクラス
例 
require 'delegate'

class ExtArray < DelegateClass(Array)
  def initialize
    super([])
  end
end
a = ExtArray.new
p a.class   # => ExtArray
a.push 25
p a         # => [25]
Digest(name) -> object[permalink][rdoc][edit] [added by digest]

"MD5"や"SHA1"などのダイジェストを示す文字列 name を指定し、対応するダイジェストのクラスを取得します。

このメソッドはスレッドセーフです。マルチスレッド環境で Digest::MD5などを直接呼び出すと問題があるときはこのメソッドを使うか、起動時に使用するライブラリを Kernel?.require してください。

[PARAM] name:
"MD5"や"SHA1"などのダイジェストを示す文字列を指定します。
[RETURN]
Digest::MD5やDigest::SHA1などの対応するダイジェストのクラスを返します。インスタンスではなく、クラスを返します。注意してください。

例: Digest::MD、Digest::SHA1、Digest::SHA512のクラス名を順番に出力する。 

require 'digest'
for a in ["MD5", "SHA1", "SHA512"]
  p Digest(a) # => Digest::MD5, Digest::SHA1, Digest::SHA512
end
$ERROR_INFO -> Exception | nil[permalink][rdoc][edit] [added by English]

$! の別名 

require "English"
class SomethingError < StandardError; end

begin
  raise SomethingError
rescue
  p $ERROR_INFO.backtrace #=> ["sample.rb:5"]
  p $ERROR_INFO.to_s #=> "SomethingError"
end
$ERROR_POSITION -> [String] | nil[permalink][rdoc][edit] [added by English]

$@ の別名 

require "English"
class SomethingError < StandardError; end

begin
  raise SomethingError
rescue
  p $ERROR_POSITION #=> ["sample.rb:5"]
end
$FS -> String | nil[permalink][rdoc][edit] [added by English]
$FIELD_SEPARATOR -> String | nil [added by English]

$; の別名 

require "English"

str = "hoge,fuga,ugo,bar,foo"
p str.split #=> ["hoge,fuga,ugo,bar,foo"]
$FIELD_SEPARATOR = ","
p str.split #=> ["hoge", "fuga", "ugo", "bar", "foo"]
$IGNORECASE -> bool[permalink][rdoc][edit] [added by English]

過去との互換性のために残されていますが、もはや何の意味もありません。

値は常に false です。代入しても無視されます。

$= の別名 

require "English"

$IGNORECASE = true # => warning: variable $= is no longer effective; ignored
p $IGNORECASE      # => warning: variable $= is no longer effective
                   #    false
$INPUT_LINE_NUMBER -> Integer[permalink][rdoc][edit] [added by English]
$NR -> Integer [added by English]

$. の別名 

1 e
2 f
3 g
4 h
5 i
# end of a.txt

require "English"

File.foreach(ARGV.at(0)){|line|
  # read line
}
p $INPUT_LINE_NUMBER
# end of sample.rb

ruby sample.rb a.txt
#=> 5
$RS -> String | nil[permalink][rdoc][edit] [added by English]
$INPUT_RECORD_SEPARATOR -> String | nil [added by English]

$/ の別名 

require "English"

$INPUT_RECORD_SEPARATOR = '|'
array = []
while line = DATA.gets
  array << line
end
p array #=> ["ugo|", "ego|", "fogo\n"]

__END__
ugo|ego|fogo
JSON(object, options = {}) -> objectRuby 1.9.3 から[permalink][rdoc][edit] [added by json]

第一引数に与えられたオブジェクトの種類によって Ruby のオブジェクトか JSON 形式の文字列を返します。

第一引数に文字列のようなオブジェクトを指定した場合は、それを JSON?.parse を用いてパースした結果を返します。そうでないオブジェクトを指定した場合は、それを JSON?.generate を用いて変換した結果を返します。

[PARAM] object:
任意のオブジェクトを指定します。
[PARAM] options:
JSON?.parse, JSON?.generate に渡すオプションを指定します。
例 
require "json"

p JSON('[1,2,{"name":"tanaka","age":19}]')
# => [1, 2, {"name"=>"tanaka", "age"=>19}]

p JSON('[1,2,{"name":"tanaka","age":19}]', symbolize_names: true)
# => [1, 2, {:name=>"tanaka", :age=>19}]

[SEE_ALSO] JSON?.parse, JSON?.generate

$LAST_MATCH_INFO -> MatchData | nil[permalink][rdoc][edit] [added by English]

$~ の別名 

require "English"

str = "<a href=https://www.ruby-lang.org/en/about/license.txt>license</a>"

if /<a href=(.+?)>/ =~ str
  p $LAST_MATCH_INFO[0] #=> "<a href=https://www.ruby-lang.org/en/about/license.txt>"
  p $LAST_MATCH_INFO[1] #=> "https://www.ruby-lang.org/en/about/license.txt"
  p $LAST_MATCH_INFO[2] #=> nil
end
$LAST_PAREN_MATCH -> String | nil[permalink][rdoc][edit] [added by English]

$+ の別名 

require "English"

r1 = Regexp.compile("<img src=(http:.+?)>")
r2 = Regexp.compile("<a href=(http|ftp).+?>(.+?)</a>")

while line = DATA.gets
  [ r1, r2 ].each {|rep|
    rep =~ line
    p $+
  }
end
__END__
<tr> <td><img src=http://localhost/a.jpg></td> <td>ikkou</td> <td><a href=http://localhost/link.html>link</a></td> </tr>
#enf of sample.rb

$ ruby sample.rb
"http://localhost/a.jpg"
"link"
$LAST_READ_LINE -> String | nil[permalink][rdoc][edit] [added by English]

$_ の別名 

1 e
2 f
3 g
4 h
5 i
# end of a.txt

ruby -rEnglish -ne'p $LAST_READ_LINE' a.txt
#=>
"1 e\n"
"2 f\n"
"3 g\n"
"4 h\n"
"5 i\n"
$LDFLAGS -> String[permalink][rdoc][edit] [added by mkmf]

拡張ライブラリをリンクするときのリンカのオプション、ライブラリファイルのディレクトリを指定する文字列です。

Kernel#find_library または Kernel#dir_config の検査が成功すると、$LDFLAGS の値に "-Ldir" を追加します。

$MATCH -> String | nil[permalink][rdoc][edit] [added by English]

$& の別名 

require "English"

str = 'hoge,foo,bar,hee,hoo'

/(foo|bar)/ =~ str
p $MATCH     #=> "foo"
$OFS -> String | nil[permalink][rdoc][edit] [added by English]
$OUTPUT_FIELD_SEPARATOR -> String | nil [added by English]

$, の別名 

require "English"

array = %w|hoge fuga ugo bar foo|
p array.join #=> "hogefugaugobarfoo"
$OUTPUT_FIELD_SEPARATOR = ","
p array.join #=> "hoge,fuga,ugo,bar,foo"
$ORS -> String | nil[permalink][rdoc][edit] [added by English]
$OUTPUT_RECORD_SEPARATOR -> String | nil [added by English]

$\ の別名 

require "English"

print "hoge\nhuga\n"
$OUTPUT_RECORD_SEPARATOR = "\n"
print "fuge"
print "ugo"
# end of sample.rb

ruby sample.rb
hoge
huga
fuge
ugo
$PID -> Integer[permalink][rdoc][edit] [added by English]
$PROCESS_ID -> Integer [added by English]

$$ の別名 

require "English"

p sprintf("something%s", $PID) #=> "something5543" など
$POSTMATCH -> String | nil[permalink][rdoc][edit] [added by English]

$' の別名 

require "English"

str = 'hoge,foo,bar,hee,hoo'

/foo/ =~ str
p $POSTMATCH #=> ",bar,hee,hoo"
$PREMATCH -> String | nil[permalink][rdoc][edit] [added by English]

$` の別名 

require "English"

str = 'hoge,foo,bar,hee,hoo'

/foo/ =~ str
p $PREMATCH  #=> "hoge,"
Pathname(path) -> Pathname[permalink][rdoc][edit] [added by pathname]

文字列 path を元に Pathname オブジェクトを生成します。

Pathname.new(path) と同じです。

[PARAM] path:
文字列、または類似のオブジェクトを与えます。実際には to_str に反応するオブジェクトなら何でも構いません。
URI(uri_str) -> object[permalink][rdoc][edit] [added by uri]

与えられた URI から該当する URI::Generic のサブクラスのインスタンスを生成して返します。scheme が指定されていない場合は、URI::Generic オブジェクトを返します。

[PARAM] uri_str:
パースしたい URI を文字列として与えます。
[EXCEPTION] URI::InvalidURIError:
パースに失敗した場合に発生します。

[SEE_ALSO] URI.parse

$archdir -> String[permalink][rdoc][edit] [added by mkmf]

マシン固有のライブラリを置くディレクトリです。通常は "/usr/local/lib/ruby/バージョン/arch" です。

arg_config(config, default) { ... } -> object | String | true | nil[permalink][rdoc][edit] [added by mkmf]

configure オプション --config の値を返します。

[PARAM] config:
オプションを文字列で指定します。
[PARAM] default:
引数 config で指定したオプションのデフォルト値を指定します。
[RETURN]
オプションが指定されてた場合は true を、指定されなかった場合は nil を返します。引数 default、あるいはブロックを指定すると、オプションが指定されていない場合に引数 default の値かブロックの評価結果を返します (両方指定した場合はブロックが優先されます)。オプションに引数が指定されていた場合は指定した文字列を返します。

例えば extconf.rb で arg_config メソッドを使う場合、 

$ ruby extconf.rb --foo --bar=baz

と実行したとき、arg_config("--foo") の値は true、 arg_config("--bar") の値は "baz" です。

callcc {|cont| .... } -> object[permalink][rdoc][edit] [added by continuation]

継続を作成します。 Continuation を参照してください。

cc_command(opt = "") -> String[permalink][rdoc][edit] [added by mkmf]

実際にコンパイルする際に使用するコマンドを返します。

[PARAM] opt:
コンパイラに与える追加のコマンドライン引数を指定します。

[SEE_ALSO] RbConfig.expand

check_signedness(type, headers = nil, opts = nil) -> "signed" | "unsigned" | nilRuby 1.9.3 から[permalink][rdoc][edit] [added by mkmf]
check_signedness(type, headers = nil, opts = nil) { ... } -> "signed" | "unsigned" | nil [added by mkmf] 
Returns the signedness of the given +type+.  You may optionally
specify additional +headers+ to search in for the +type+.
 
If the +type+ is found and is a numeric type, a macro is passed as a
preprocessor constant to the compiler using the +type+ name, in
uppercase, prepended with 'SIGNEDNESS_OF_', followed by the +type+
name, followed by '=X' where 'X' is positive integer if the +type+ is
unsigned, or negative integer if the +type+ is signed.
 
For example, if size_t is defined as unsigned, then
check_signedness('size_t') would returned +1 and the
SIGNEDNESS_OF_SIZE_T=+1 preprocessor macro would be passed to the
compiler, and SIGNEDNESS_OF_INT=-1 if check_signedness('int') is
done.
check_sizeof(type, headers = nil) -> Integer | nil[permalink][rdoc][edit] [added by mkmf]
check_sizeof(type, headers = nil) { ... } -> Integer | nil [added by mkmf]

与えられた型のサイズを返します。

型 type がシステムに存在する場合は、グローバル変数 $defs に "-DSIZEOF_type=X" を追加し、型のサイズを返します。型 type がシステムに存在しない場合は、nil を返します。

例えば、 

require 'mkmf'
p check_sizeof('mystruct') # => 12

である場合、SIZEOF_MYSTRUCT=12 というプリプロセッサマクロをコンパイラに渡します。

[PARAM] type:
検査したい型を指定します。
[PARAM] headers:
追加のヘッダファイルを指定します。
chmod -> ()[permalink][rdoc][edit] [added by un]

ファイルのアクセス権を変更します。

Change the mode of each FILE to OCTAL-MODE. 

ruby -run -e chmod -- [OPTION] OCTAL-MODE FILE

-v          詳細表示

[SEE_ALSO] chmod(1)

convertible_int(type, headers = nil, opts = nil)Ruby 1.9.3 から[permalink][rdoc][edit] [added by mkmf]
convertible_int(type, headers = nil, opts = nil) { ... } [added by mkmf] 
Returns the convertible integer type of the given +type+.  You may
optionally specify additional +headers+ to search in for the +type+.
_Convertible_ means actually same type, or typedefed from same type.
 
If the +type+ is a integer type and _convertible_ type is found,
following macros are passed as preprocessor constants to the
compiler using the +type+ name, in uppercase.
 
* 'TYPEOF_', followed by the +type+ name, followed by '=X' where 'X'
  is the found _convertible_ type name.  * 'TYP2NUM' and 'NUM2TYP,
  where 'TYP' is the +type+ name in uppercase with replacing '_t'
  suffix with 'T', followed by '=X' where 'X' is the macro name to
  convert +type+ to +Integer+ object, and vice versa.
 
For example, if foobar_t is defined as unsigned long, then
convertible_int("foobar_t") would return "unsigned long", and define
macros:
 
  #define TYPEOF_FOOBAR_T unsigned long
  #define FOOBART2NUM ULONG2NUM
  #define NUM2FOOBART NUM2ULONG
cp -> ()[permalink][rdoc][edit] [added by un]

ファイルやディレクトリをコピーします。 

ruby -run -e cp -- [OPTION] SOURCE DEST

-p          可能であればファイルの属性を保持します。
-r          再帰的にコピーします。
-v          詳細表示

[SEE_ALSO] cp(1)

cpp_command(outfile, opt = "") -> String[permalink][rdoc][edit] [added by mkmf]

実際にプリプロセッサを実行する際に使用するコマンドを返します。

[PARAM] outfile:
出力ファイルの名前を指定します。
[PARAM] opt:
プリプロセッサに与える追加のコマンドライン引数を指定します。

[SEE_ALSO] RbConfig.expand

create_header(header = "extconf.h") -> String[permalink][rdoc][edit] [added by mkmf]

Kernel#have_func, Kernel#have_header などの検査結果を元に、ヘッダファイルを生成します。

このメソッドは extconf.rb の最後で呼び出すようにしてください。

[PARAM] header:
ヘッダファイルの名前を指定します。
[RETURN]
ヘッダファイルの名前を返します。
例 
# extconf.rb
require 'mkmf'
have_func('realpath')
have_header('sys/utime.h')
create_header
create_makefile('foo')

上の extconf.rb は以下の extconf.h を生成します。 

#ifndef EXTCONF_H
#define EXTCONF_H
#define HAVE_REALPATH 1
#define HAVE_SYS_UTIME_H 1
#endif
create_makefile(target, srcprefix = nil) -> true[permalink][rdoc][edit] [added by mkmf]

[TODO]

Kernel#have_library などの各種検査の結果を元に、拡張ライブラリをビルドするための Makefile を生成します。

extconf.rb は普通このメソッドの呼び出しで終ります。

[PARAM] target:
ターゲットとなる拡張ライブラリの名前を指定します。例えば、拡張ライブラリで "Init_foo" という関数を定義している場合は、"foo" を指定します。 '/' を含む場合は、最後のスラッシュ以降のみをターゲット名として使用します。残りはトップレベルのディレクトリ名と見なされ、生成された Makefile はそのディレクトリ構造に従います。例えば、'test/foo' を指定した場合、拡張ライブラリは 'test' ディレクトリにインストールされます。この拡張ライブラリを Ruby スクリプトから使用するときは "require 'test/foo'" とする必要があります。
[PARAM] srcprefix:
ソースコードがあるディレクトリ名を指定します。省略した場合は extconf.rb があるディレクトリを使用します。

以下のようなディレクトリ構成の場合: 

ext/
   extconf.rb
   test/
      foo.c

このようにします。 

require 'mkmf'
create_makefile('test/foo', 'test')

このようにして作った Makefile で 'make install' すると拡張ライブラリは、以下のパスにインストールされます。 

/path/to/ruby/sitearchdir/test/foo.so

ブロックを与える場合、生成する Makefile の設定部分を文字列の配列として yield します。 

create_makefile('foo') {|conf|
  [
    *conf,
    "MACRO_YOU_NEED = something",
  ]
}

ソースディレクトリに depend ファイルが存在する場合、その内容が Kernel#depend_rules メソッドで整形されて、生成される Makefile に加えられます。

create_tmpsrc(src) -> String[permalink][rdoc][edit] [added by mkmf]

与えられた C プログラムのソースコードを一時ファイルに出力して与えられたソースコードを返します。

[PARAM] src:
C プログラムのソースコードを指定します。
$defs -> [String][permalink][rdoc][edit] [added by mkmf]

拡張ライブラリをコンパイルするときのマクロ定義を指定する配列です。

この変数の値は、例えば 

["-DHAVE_FUNC", "-DHAVE_HEADER_H"]

のような形式の配列です。

Kernel#have_func または Kernel#have_header を呼び出すと、その検査結果が $defs に追加されます。

Kernel#create_header はこの変数の値を参照してヘッダファイルを生成します。

depend_rules(depend) -> ArrayRuby 1.9.3 から[permalink][rdoc][edit] [added by mkmf]

ファイルの依存関係の書かれた depend ファイルの内容を処理します。

[PARAM] depend:
depend ファイルの内容を指定します。
[RETURN]
見つかった依存関係を Makefile 形式で返します。
desc(description) -> StringRuby 1.9.3 から[permalink][rdoc][edit] [added by rake]

直後の Rake タスクの説明を登録します。

[PARAM] description:
直後のタスクの説明を指定します。
例 
desc "Run the Unit Tests"
task :test => [:build] do
  runtests
end
dir_config(target, idefault = nil, ldefault = nil) -> [String, String][permalink][rdoc][edit] [added by mkmf]

configure オプション --with-TARGET-dir, --with-TARGET-include, --with-TARGET-lib をユーザが extconf.rb に指定できるようにします。

--with-TARGET-dir オプションはシステム標準ではない、ヘッダファイルやライブラリがあるディレクトリをまとめて指定するために使います。ユーザが extconf.rb に --with-TARGET-dir=PATH を指定したときは $CFLAGS に "-IPATH/include" を、 $LDFLAGS に "-LPATH/lib" を、それぞれ追加します。

--with-TARGET-include オプションはシステム標準ではないヘッダファイルのディレクトリを指定するために使います。ユーザが extconf.rb に --with-TARGET-include=PATH を指定したときは $CFLAGS に PATH を追加します。

--with-TARGET-lib オプションはシステム標準ではないライブラリのディレクトリを指定するために使います。ユーザが extconf.rb に --with-TARGET-lib=PATH を指定したときは $CFLAGS に PATH を追加します。

[PARAM] target:
ターゲットの名前を指定します。
[PARAM] idefault:
システム標準ではないヘッダファイルのディレクトリのデフォルト値を指定します。
[PARAM] ldefault:
システム標準ではないライブラリのディレクトリのデフォルト値を指定します。
例 
require 'mkmf'
# xml2 の configure オプションを指定できるようにします。
xml2_dirs = dir_config('xml2', '/opt/local/include/libxml2', '/opt/local/lib')
directory(dir) -> ()Ruby 1.9.3 から[permalink][rdoc][edit] [added by rake]

与えられたディレクトリを作成するタスクを定義します。

[PARAM] dir:
作成するディレクトリを指定します。
例 
directory 'testdata/doc'
dummy_makefile(srcdir) -> String[permalink][rdoc][edit] [added by mkmf]

ダミーの Makefile を作成します。

[PARAM] srcdir:
ソースディレクトリを指定します。
egrep_cpp(pattern, src, opt = "") -> bool[permalink][rdoc][edit] [added by mkmf]
egrep_cpp(pattern, src, opt = "") { ... } -> bool [added by mkmf]

C プログラムのソースコード src をプリプロセスし、その結果が正規表現 pattern にマッチするかどうかを判定します。 

CPP $CFLAGS opt | egrep pat

を実行し、その結果が正常かどうかを true または false で返します。

このメソッドはヘッダファイルに関数などの宣言があるかどうか検査するために使用します。

[PARAM] pattern:
「egrep の」正規表現を文字列で指定します。 Ruby の正規表現ではありません。
[PARAM] src:
C 言語のソースコードを文字列で記述します。

[SEE_ALSO] egrep(1)

enable_config(config, default) -> bool | String[permalink][rdoc][edit] [added by mkmf]
enable_config(config, default) {|config, default| ... } -> bool | String [added by mkmf]

configure のオプションを検査します。

configure のオプションに --enable-<config> が指定された場合は、真を返します。--disable-<config> が指定された場合は。偽を返します。どちらでもない場合は default を返します。

これはデバッグ情報などのカスタム定義を、追加するのに役立ちます。

[PARAM] config:
configure のオプションの名前を指定します。
[PARAM] default:
デフォルト値を返します。
例 
require 'mkmf'
if enable_config("debug")
   $defs.push("-DOSSL_DEBUG") unless $defs.include? "-DOSSL_DEBUG"
end
file(*args) { ... } -> Rake::FileTaskRuby 1.9.3 から[permalink][rdoc][edit] [added by rake]

ファイルタスクを定義します。

[PARAM] args:
ファイル名と依存ファイル名を指定します。
例 
file "config.cfg" => ["config.template"] do
  open("config.cfg", "w") do |outfile|
    open("config.template") do |infile|
      while line = infile.gets
        outfile.puts line
      end
    end
  end
end

[SEE_ALSO] Rake::Task.define_task

file_create(*args) { ... } -> Rake::FileCreationTaskRuby 1.9.3 から[permalink][rdoc][edit] [added by rake]

ファイルを作成するタスクを定義します。

主に Kernel?.directory を定義するために使用します。

find_executable(bin, path = nil) -> String | nil[permalink][rdoc][edit] [added by mkmf]

パス path から実行ファイル bin を探します。

実行ファイルが見つかった場合は、そのフルパスを返します。実行ファイルが見つからなかった場合は、nilを返します。

このメソッドは Makefile を変更しません。

[PARAM] bin:
実行ファイルの名前を指定します。
[PARAM] path:
パスを指定します。デフォルトは環境変数 PATH です。環境変数 PATH が定義されていない場合は /usr/local/bin, /usr/ucb, /usr/bin, /bin を使います。
find_header(header, *paths) -> bool[permalink][rdoc][edit] [added by mkmf]

与えられた paths から header を検索し、見つかった場合は真を返します。そうでない場合は偽を返します。

ヘッダが見つかったディレクトリをコンパイラに渡すコマンドラインオプションに追加します(-I オプションを経由します)。

[PARAM] header:
ヘッダを指定します。
[PARAM] paths:
ヘッダを検索するパスを指定します。
find_library(lib, func, *paths) -> bool[permalink][rdoc][edit] [added by mkmf]
find_library(lib, func, *paths) { ... } -> bool [added by mkmf]

関数 func が定義されたライブラリ lib を探します。

最初はパスを指定せずに探し、それに失敗したら paths[0] を指定して探し、それにも失敗したら paths[1] を指定して探し……というように、リンク可能なライブラリを探索します。

上記の探索でライブラリ lib を発見できた場合は lib を $libs に追加し、見つかったパスを $LDFLAGS に追加して true を返します。指定されたすべてのパスを検査してもライブラリ lib が見つからないときは、変数を変更せず false を返します。

paths を指定しないときは Kernel#have_library と同じ動作です。

[PARAM] lib:
ライブラリ名を指定します。
[PARAM] func:
関数名を指定します。 nil または空文字列を指定した場合は "main" になります。
[PARAM] paths:
ライブラリを検索するパスを文字列の配列で指定します。
find_type(type, opt, *headers) -> Array[permalink][rdoc][edit] [added by mkmf]
find_type(type, opt, *headers) { ... } -> Array [added by mkmf]

静的な型 type がシステムに存在するかどうか検査します。

[PARAM] type:
検査したい型の名前を指定します。
[PARAM] opt:
コンパイラに渡す追加のオプションを指定します。
[PARAM] headers:
追加のヘッダを指定します。

[SEE_ALSO] Kernel#have_type

gem(gem_name, *version_requirements) -> boolRuby 1.9.3 から[permalink][rdoc][edit] [added by rubygems]

$LOAD_PATH に Ruby Gem を追加します。

指定された Gem をロードする前にその Gem が必要とする Gem をロードします。バージョン情報を省略した場合は、最も高いバージョンの Gem をロードします。指定された Gem やその Gem が必要とする Gem が見つからなかった場合は Gem::LoadError が発生します。

バージョンの指定方法に関しては Gem::Version を参照してください。

rubygems ライブラリがライブラリバージョンの衝突を検出しない限り、 gem メソッドは全ての require メソッドよりも前に実行されます。

環境変数 GEM_SKIP

特定の Gem をロードしないようにするために環境変数 GEM_SKIP を定義できます。特定の Gem がまだインストールされていないという状況を試すために使用できます。

例 
GEM_SKIP=libA:libB ruby-I../libA -I../libB ./mycode.rb
[PARAM] gem:
Gem の名前の文字列か、Gem の依存関係を Gem::Dependency のインスタンスで指定します。
[PARAM] version_requirements:
必要とする gem のバージョンを指定します。
[RETURN]
Gem がロードできた場合は true を返します。ロードできなかった場合は false を返します。
[EXCEPTION] Gem::LoadError:
指定された Gem やその Gem が必要とする Gem が見つからなかった場合に発生します。ただし、環境変数 GEM_SKIP に指定されている Gem に関してはこの例外は発生しません。

[SEE_ALSO] Gem::Version

have_devel? -> bool[permalink][rdoc][edit] [added by mkmf]

開発環境がインストールされているかどうか検査するために何もしない実行ファイルを作成しようと試みます。成功した場合は、真を返します。失敗した場合は、偽を返します。

have_framework(framework) -> boolRuby 1.9.3 から[permalink][rdoc][edit] [added by mkmf]
have_framework(framework) { ... } -> bool [added by mkmf]

フレームワーク framework がシステムに存在するかどうか検査します。

フレームワーク framework がシステムに存在する場合は、グローバル変数 $defs に "-DHAVE_FRAMEWORK_framework" を追加し、真を返します。また、グローバル変数 $LDFLAGS に "-framework #{framework}" を追加します。 フレームワーク framework がシステムに存在しない場合は、偽を返します。

例えば、 

require 'mkmf'
p have_framework('Ruby') # => true

である場合、HAVE_FRAMEWORK_RUBY というプリプロセッサマクロをコンパイラに渡します。

[PARAM] framework:
フレームワークの名前を指定します。
have_func(func, headers = nil) -> bool[permalink][rdoc][edit] [added by mkmf]
have_func(func, headers = nil) { ... } -> bool [added by mkmf]

関数 func がシステムに存在するかどうかを検査します。

関数 func が存在すれば $defs に "-DHAVE_func" (func は大文字に変換されます) を追加して true を返します。関数 func が見つからないときはグローバル変数を変更せず false を返します。

[PARAM] func:
関数名を指定します。
[PARAM] headers:
関数 func を使用するのに必要なヘッダファイル名を指定します。これは関数の型をチェックするためではなく、関数が実際にはマクロで定義されている場合などのために使用します。
have_header(header, preheaders = nil) -> bool[permalink][rdoc][edit] [added by mkmf]
have_header(header, preheaders = nil) { ... } -> bool [added by mkmf]

ヘッダファイル header がシステムに存在するかどうか検査します。

ヘッダファイル header が存在する場合は、グローバル変数 $defs に "-DHAVE_header" を追加して true を返します。ヘッダファイル header が存在しない場合は $defs は変更せず false を返します。

[PARAM] header:
検査したいヘッダファイルを指定します。
[PARAM] preheaders:
ヘッダファイルを検査する前に読み込んでおくヘッダファイルを指定します。
have_library(lib, func = nil, headers = nil) -> bool[permalink][rdoc][edit] [added by mkmf]
have_library(lib, func = nil, headers = nil) { ... } -> bool [added by mkmf]

ライブラリ lib がシステムに存在し、関数 func が定義されているかどうかをチェックします。チェックが成功すれば $libs に lib を追加し true を返します。チェックが失敗したら false を返します。

[PARAM] lib:
ライブラリの名前を指定します。
[PARAM] func:
検査する関数名を指定します。 nil または空文字列のときは、"main" になります。
[PARAM] headers:
追加のヘッダファイルを指定します。
have_macro(macro, headers = nil, opt = "") -> bool[permalink][rdoc][edit] [added by mkmf]
have_macro(macro, headers = nil, opt = "") { ... } -> bool [added by mkmf]

与えられた macro が共通のヘッダファイルか headers に定義されている場合は真を返します。そうでない場合は偽を返します。

[PARAM] macro:
マクロの名前を指定します。
[PARAM] headers:
追加のヘッダファイルを指定します。
[PARAM] opt:
C コンパイラに渡すコマンドライン引数を指定します。
have_struct_member(type, member, headers = nil) -> bool[permalink][rdoc][edit] [added by mkmf]
have_struct_member(type, member, headers = nil) { ... } -> bool [added by mkmf]

member というメンバを持つ構造体 type がシステムに存在するかどうか検査します。

member というメンバを持つ構造体 type がシステムに存在する場合は、グローバル変数 $defs に "-DHAVE_type_member" を追加し、真を返します。 member というメンバを持つ構造体 type が存在しない場合は、偽を返します。

例えば 

require 'mkmf'
p have_struct_member('struct foo', 'bar') # => true

である場合、HAVE_STRUCT_FOO_BAR というプリプロセッサマクロをコンパイラに渡します。また、後方互換性のために HAVE_ST_BAR というプリプロセッサマクロも定義します。

[PARAM] type:
検査したい構造体の名前を指定します。
[PARAM] member:
検査したい構造体のメンバの名前を指定します。
[PARAM] headers:
追加のヘッダファイルを指定します。
have_type(type, headers = nil, opt = "") -> bool[permalink][rdoc][edit] [added by mkmf]
have_type(type, headers = nil, opt = "") { ... } -> bool [added by mkmf]

静的な型 type がシステムに存在するかどうか検査します。

型 type がシステムに存在する場合は、グローバル変数 $defs に "-DHAVE_type" を追加し、真を返します。型 type がシステムに存在しない場合は、偽を返します。

例えば、 

require 'mkmf'
p have_type('foo') # => true

である場合、HAVE_TYPE_FOO をというプリプロセッサマクロをコンパイラに渡します。

[PARAM] type:
検査したい型の名前を指定します。
[PARAM] headers:
追加のヘッダを指定します。
[PARAM] opt:
コンパイラに渡す追加のオプションを指定します。
have_var(var, headers = nil) -> bool[permalink][rdoc][edit] [added by mkmf]
have_var(var, headers = nil) { ... } -> bool [added by mkmf]

変数 var がシステムに存在するかどうか検査します。

変数 var がシステムに存在する場合は、グローバル変数 $defs に "-DHAVE_var" を追加し、真を返します。変数 var がシステムに存在しない場合は、偽を返します。

例えば、 

require 'mkmf'
p have_var('foo') # => true

である場合、HAVE_FOO というプリプロセッサマクロをコンパイラに渡します。

[PARAM] var:
検査したい変数名を指定します。
[PARAM] headers:
追加のヘッダを指定します。
$hdrdir -> String[permalink][rdoc][edit] [added by mkmf]

Ruby のヘッダファイル ruby.h が存在するディレクトリです。通常は $archdir と同じで、"/usr/local/lib/ruby/バージョン/arch" です。

help -> ()[permalink][rdoc][edit] [added by un]

ヘルプメッセージを表示します。 

ruby -run -e help [COMMAND]
httpd -> ()Ruby 1.9.3 から[permalink][rdoc][edit] [added by un]

WEBrick HTTP server を起動します。 

ruby -run -e httpd -- [OPTION] [DocumentRoot]

--bind-address=ADDR         バインドアドレスを指定します
--port=NUM                  ポート番号を指定します
--max-clients=MAX           同時接続数の最大値
--temp-dir=DIR              一時ディレクトリを指定します
--do-not-reverse-lookup     逆引きを無効にします
--request-timeout=SECOND    リクエストがタイムアウトする秒数を指定します
--http-version=VERSION      HTTP version
--server-name=NAME          サーバーのホスト名を指定します
--server-software=NAME      サーバーの名前とバージョンを指定します
--ssl-certificate=CERT      サーバーの SSL 証明書ファイルを指定します
--ssl-private-key=KEY       サーバーの SSL 証明書の秘密鍵を指定します
-v                          詳細表示
import(*filenames)Ruby 1.9.3 から[permalink][rdoc][edit] [added by rake]

分割された Rakefile をインポートします。

インポートされたファイルは、現在のファイルが完全にロードされた後でロードされます。このメソッドはインポートするファイルのどこで呼び出されてもかまいません。また、インポートされるファイル内に現れるオブジェクトはインポートするファイル内で定義されているオブジェクトに依存していてもかまいません。

このメソッドは依存関係を定義したファイルを読み込むのによく使われます。

[PARAM] filenames:
インポートする Rakefile を指定します。
例 
import ".depend", "my_rules"
install -> ()[permalink][rdoc][edit] [added by un]

ファイルをコピーし、その属性を設定します。 

ruby -run -e install -- [OPTION] SOURCE DEST

-p          ファイルのアクセス時刻と修正時刻を保持します。
-m          chmod と同じようにファイルのパーミッションを設定します。
-v          詳細表示

[SEE_ALSO] install(1)

install_files(mfile, ifiles, map = nil, srcprefix = nil) -> [][permalink][rdoc][edit] [added by mkmf]

このメソッドは create_makefile, install_rb が使用します。内部用のメソッドです。

[PARAM] mfile:
Makefile を表す File のインスタンスです。
[PARAM] ifiles:
インストールするファイルのリストを指定します。
[PARAM] map:
???
[PARAM] srcprefix:
ソースディレクトリを指定します。
install_rb(mfile, dest, srcdir = nil) -> Array[permalink][rdoc][edit] [added by mkmf]

このメソッドは create_makefile が使用します。内部用のメソッドです。

ディレクトリ srcdir/lib 配下の Ruby スクリプト (*.rb ファイル) を dest にインストールするための Makefile 規則を mfile に出力します。

srcdir/lib のディレクトリ構造はそのまま dest 配下に反映されます。

[PARAM] mfile:
Makefile を表す File のインスタンスです。
[PARAM] dest:
インストールする先のディレクトリを指定します。
[PARAM] srcdir:
ソースディレクトリを指定します。
j(*objects) -> nilRuby 1.9.3 から[permalink][rdoc][edit] [added by json]

与えられたオブジェクトを JSON 形式の文字列で標準出力に一行で出力します。

[PARAM] objects:
JSON 形式で出力したいオブジェクトを指定します。
例 
require "json"

p j([1,2,{"name" => "tanaka","age" => 19}])
# => [1,2,{"name":"tanaka","age":19}]

[SEE_ALSO] Kernel?.p

jj(*objects) -> nilRuby 1.9.3 から[permalink][rdoc][edit] [added by json]

与えられたオブジェクトを JSON 形式の文字列で標準出力に人間に読みやすく整形して出力します。

[PARAM] objects:
JSON 形式で出力したいオブジェクトを指定します。
例 
require "json"

p jj([1,2,{"name" => "tanaka","age" => 19}])
# => [
#      1,
#      2,
#      {
#        "name": "tanaka",
#        "age": 19
#      }
#    ]

[SEE_ALSO] Kernel?.pp

$libdir -> String[permalink][rdoc][edit] [added by mkmf]

Ruby のライブラリを置くディレクトリです。通常は "/usr/local/lib/ruby/バージョン" です。

libpathflag(libpath = $DEFLIBPATH|$LIBPATH) -> String[permalink][rdoc][edit] [added by mkmf]

与えられた libpath を -L 付きの文字列に変換して返します。

[PARAM] libpath:
LIBPATH に指定する値を指定します。
$libs -> String[permalink][rdoc][edit] [added by mkmf]

拡張ライブラリをリンクするときに一緒にリンクされるライブラリを指定する文字列です。

この変数の値は、例えば 

"-lfoo -lbar"

のような形式の文字列です。

Kernel#have_library または Kernel#find_library を呼び出すと、その検査結果が間に空白をはさみつつ $libs に連結されます。

実際にリンクする際に使用するコマンドを返します。

[PARAM] ldflags:
LDFLAGS に追加する値を指定します。
[PARAM] opt:
LIBS に追加する値を指定します。
[PARAM] libpath:
LIBPATH に指定する値を指定します。

[SEE_ALSO] RbConfig.expand

ln -> ()[permalink][rdoc][edit] [added by un]

ファイルへのリンクを作成します。 

ruby -run -e ln -- [OPTION] TARGET LINK_NAME

-s          ハードリンクの代わりにシンボリックリンクを作成します
-f          LINK_NAME を上書きします
-v          詳細表示

[SEE_ALSO] ln(1)

log_src(src) -> ()[permalink][rdoc][edit] [added by mkmf]

与えられた C プログラムのソースコードをログ出力します。

[PARAM] src:
C プログラムのソースコードを指定します。
merge_libs(*libs) -> [String][permalink][rdoc][edit] [added by mkmf]

[TODO] 使われてない

[PARAM] libs:
???
message(format, *arg) -> nil[permalink][rdoc][edit] [added by mkmf]

Kernel?.printf と同じように標準出力にメッセージを出力します。メッセージ出力後すぐに IO#flush します。

$VERBOSE が真のときは何もしません。

[PARAM] format:
フォーマット文字列です。
[PARAM] arg:
フォーマットされる引数です。

[SEE_ALSO] Kernel?.printf

mkdir -> ()[permalink][rdoc][edit] [added by un]

ディレクトリを作成します。 

ruby -run -e mkdir -- [OPTION] DIR

-p          ディレクトリが存在してもエラーになりません。
            必要であれば親ディレクトリも作成します。
-v          詳細表示

[SEE_ALSO] mkdir(1)

mkmf -> ()Ruby 1.9.3 から[permalink][rdoc][edit] [added by un]

mkmf を使って Makefile を作成します。 

ruby -run -e mkmf -- [OPTION] EXTNAME [OPTION]

-d ARGS     run dir_config
-h ARGS     run have_header
-l ARGS     run have_library
-f ARGS     run have_func
-v ARGS     run have_var
-t ARGS     run have_type
-m ARGS     run have_macro
-c ARGS     run have_const
--vendor    install to vendor_ruby
modified?(target, times) -> Time | nil[permalink][rdoc][edit] [added by mkmf]

target が times の全ての要素よりも新しい場合は target の更新時刻を返します。そうでない場合は nil を返します。target が存在しない場合も nil を返します。

[PARAM] target:
対象のファイル名を指定します。
[PARAM] times:
Time の配列か Time を一つ指定します。
multitask(args) { ... } -> Rake::MultiTaskRuby 1.9.3 から[permalink][rdoc][edit] [added by rake]

事前タスクを並列実行するタスクを定義します。

与えられた事前タスクを実行する順序は不定です。

例 
multitask :deploy => [:deploy_gem, :deploy_rdoc]
mv -> ()[permalink][rdoc][edit] [added by un]

ファイルを移動します (ファイル名を変更します)。 

ruby -run -e mv -- [OPTION] SOURCE DEST

-v          詳細表示

[SEE_ALSO] mv(1)

namespace(name = nil) { ... } -> Rake::NameSpaceRuby 1.9.3 から[permalink][rdoc][edit] [added by rake]

新しい名前空間を作成します。

与えられたブロックを評価する間は、その名前空間を使用します。

例 
ns = namespace "nested" do
  task :run
end
task_run = ns[:run] # find :run in the given namespace.

[SEE_ALSO] Rake::TaskManager#in_namespace

require(path) -> boolRuby 1.9.3 から[permalink][rdoc][edit] [added by rubygems/custom_require]

RubyGems を require すると、Kernel#require が Gem を要求されたときにロードするように置き換えます。

再定義された Kernel#require を呼び出すと以下の事を行います。 Ruby のロードパスに存在するライブラリを指定した場合はそのままロードします。そうではなく、インストールされた Gem ファイルの中から見つかった場合は、その Gem をロードパスに登録します。

[PARAM] path:
ロードしたいライブラリの名前を指定します。
[RETURN]
既にロードされているライブラリを再度ロードしようとした場合は false を返します。そうでない場合は true を返します。
rm -> ()[permalink][rdoc][edit] [added by un]

ファイルやディレクトリを削除します。 

ruby -run -e rm -- [OPTION] FILE

-f          存在しないファイルを無視します
-r          ディレクトリを再帰的にたどってファイルやディレクトリを削除します
-v          詳細表示

[SEE_ALSO] rm(1)

rm_f(*files) -> ()[permalink][rdoc][edit] [added by mkmf]

FileUtils?.rm_f のラッパーメソッドです。

[PARAM] files:
ファイルのリストか、Dir.globで利用できる glob パターンを指定します。最後の要素が Hash の場合は FileUtils?.rm_f の第二引数になります。

[SEE_ALSO] FileUtils?.rm_f, Dir.glob

rm_rf(*files) -> ()[permalink][rdoc][edit] [added by mkmf]

FileUtils?.rm_rf のラッパーメソッドです。

[PARAM] files:
ファイルのリストか、Dir.globで利用できる glob パターンを指定します。最後の要素が Hash の場合は FileUtils?.rm_f の第二引数になります。

[SEE_ALSO] FileUtils?.rm_rf, Dir.glob

rmdir -> ()[permalink][rdoc][edit] [added by un]

空のディレクトリを削除します。 

ruby -run -e rmdir -- [OPTION] DIR

-p          DIR で指定されたディレクトリとその上位ディレクトリを削除します
-v          詳細表示

[SEE_ALSO] rmdir(1)

rule(*args) {|t| ... } -> Rake::TaskRuby 1.9.3 から[permalink][rdoc][edit] [added by rake]

自動的に作成するタスクのためのルールを定義します。

[PARAM] args:
ルールに与えるパラメータを指定します。
例 
rule '.o' => '.c' do |t|
  sh %{cc -o #{t.name} #{t.source}}
end
$sitearchdir -> String[permalink][rdoc][edit] [added by mkmf]

サイト固有でかつマシン固有のライブラリを置くディレクトリです。通常は "/usr/local/lib/ruby/site_ruby/バージョン/arch" です。

$sitelibdir -> String[permalink][rdoc][edit] [added by mkmf]

サイト固有のライブラリを置くディレクトリです。通常は "/usr/local/lib/ruby/site_ruby/バージョン" です。

$srcdir -> String[permalink][rdoc][edit] [added by mkmf]

Ruby インタプリタを make したときのソースディレクトリです。

task(*args) { ... } -> Rake::TaskRuby 1.9.3 から[permalink][rdoc][edit] [added by rake]

Rake タスクを定義します。

[PARAM] args:
タスク名と依存タスクを指定します。
例 
task :clobber => [:clean] do
  rm_rf "html"
end

[SEE_ALSO] Rake::Task.define_task

time(msg, width = 25) { ... } -> objectRuby 1.9.3 から[permalink][rdoc][edit] [added by rubygems/timer]

与えられたブロックの実行時間を計測して表示します。

[PARAM] msg:
表示するメッセージを指定します。
[PARAM] width:
表示する幅を指定します。
[RETURN]
ブロックの実行結果を返します。
$topdir -> String[permalink][rdoc][edit] [added by mkmf]

拡張ライブラリを make するためのヘッダファイル、ライブラリ等が存在するディレクトリです。通常は $archdir と同じで、"/usr/local/lib/ruby/バージョン/arch" です。

touch -> ()[permalink][rdoc][edit] [added by un]

ファイルのアクセス時刻と修正時刻を現在の時刻に変更します。 

ruby -run -e touch -- [OPTION] FILE

-v          詳細表示

[SEE_ALSO] touch(1)

try_compile(src, opt = "", *opts) -> bool[permalink][rdoc][edit] [added by mkmf]
try_compile(src, opt = "", *opts) { ... } -> bool [added by mkmf]

与えられた C のソースコードがコンパイルできた場合は真を返します。コンパイルできなかった場合は偽を返します。

ブロックを与えた場合、そのブロックはコンパイル前に評価されます。ブロック内でソースコードを変更できます。

[PARAM] src:
C のソースコードを指定します。
[PARAM] opt:
コンパイラに渡すオプションを指定します。 $CFLAGS もコンパイラには渡されます。
try_constant(const, headers = nil, opt = "") -> Integer | nil[permalink][rdoc][edit] [added by mkmf]
try_constant(const, headers = nil, opt = "") { ... } -> Integer | nil [added by mkmf]

定数 const がシステムに存在するかどうか検査します。 Kernel#have_const を使ってください。

[PARAM] const:
C 言語の定数名を指定します。
[PARAM] headers:
追加のヘッダファイルを指定します。
[PARAM] opt:
コンパイラに渡すオプションを指定します。 $CFLAGS もコンパイラには渡されます。
[RETURN]
定数 const がシステムに存在する場合はその値を返します。定数 const がシステムに存在しない場合は nil を返します。
try_cpp(src, opt = "", *opts) -> bool[permalink][rdoc][edit] [added by mkmf]
try_cpp(src, opt = "", *opts) { ... } -> bool [added by mkmf]

C プログラムのソースコード src をプリプロセスします。

$CPPFLAGS, $CFLAGS の値もプリプロセッサにコマンドライン引数として渡します。

このメソッドはヘッダファイルの存在チェックなどに使用します。

[PARAM] src:
C プログラムのソースコードを指定します。
[PARAM] opt:
プリプロセッサにコマンドライン引数として渡す値を指定します。
[RETURN]
問題なくプリプロセスできたら true を返します。プリプロセスに失敗したら false を返します。
例 
require 'mkmf'
if try_cpp("#include <stdio.h>")
  $stderr.puts "stdio.h exists"
end
try_do(src, command, *opts) -> ()[permalink][rdoc][edit] [added by mkmf]
try_do(src, command, *opts) { ... } -> () [added by mkmf]
[PARAM] src:
C プログラムのソースコードを指定します。
[PARAM] command:
コマンドを指定します。
[PARAM] opts:
オプションを Hash で指定します。
[EXCEPTION] RuntimeError:
開発環境がインストールされていない場合に発生します。

[SEE_ALSO] Kernel#xsystem

try_func(func, libs, headers = nil) -> bool[permalink][rdoc][edit] [added by mkmf]
try_func(func, libs, headers = nil) { ... } -> bool [added by mkmf]

関数 func がシステムに存在するかどうか検査します。 Kernel#have_func を使ってください。

[PARAM] func:
関数名を指定します。
[PARAM] libs:
ライブラリの名前を指定します。
[PARAM] headers:
関数 func を使用するのに必要なヘッダファイル名を指定します。これは関数の型をチェックするためではなく、関数が実際にはマクロで定義されている場合などのために使用します。
try_link(src, opt = "", *options) { ... } -> bool [added by mkmf]

C プログラムのソースコード src をコンパイル、リンクします。

このメソッドは $CFLAGS と $LDFLAGS の値もコンパイラまたはリンカに渡します。

問題なくリンクできたら true を返します。コンパイルとリンクに失敗したら false を返します。

[PARAM] src:
C プログラムのソースコードを指定します。
[PARAM] opt:
リンカにコマンド引数として渡す値を指定します。
例 
require 'mkmf'
if try_link("int main() { sin(0.0); }", '-lm')
  $stderr.puts "sin() exists"
end
try_run(src, opt = "") -> bool | nil[permalink][rdoc][edit] [added by mkmf]
try_run(src, opt = "") { ... } -> bool | nil [added by mkmf]

与えられたソースコードが、コンパイルやリンクできるかどうか検査します。

以下の全ての検査に成功した場合は、真を返します。そうでない場合は偽を返します。

  • src が C のソースとしてコンパイルできるか
  • 生成されたオブジェクトが依存しているライブラリとリンクできるか
  • リンクしたファイルが実行可能かどうか
  • 実行ファイルがきちんと存在しているかどうか

ブロックを与えた場合、そのブロックはコンパイル前に評価されます。ブロック内でソースコードを変更できます。

[PARAM] src:
C のソースコードを指定します。
[PARAM] opt:
リンカに渡すオプションを指定します。 $CFLAGS, $LDFLAGS もリンカには渡されます。
[RETURN]
実行ファイルが存在する場合は true を返します。そうでない場合は false を返します。プリプロセス、コンパイル、リンクのいずれかの段階で失敗した場合は nil を返します。
try_static_assert(expr, headers = nil, opt = "") -> bool[permalink][rdoc][edit] [added by mkmf]
try_static_assert(expr, headers = nil, opt = "") { ... } -> bool [added by mkmf]

[TODO] ???

...

[PARAM] expr:
C 言語の式を指定します。
[PARAM] headers:
追加のヘッダファイルを指定します。
[PARAM] opt:
コンパイラに渡すオプションを指定します。 $CFLAGS もコンパイラには渡されます。
try_type(type, headers = nil, opt = "") -> bool[permalink][rdoc][edit] [added by mkmf]
try_type(type, headers = nil, opt = "") { ... } -> bool [added by mkmf]

Kernel#have_type を使ってください。

[PARAM] type:
検査したい型の名前を指定します。
[PARAM] headers:
追加のヘッダを指定します。
[PARAM] opt:
コンパイラに渡す追加のオプションを指定します。
try_var(var, headers = nil) -> bool[permalink][rdoc][edit] [added by mkmf]
try_var(var, headers = nil) { ... } -> bool [added by mkmf]

Kernel#have_var を使ってください。

[PARAM] var:
検査したい変数名を指定します。
[PARAM] headers:
追加のヘッダを指定します。
wait_writable -> ()Ruby 1.9.3 から[permalink][rdoc][edit] [added by un]

ファイルが書き込み可能になるまで待ちます。 

ruby -run -e wait_writable -- [OPTION] FILE

-n RETRY    リトライ回数
-w SEC      リトライごとに待つ秒数
-v          詳細表示
with_config(config, default = nil) -> bool | String[permalink][rdoc][edit] [added by mkmf]
with_config(config, default = nil) {|config, default| ... } -> bool | String [added by mkmf]

configure のオプションを検査します。

configure のオプションに --with-<config> が指定された場合は真を返します。--without-<config> が指定された場合は偽を返します。どちらでもない場合は default を返します。

これはデバッグ情報などのカスタム定義を、追加するのに役立ちます。

[PARAM] config:
configure のオプションの名前を指定します。
[PARAM] default:
デフォルト値を返します。
例 
require 'mkmf'
if with_config("debug")
   $defs.push("-DOSSL_DEBUG") unless $defs.include? "-DOSSL_DEBUG"
end
with_werror(opt, opts = nil) {|opt| ... } -> object[permalink][rdoc][edit] [added by mkmf]
with_werror(opt, opts = nil) {|opt, opts| ... } -> object [added by mkmf]

[TODO] 内部用？

???

[PARAM] opt:
????
[PARAM] opts:
????
[RETURN]
ブロックを評価した結果を返します。
xmp(exps, bind = nil) -> XMP[permalink][rdoc][edit] [added by irb/xmp]

引数 exps で指定されたRuby のソースコードとその実行結果を、標準出力に行ごとに交互に表示します。

[PARAM] exps:
評価するRuby のソースコードを文字列で指定します。
[PARAM] bind:
Binding オブジェクトを指定します。省略した場合は、最後に実行した XMP#puts、Kernel#xmp の Binding を使用します。まだ何も実行していない場合は Object::TOPLEVEL_BINDING を使用します。
xpopen(command, *mode) -> IO[permalink][rdoc][edit] [added by mkmf]
xpopen(command, *mode) { ... } -> object [added by mkmf]

command を表示してから IO.popen の実行します。

[PARAM] command:
コマンド名を指定します。
[PARAM] mode:
オープンする IO ポートのモードを指定します。mode の詳細は Kernel?.open 参照して下さい。

[SEE_ALSO] IO.popen

xsystem(command, opts = nil) -> ()[permalink][rdoc][edit] [added by mkmf]

Kernel?.system と同じですが、コマンドの出力は(標準出力、標準エラー出力ともに)ログファイルに出力します。ログファイル名は mkmf.log です。

[PARAM] command:
コマンドを指定します。
[PARAM] opts:
オプションを Hash で指定します。 :werror というキーに真を指定すると

[SEE_ALSO] Kernel?.system

y(*objects) -> nil[permalink][rdoc][edit] [added by psych]

objects を YAML document として標準出力に出力します。

このメソッドは irb 上でのみ定義されます。

[PARAM] objects:
YAML document に変換する Ruby のオブジェクト

特殊変数

$! -> Exception | nil[permalink][rdoc][edit]

最後に例外が発生したときの Exception オブジェクトです。該当する例外がないときは nil です。

Kernel?.raise によって設定されます。

この変数はスレッドローカル、読み取り専用です。

$" -> [String][permalink][rdoc][edit]
$LOADED_FEATURES -> [String]

Kernel?.require でロードされたファイル名を含む配列です。

Kernel?.require で同じファイルを複数回ロードしないようにするためのロックとして使われます。

この変数はグローバルスコープです。

$$ -> Integer[permalink][rdoc][edit]

現在実行中の Ruby プロセスのプロセス ID です。 Process?.pid と同じです。

この変数はグローバルスコープです。

$& -> String | nil[permalink][rdoc][edit]

現在のスコープで最後に成功した正規表現のマッチでマッチした文字列です。最後のマッチが失敗していた場合には 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][edit]

現在のスコープで最後に成功した正規表現のマッチでマッチした部分より後ろの文字列です。最後のマッチが失敗していた場合には 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][edit]

Rubyスクリプトに与えられた引数を表す配列です。組み込み定数 Object::ARGV の別名です。

Ruby 自身に対する引数は取り除かれています。

この変数はグローバルスコープです。

$+ -> String | nil[permalink][rdoc][edit]

現在のスコープで最後に成功した正規表現のマッチでマッチした中で最後の括弧に対応する部分文字列です。

最後のマッチが失敗していた場合には nil。いくつかある選択型のパターンのどれがマッチしたのか分からない時に便利です。

この変数はローカルスコープかつスレッドローカルです。

$, -> String | nil[permalink][rdoc][edit]

デフォルトの出力フィールド区切り文字列です。 Array#join で引数を省略した場合と、 Kernel?.print の各引数の間で出力されます。

デフォルト値は nil で、空文字列と同じ結果になります。

Ruby 2.7からは nil 以外に変更することは非推奨になったため、 nil 以外を代入すると警告がでるようになりました。

この変数はグローバルスコープです。

$/ -> String | nil[permalink][rdoc][edit]
$-0 -> String | nil

入力レコード区切りを表す文字列です。 awk の RS 変数のように働きます。

Kernel?.gets のような「行」単位の読み込みメソッドが「行」の区切りとして使用します。 Rubyがコマンドオプション -0 付きで起動されたときには -0 で指定された値が既定値となります。そうでないとき、既定値は "\n" です。

この変数に nil を設定すると読み込みメソッドはファイル全体を一度に読み込みます。空文字列 "" を設定するとパラグラフモードとみなされ、 2 つ以上連続した改行が「行」の区切りになります。

$/ には正規表現は使えません。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$; -> Regexp | String | nil[permalink][rdoc][edit]
$-F -> Regexp | String | nil

String#split で引数を省略した場合の区切り文字です。

Ruby 2.7からは nil 以外に変更することは非推奨になったため、 nil 以外を代入すると警告がでるようになりました。

nilを設定すると特殊な分割を行います。詳細は String#split を参照してください。

コマンドラインオプション -F を指定して Ruby を起動した場合、初期値は -F で指定した値です。それ以外の時には初期値は nil です。

$; には任意のオブジェクトを代入できます。ただし、String#split の仕様変更を考慮すると常に正規表現を指定すべきです。

Ruby のバージョンによらず動作するプログラムを書くときは $; に頼らないコードを書くべきです。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$: -> [String][permalink][rdoc][edit]
$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 環境では ruby.dll の位置からの相対で決まります。

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 $:'

とします。

$LOAD_PATH の特異メソッドとして resolve_feature_path が定義されています。 require を呼んだときに読み込まれるファイルを特定できます。 

p $LOAD_PATH.resolve_feature_path('set')
# => [:rb, "/build-all-ruby/2.7.0/lib/ruby/2.7.0/set.rb"]

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動, 環境変数

$KCODE -> object[permalink][rdoc][edit]
$-K -> object

通常のグローバル変数です。

Ruby 2.7 以前は特殊変数でしたが、Ruby 3.0 から通常のグローバル変数になりました。任意のオブジェクトを代入して nil 以外の値に設定できます。

[SEE_ALSO] Rubyの起動

$-W -> 0 | 1 | 2Ruby 1.9.3 から[permalink][rdoc][edit]

コマンドラインオプション -W を指定したとき、そのコマンドライン引数の値が設定されます。

つまり、$VERBOSE の値によって以下の値を返します。

nil

0。警告を出力しない。

false

1。重要な警告のみ出力する。(デフォルト)

true

2。すべての警告を出力する。

この変数には代入できません。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$-a -> bool[permalink][rdoc][edit]

自動 split モードを表すフラグです。

コマンドラインオプション -a を使ったとき true に設定されます。この変数には代入できません。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$DEBUG -> bool[permalink][rdoc][edit]
$-d -> bool

この値が真のときはインタプリタがデバッグモードになります。

コマンドラインオプション -d でセットされます。スクリプトから代入することもできます。

デバッグモードでは、通常モードに比べて以下の違いがあります。

  • 通常時はいずれかのスレッドが例外によって終了しても 他のスレッドは実行を続けますが、デバッグモードでは いずれかのスレッドが例外によって終了した時に インタプリタ全体が中断されるようになります。 Thread.abort_on_exception を true にセットするのと同じ効果です。
  • Thread.abort_on_exception= の効果がなくなります。
  • 例外を捕捉しているかどうかに関係なく、 例外が発生した時点で $stderr にそれが出力されます。 スクリプトの処理は続行されます。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$-i -> String | nil[permalink][rdoc][edit]

in-place 置換モードで用いられます。

コマンドラインオプション -i を指定したとき、空文字列になります。 -i オプションに拡張子を渡した場合にはその拡張子が文字列として格納されます。

-i オプションが指定されていない時の値は nil です。

スクリプト内で $-i に代入することもでき、その場合は Object::ARGV の次のファイルを読み込み始めるタイミングで in-place 置換を開始します。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$-l -> bool[permalink][rdoc][edit]

コマンドラインオプション -l を指定したとき true に設定されます。この変数には代入できません。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$-p -> bool[permalink][rdoc][edit]

コマンドラインオプション -p を指定したとき true に設定されます。この変数には代入できません。

この変数はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$VERBOSE -> bool | nil[permalink][rdoc][edit]
$-v -> bool | nil
$-w -> bool | nil

冗長メッセージフラグです。Rubyインタプリタへのコマンドラインオプション -v でセットされます。

警告レベルは三段階あり、それぞれ以下の通りです。

nil

警告を出力しない

false

重要な警告のみ出力 (デフォルト)

true

すべての警告を出力する

$VERBOSE に nil, false 以外を代入すると値は true になります。

$VERBOSE の値はコマンドラインオプション -W でも設定できます。 -W0 オプションで nil、 -W1 オプションで false、 -W2, -W オプションで true が設定されます。 -d, -v, -w の各オプションによっても true が設定されます。

$VERBOSE はグローバルスコープです。

[SEE_ALSO] Rubyの起動

$. -> Integer[permalink][rdoc][edit]

いずれかの IO オブジェクトが最後に読んだ行の行番号です。 Object::ARGF などの IO 互換のオブジェクトも $. を更新します。

IO からの読み込みが起きるタイミングが予測不能であるような複雑なプログラムでは使用すべきではありません。特に、マルチスレッドプログラムではスレッド間で競合を起こす可能性があります。そのような場合には、 IO#lineno を使用してください。

この変数はグローバルスコープです。 Ruby起動時の初期値は 0 です。

$0 -> String[permalink][rdoc][edit]
$PROGRAM_NAME -> String

現在実行中の Ruby スクリプトの名前を表す文字列です。

OS と Ruby のバージョンによっては、この変数に代入すると ps(1) の出力が変化します。この機能はプログラムの現在の状態を表示するのに便利です。

この変数はグローバルスコープです。

$1 -> String | nil[permalink][rdoc][edit]
$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 は任意の正整数にできますが、巨大な数に対しては常に nil を返し、警告を表示します。

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

すべての引数または標準入力で構成される仮想ファイルです。定数 Object::ARGF の別名です。

この変数はグローバルスコープ、読み取り専用です。

$= -> bool[permalink][rdoc][edit]

過去との互換性のために残されていますが、もはや何の意味もありません。

値は常に false です。代入しても無視されます。

この変数はグローバルスコープです。

例 
$= = true # => warning: variable $= is no longer effective; ignored
p $=      # => warning: variable $= is no longer effective
          #    false
$> -> object[permalink][rdoc][edit]
$stdout -> object

標準出力です。

組み込み関数 Kernel?.print、Kernel?.puts や Kernel?.p などのデフォルトの出力先となります。初期値は Object::STDOUT です。コマンドラインオプションオプション -i を指定した場合には読み込み元と同じ名前のファイルを表します。

$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][edit]

このスレッドで最後に終了した子プロセスのステータスです。

Process::Status オブジェクトが入っています。子プロセスの終了時ステータスは Process::Status#exitstatus で得られます。

この変数はスレッドローカルで読み取り専用です。

[SEE_ALSO] Process?.wait

[SEE_ALSO] Process.last_status

$@ -> [String] | nil[permalink][rdoc][edit]

最後に例外が発生した時のバックトレースを表す配列です。 Kernel?.raise によって設定されます。

配列の各要素はメソッドの呼び出し位置を示す文字列で形式は 

"filename:line"

または 

"filename:line:in 'methodname'"

です。これは Kernel?.caller が返す値と同じ形式です。

$@ へ値を代入するときは、$! が nil であってはいけません。 $@ の値は、$!.backtrace の値と同じです。また、$@ への代入は $!.set_backtrace 呼び出しと同じです。

文字列の配列でも nil でもない値を代入しようとすると、 TypeError 例外が発生します。

この変数はスレッドローカルです。

$FILENAME -> String[permalink][rdoc][edit]

仮想ファイル Object::ARGF で現在読み込み中のファイル名です。 ARGF.class#filename と同じです。

この変数はグローバルスコープです。

$SAFE -> object[permalink][rdoc][edit]

通常のグローバル変数です。

Ruby 2.7 以前は特殊変数でしたが、Ruby 3.0 から通常のグローバル変数になりました。

$\ -> String | nil[permalink][rdoc][edit]

出力レコード区切りを表す文字列です。 Kernel?.print が最後にこの文字列を出力します。

デフォルトは nil で、何も出力しません。

この変数はグローバルスコープです。

$_ -> String | nil[permalink][rdoc][edit]

最後に 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][edit]

現在のスコープで最後に成功した正規表現のマッチでマッチした部分より前の文字列です。最後のマッチが失敗していた場合には 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][edit]

標準エラー出力です。

Ruby インタプリタが出力するエラーメッセージや警告メッセージ、Kernel?.warn の出力先となります。初期値は Object::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][edit]

標準入力です。

自プロセスの標準入力をリダイレクトしたいときは $stdin に代入すれば十分です。

例 
# 標準入力の入力元 /tmp/foo に変更
$stdin = File.open("/tmp/foo", "r")
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 を保存する
$stdin.reopen("/tmp/foo")    # $stdin を /tmp/foo にリダイレクトする
gets                         # /tmp/foo から入力
$stdin.reopen stdin_old      # 元に戻す

$stdin はグローバルスコープです。

$~ -> MatchData | nil[permalink][rdoc][edit]

現在のスコープで最後に成功したマッチに関する 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"