class Time + Comparable + Object
クラスの継承リスト: Time < Comparable < Object < Kernel
要約
時刻を表すクラスです。
Time.now は現在の時刻を返します。 File.mtime などが返すファイルのタイムスタンプは Time オブジェクトです。
Time オブジェクトは時刻を起算時からの経過秒数で保持しています。 起算時は協定世界時(UTC、もしくはその旧称から GMT とも表記されます) の 1970年1月1日午前0時です。なお、うるう秒を勘定するかどうかはシステムに よります。
現在の Unix システムでの最大時刻は、 協定世界時の2038年1月19日午前3時14分7秒 です。
Time オブジェクトが格納可能な時刻の範囲は環境によって異なります。 範囲の下限としては、上記起算時からの経過秒数として 0 および正数しか 受け付けない環境もあれば、負数も受け付ける環境もあります。 また、範囲の上限としては、上記の Unix システムでの最大時刻を越えて 64bit 値の範囲の経過秒数を受け付ける環境もあります。 さらに、他に特定の時点を越える時刻の値を受け付けない環境もあります。 Time オブジェクトを生成する各メソッドで、それぞれの環境での範囲外の 時刻を格納しようとした場合は例外が発生します。
また、Time オブジェクトは協定世界時と地方時のどちらのタイムゾー ンを使用するかのフラグを内部に保持しています。 ただし、この情報は Marshal.#dump では保存されず、Marshal.#load で読み込んだ Time オブジェクトのタイムゾーンは常に地方時になりま す。
p Marshal.load(Marshal.dump(Time.now.gmtime)).zone # => "JST"
time ライブラリによって、Time.parse, Time.rfc2822, Time.httpdate, Time.iso8601 等が拡張されます。
localtime(3) も参照しください。
C 言語との違いに注意
C 言語の tm 構造体とは異なり、month は 1 月に対 して 1 を返し、year は 1998 年に対して 1998 を返します。また、 yday は 1 から数えます。
特異メソッド
at(time) -> Time
-
time で指定した時刻の Time オブジェクトを返します。
引数が数値の場合、生成された Time オブジェクトのタイムゾーンは地方時となります。
- [PARAM] time:
- Time オブジェクト、もしくは起算時からの経過秒数を表わす数値で指定します。
at(time, usec) -> Time
-
time + (usec/1000000) の時刻を表す Time オブジェクトを返します。 浮動小数点の精度では不十分な場合に使用します。
生成された Time オブジェクトのタイムゾーンは地方時となります。
- [PARAM] time:
- 起算時からの経過秒数を表わす整数を指定します。
- [PARAM] usec:
- マイクロ秒を整数で指定します。
gm(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time
utc(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time
-
引数で指定した協定世界時の Time オブジェクトを返します。
第2引数以降に nil を指定した場合の値はその引数がとり得る最小の値です。
- [PARAM] year:
- 年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。 ただし、0 以上 38 以下の整数が与えられた場合は、2000年代の下2桁だと解釈します。 69 以上 138 以下の整数が与えられた場合は、1900 にその数を足した年だと解釈されます。
- [PARAM] mon:
- 1(1月)から 12(12月)の範囲の整数または文字列で指定します。 英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
- [PARAM] day:
- 日を 1 から 31 までの整数か文字列で指定します。
- [PARAM] hour:
- 時を 0 から 23 までの整数か文字列で指定します。
- [PARAM] min:
- 分を 0 から 59 までの整数か文字列で指定します。
- [PARAM] sec:
- 秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
- [PARAM] usec:
- マイクロ秒を整数か文字列で指定します。
- [EXCEPTION] ArgumentError:
- 与えられた引数の範囲が valid でない場合に発生します。
p Time.gm(2000, 1, 1) #=> Sat Jan 01 00:00:00 UTC 2000
gm(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time
utc(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time
-
引数で指定した協定世界時の Time オブジェクトを返します。
引数の順序は Time#to_a と全く同じです。 引数 wday, yday, zone に指定した値は無視されます。 引数に nil を指定した場合の値はその引数がとり得る最小の値です。
- [PARAM] sec:
- 秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
- [PARAM] min:
- 分を 0 から 59 までの整数か文字列で指定します。
- [PARAM] hour:
- 時を 0 から 23 までの整数か文字列で指定します。
- [PARAM] mday:
- 日を 1 から 31 までの整数か文字列で指定します。
- [PARAM] mon:
- 1(1月)から 12(12月)の範囲の整数か文字列で指定します。 英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
- [PARAM] year:
- 年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。 ただし、0 以上 38 以下の整数が与えられた場合は、2000年代の下2桁だと解釈します。 69 以上 138 以下の整数が与えられた場合は、1900 にその数を足した年だと解釈されます。
- [PARAM] wday:
- 無視されます。
- [PARAM] yday:
- 無視されます。
- [PARAM] isdst:
- 指定した日時が夏時間(Daylight Saving Time)なら true を指定します。 そうでないなら、false を指定します。
- [PARAM] zone:
- 無視されます。
- [EXCEPTION] ArgumentError:
- 与えられた引数の範囲が valid でない場合に発生します。
local(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time
mktime(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time
-
引数で指定した地方時の Time オブジェクトを返します。
第2引数以降に nil を指定した場合の値はその引数がとり得る最小の値です。
- [PARAM] year:
- 年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。 ただし、0 以上 38 以下の整数が与えられた場合は、2000年代の下2桁だと解釈します。 69 以上 138 以下の整数が与えられた場合は、1900 にその数を足した年だと解釈されます。
- [PARAM] mon:
- 1(1月)から 12(12月)の範囲の整数または文字列で指定します。 英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
- [PARAM] day:
- 日を 1 から 31 までの整数か文字列で指定します。
- [PARAM] hour:
- 時を 0 から 23 までの整数か文字列で指定します。
- [PARAM] min:
- 分を 0 から 59 までの整数か文字列で指定します。
- [PARAM] sec:
- 秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
- [PARAM] usec:
- マイクロ秒を整数か文字列で指定します。
- [EXCEPTION] ArgumentError:
- 与えられた引数の範囲が valid でない場合に発生します。
p Time.local(2000, 1, 1) #=> Sat Jan 01 00:00:00 +0900 2000
local(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time
mktime(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time
-
引数で指定した地方時の Time オブジェクトを返します。
引数の順序は Time#to_a と全く同じです。 引数 wday, yday, zone に指定した値は無視されます。 引数に nil を指定した場合の値はその引数がとり得る最小の値です。
- [PARAM] sec:
- 秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
- [PARAM] min:
- 分を 0 から 59 までの整数か文字列で指定します。
- [PARAM] hour:
- 時を 0 から 23 までの整数か文字列で指定します。
- [PARAM] mday:
- 日を 1 から 31 までの整数か文字列で指定します。
- [PARAM] mon:
- 1(1月)から 12(12月)の範囲の整数か文字列で指定します。 英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
- [PARAM] year:
- 年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。 ただし、0 以上 38 以下の整数が与えられた場合は、2000年代の下2桁だと解釈します。 69 以上 138 以下の整数が与えられた場合は、1900 にその数を足した年だと解釈されます。
- [PARAM] wday:
- 無視されます。
- [PARAM] yday:
- 無視されます。
- [PARAM] isdst:
- 指定した日時が夏時間(Daylight Saving Time)なら true を指定します。 そうでないなら、false を指定します。
- [PARAM] zone:
- 無視されます。
- [EXCEPTION] ArgumentError:
- 与えられた引数の範囲が valid でない場合に発生します。
new -> Time
now -> Time
-
現在時刻の Time オブジェクトを生成して返します。 タイムゾーンは地方時となります。
new -> Object
-
Objectクラスのインスタンスを生成して返します。
some = Object.new p some #=> #<Object:0x2b696d8>
times -> Struct::Tms
-
このメソッドは obsolete です。
自身のプロセスとその子プロセスが消費したユーザ/システム CPU 時間の積算を Struct::Tms のオブジェクトとして返します。 Struct::Tms は以下のメンバを持つ構造体クラスです。
- utime # user time
- stime # system time
- cutime # user time of children
- cstime # system time of children
時間の単位は秒で、浮動小数点数で与えられます。詳細は times(3) を参照してください。
このメソッドは Process.#times に移動しました。Time.times も使えます が、警告メッセージが出力されます。
インスタンスメソッド
self + other -> Time
-
self より other 秒だけ後の時刻を返します。
- [PARAM] other:
- 自身からの秒数を数値で指定します。
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003 t + (60 * 60 * 24) #=> Thu Apr 10 08:56:03 CDT 2003
self - time -> Float
-
自身と time との時刻の差を Float で返します。単位は秒です。
- [PARAM] time:
- 自身との差を算出したい Time オブジェクトを指定します。
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003 t2 = t + 2592000 #=> Fri May 09 08:56:03 CDT 2003 t2 - t #=> 2592000.0
self - sec -> Time
-
自身より sec 秒だけ前の時刻を返します。
- [PARAM] sec:
- 実数を秒を単位として指定します。
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003 t2 = t + 2592000 #=> Fri May 09 08:56:03 CDT 2003 t2 - 2592000 #=> Wed Apr 09 08:56:03 CDT 2003
self < other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が負の整数を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
self <= other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が負の整数か 0 を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
self <=> other -> -1 | 0 | 1 | nil
-
self と other の時刻を比較します。self の方が大きい場合は 1 を、等しい場合は 0 を、 小さい場合は -1 を返します。比較できない場合は、nil を返します。
- [PARAM] other:
- 自身と比較したい時刻を Time オブジェクトで指定します。
self == other -> bool | nil
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が 0 を返した時に、true を返します。 それ以外を返した場合は、false を返します。
<=> が nil を返した場合は、 nil を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
self == other -> bool
-
オブジェクトと other が等しければ真を返します。
このメソッドは各クラスの性質に合わせて再定義すべきです。 多くの場合、オブジェクトの内容が等しければ真を返すように (同値性を判定するように)再定義されることが期待されています。
デフォルトでは equal? と同じオブジェクト の同一性判定になっています。
- [PARAM] other:
- 比較するオブジェクトです。
p("foo" == "bar") #=> false p("foo" == "foo") #=> true p(4 == 4) #=> true p(4 == 4.0) #=> true
[SEE_ALSO] Object#equal?,Object#eql?
self === other -> bool
-
メソッド Object#== の別名です。 case 式で使用されます。このメソッドは case 式での振る舞いを考慮して、 各クラスの性質に合わせて再定義すべきです。
一般的に所属性のチェックを実現するため適宜再定義されます。
when 節の式をレシーバーとして === を呼び出すことに注意してください。
また Enumerable#grep でも使用されます。
- [PARAM] other:
- 比較するオブジェクトです。
age = 12 result = case age when 0 .. 2 "baby" when 3 .. 6 "little child" when 7 .. 12 "child" when 13 .. 18 "youth" else "adult" end puts result #=> "child" def check arg case arg when /ruby(?!\s*on\s*rails)/i "hit! #{arg}" when String "Instance of String class. But don't hit." else "unknown" end end puts check([]) #=> unknown puts check("mash-up in Ruby on Rails") #=> instance of String class. But not hit... puts check("<Ruby's world>") #=> hit! <Ruby's world>
[SEE_ALSO] Object#==, Range#===, Module#===, Enumerable#grep
self =~ other -> false
-
右辺に正規表現オブジェクトを置いた正規表現マッチ obj =~ /RE/ をサポートするためのメソッドです。 常に false を返します。
この定義により、=~ が再定義されたオブジェクトでは正常にマッチを行い、 それ以外のものは false を返すようになります。
- [PARAM] other:
- 任意のオブジェクトです。結果に影響しません。
obj = 'regexp' p(obj =~ /re/) #=> 0 obj = nil p(obj =~ /re/) #=> false
[SEE_ALSO] String#=~
self > other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が正の整数を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
self >= other -> bool
-
比較演算子 <=> をもとにオブジェクト同士を比較します。 <=> が正の整数か 0 を返した場合に、true を返します。 それ以外の整数を返した場合に、false を返します。
- [PARAM] other:
- 自身と比較したいオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- <=> が nil を返したときに発生します。
__id__ -> Integer
object_id -> Integer
id -> Integer
-
各オブジェクトに対して一意な整数を返します。あるオブジェクトに対し てどのような整数が割り当てられるかは不定です。
Rubyでは、(Garbage Collectされていない)アクティブなオブジェクト間で 重複しない整数(object_id)が各オブジェクトにひとつずつ割り当てられています。この メソッドはその値を返します。
TrueClass, FalseClass, NilClass, Symbol, Fixnum クラス のインスタンスなど Immutable(変更不可)なオブジェクトの一部は同じ内容ならば必ず同じ object_id になります。
これは、Immutable ならば複数の場所から参照されても`破壊的操作'による問題が発生しないので、 同じ内容のインスタンスを複数生成しないという内部実装が理由です。
Symbol#to_iで得られる整数と object_id は別物です。
id メソッドの再定義に備えて別名 __id__ が用意されて おり、ライブラリでは後者の利用が推奨されます。また __id__ を 再定義すべきではありません。
id は obsolete なので、object_id か __id__ を使用してください。
p "ruby".object_id #=> 22759500 p "ruby".object_id #=> 22759400 p [].object_id #=> 22759360 p [].object_id #=> 22759340 p :ruby.object_id #=> 103538 p :ruby.object_id #=> 103538 p 11.object_id #=> 23 p 11.object_id #=> 23 p true.object_id #=> 2 p true.object_id #=> 2
[SEE_ALSO] Object#equal?,Symbol
send(name, *args) -> object
send(name, *args) { .... } -> object
__send__(name, *args) -> object
__send__(name, *args) { .... } -> object
-
オブジェクトのメソッド name を args を引数に して呼び出し、メソッドの実行結果を返します。
ブロック付きで呼ばれたときはブロックもそのまま引き渡します。
send が再定義された場合に備えて別名 __send__ も 用意されており、ライブラリではこちらを使うべきです。また __send__ は再定義すべきではありません。
send, __send__ は、メソッドの呼び出し制限 にかかわらず任意のメソッドを呼び出せます。 クラス/メソッドの定義/呼び出し制限 も参照してください。
- [PARAM] name:
- 文字列かSymbol で指定するメソッド名です。
- [PARAM] args:
- 呼び出すメソッドに渡す引数です。
p -365.send(:abs) #=> 365 p "ruby".send(:sub,/./,"R") #=> "Ruby" class Foo def foo() "foo" end def bar() "bar" end def baz() "baz" end end # 任意のキーとメソッド(の名前)の関係をハッシュに保持しておく # レシーバの情報がここにはないことに注意 methods = {1 => :foo, 2 => :bar, 3 => :baz} # キーを使って関連するメソッドを呼び出す # レシーバは任意(Foo クラスのインスタンスである必要もない) p Foo.new.send(methods[1]) # => "foo" p Foo.new.send(methods[2]) # => "bar" p Foo.new.send(methods[3]) # => "baz"
[SEE_ALSO] Object#method, Kernel.#eval, Proc, Method
_dump(limit) -> String
-
Marshal.#dump において出力するオブジェクトがメソッド _dump を定義している場合には、そのメソッドの結果が書き出されます。
バージョン1.8.0以降ではObject#marshal_dump, Object#marshal_loadの使用 が推奨されます。 Marshal.dump するオブジェクトが _dump と marshal_dump の両方の メソッドを持つ場合は marshal_dump が優先されます。
メソッド _dump は引数として再帰を制限するレベル limit を受 け取り、オブジェクトを文字列化したものを返します。
インスタンスがメソッド _dump を持つクラスは必ず同じフォー マットを読み戻すクラスメソッド _load を定義する必要があり ます。_load はオブジェクトを表現した文字列を受け取り、それ をオブジェクトに戻したものを返す必要があります。
- [PARAM] limit:
- 再帰の制限レベルを表す整数です。
- [RETURN]
- オブジェクトを文字列化したものを返すように定義すべきです。
class Foo def initialize(arg) @foo = arg end def _dump(limit) Marshal.dump(@foo, limit) end def self._load(obj) p obj Foo.new(Marshal.load(obj)) end end foo = Foo.new(['foo', 'bar']) p foo #=> #<Foo:0xbaf234 @foo=["foo", "bar"]> dms = Marshal.dump(foo) p dms #=> "\004\bu:\bFoo\023\004\b[\a\"\bfoo\"\bbar" result = Marshal.load(dms) #=> "\004\b[\a\"\bfoo\"\bbar" # self._load の引数 p result #=> #<Foo:0xbaf07c @foo=["foo", "bar"]>
インスタンス変数の情報は普通マーシャルデータに含まれるので、上例 のように _dump を定義する必要はありません(ただし _dump を定義すると インスタンス変数の情報は dump されなくなります)。 _dump/_load はより高度な制御を行いたい場合や拡張ライブラリで定義し たクラスのインスタンスがインスタンス変数以外に情報を保持する場合に 利用します。(例えば、クラス Time は、_dump/_load を定義して います)
[SEE_ALSO] Object#marshal_dump,Object#marshal_load
asctime -> String
ctime -> String
-
時刻を asctime(3) の形式の文字列に変換します。た だし、末尾の改行文字 "\n" は含まれません。
between?(min, max) -> bool
-
比較演算子 <=> をもとに self が min と max の範囲内(min, max を含みます)にあるかを判断します。
以下のコードと同じです。
self >= min and self <= max
- [PARAM] min:
- 範囲の下端を表すオブジェクトを指定します。
- [PARAM] max:
- 範囲の上端を表すオブジェクトを指定します。
- [EXCEPTION] ArgumentError:
- self <=> min か、self <=> max が nil を返 したときに発生します。
3.between?(1, 5) #=> true 6.between?(1, 5) #=> false 'cat'.between?('ant', 'dog') #=> true 'gnu'.between?('ant', 'dog') #=> false
class -> Class
type -> Class
-
レシーバのクラスを返します。
p "ruby".class #=> String p 999999999999999.class #=> Bignum p ARGV.class #=> Array p self.class #=> Object p Class.class #=> Class p Kernel.class #=> Module
[SEE_ALSO] Class#superclass,Object#kind_of?,Object#instance_of?
clone -> object
dup -> object
-
オブジェクトの複製を作成して返します。
dup はオブジェクトの内容, taint 情報をコピーし、 clone はそれに加えて freeze, 特異メソッドなどの情報も含めた完全な複製を作成します。
clone や dup は浅い(shallow)コピーであることに注意してください。後述。
- [EXCEPTION] TypeError:
- TrueClass, FalseClass, NilClass, Symbol, そして Numeric クラスのインスタンスなど一部の オブジェクトを複製しようとすると発生します。
obj = "string" obj.taint def obj.fuga end obj.freeze p(obj.equal?(obj)) #=> true p(obj == obj) #=> true p(obj.tainted?) #=> true p(obj.frozen?) #=> true p(obj.respond_to?(:fuga)) #=> true obj_c = obj.clone p(obj.equal?(obj_c)) #=> false p(obj == obj_c) #=> true p(obj_c.tainted?) #=> true p(obj_c.frozen?) #=> true p(obj_c.respond_to?(:fuga)) #=> true obj_d = obj.dup p(obj.equal?(obj_d)) #=> false p(obj == obj_d) #=> true p(obj_d.tainted?) #=> true p(obj_d.frozen?) #=> false p(obj_d.respond_to?(:fuga)) #=> false
[SEE_ALSO] Object#initialize_copy
深いコピーと浅いコピー
clone や dup はオブジェクト自身を複製するだけで、オブジェクトの指し ている先(たとえば配列の要素など)までは複製しません。これを浅いコピー(shallow copy)といいます。
深い(deep)コピーが必要な場合には、 Marshalモジュールを利用して
Marshal.load(Marshal.dump(obj))
このように複製を作成する方法があります。ただしMarshal出来ないオブジェクトが 含まれている場合には使えません。
obj = ["a","b","c"] obj_d = obj.dup obj_d[0] << "PLUS" p obj #=> ["aPLUS", "b", "c"] p obj_d #=> ["aPLUS", "b", "c"] obj_m = Marshal.load(Marshal.dump(obj)) obj_m[1] << "PLUS" p obj #=> ["aPLUS", "b", "c"] p obj_m #=> ["aPLUS", "bPLUS", "c"]
mday -> Integer
day -> Integer
-
日を整数で返します。
p Time.local(2000, 1, 1).day #=> 1
display(out = $stdout) -> nil
-
オブジェクトを out に出力します。
以下のように定義されています。
class Object def display(out = $stdout) out.print self.to_s nil end end
- [PARAM] out:
- 出力先のIOオブジェクトです。指定しない場合は標準出力に出力されます。
- [RETURN]
- nil を返します。
Object.new.display #=> #<Object:0xbb0210>
[SEE_ALSO] $stdout
isdst -> bool
dst? -> bool
-
自身が表す日時が夏時間なら true を返します。そうでないなら false を返します。
ENV['TZ'] = 'US/Pacific' Time.local(2000, 7, 1).isdst #=> true Time.local(2000, 1, 1).isdst #=> false
to_enum(method = :each, *args) -> Enumerable::Enumerator
enum_for(method = :each, *args) -> Enumerable::Enumerator
-
Enumerable::Enumerator.new(self, method, *args) を返します。
- [PARAM] method:
- メソッド名の文字列かシンボルです。
- [PARAM] args:
- 呼び出すメソッドに渡される引数です。
- [EXCEPTION] NameError:
- 存在しないメソッド名を指定すると発生します。
str = "xyz" enum = str.enum_for(:each_byte) p(a = enum.map{|b| '%02x' % b }) #=> ["78", "79", "7a"] # protects an array from being modified a = [1, 2, 3] p(a.to_enum) #=> #<Enumerable::Enumerator:0xbaf7ac>
[SEE_ALSO] Enumerable::Enumerator
eql?(other) -> bool
-
other が Time かそのサブクラスのインスタンスであり自身と時刻が等しい場合に true を返します。そうでない場合に false を返します。
- [PARAM] other:
- 自身と比較したい時刻を Time オブジェクトを指定します。
eql?(other) -> bool
-
オブジェクトと other が等しければ真を返します。Hash で二つのキー が等しいかどうかを判定するのに使われます。
このメソッドは各クラスの性質に合わせて再定義すべきです。 多くの場合、 == と同様に同値性の判定をするように再定義されていますが、 適切にキー判定ができるようにより厳しくなっている場合もあります。
デフォルトでは equal? と同じオブジェクト の同一性判定になっています。
このメソッドを再定義した時には Object#hash メソッ ドも再定義しなければなりません。
- [PARAM] other:
- 比較するオブジェクトです。
p("foo".eql?("bar")) #=> false p("foo".eql?("foo")) #=> true p(4.eql?(4)) #=> true p(4.eql?(4.0)) #=> false
[SEE_ALSO] Object#hash,Object#equal?,Object#==
equal?(other) -> bool
-
other が self 自身の時、真を返します。
二つのオブジェクトが同一のものかどうか調べる時に使用します。 このメソッドを再定義してはいけません。
お互いのObject#object_idが一致する かどうかを調べます。
- [PARAM] other:
- 比較するオブジェクトです。
p("foo".equal?("bar")) #=> false p("foo".equal?("foo")) #=> false p(4.equal?(4)) #=> true p(4.equal?(4.0)) #=> false p(:foo.equal? :foo) #=> true
[SEE_ALSO] Object#object_id,Object#==,Object#eql?,Symbol
extend(*modules) -> self
-
引数で指定したモジュールのインスタンスメソッドを self の特異 メソッドとして追加します。
Module#include は、クラス(のインスタンス)に機能を追加します が、extend は、ある特定のオブジェクトだけにモジュールの機能を追加 したいときに使用します。
引数に複数のモジュールを指定した場合、最後 の引数から逆順に extend を行います。
- [PARAM] modules:
- モジュールを任意個指定します(クラスは不可)。
- [RETURN]
- self を返します。
module Foo def a 'ok Foo' end end module Bar def b 'ok Bar' end end obj = Object.new obj.extend Foo, Bar p obj.a #=> "ok Foo" p obj.b #=> "ok Bar" class Klass include Foo extend Bar end p Klass.new.a #=> "ok Foo" p Klass.b #=> "ok Bar"
extend の機能は、「特異クラスに対する Module#include」 と言い替えることもできます。 ただしその場合、フック用のメソッド が Module#extended ではなく Module#included になるという違いがあります。
# obj.extend Foo, Bar とほぼ同じ class << obj include Foo, Bar end
[SEE_ALSO] Module#extend_object,Module#include,Module#extended
freeze -> self
-
オブジェクトを凍結(内容の変更を禁止)します。
凍結されたオブジェクトの変更は 例外 TypeError を発生させます。 いったん凍結されたオブジェクトを元に戻す方法はありません。
凍結されるのはオブジェクトであり、変数ではありません。代入などで変数の指す オブジェクトが変化してしまうことは freeze では防げません。 freeze が防ぐのは、 `破壊的な操作' と呼ばれるもの一般です。変数への参照自体を凍結したい 場合は、グローバル変数なら Kernel.#trace_var が使えます。
- [RETURN]
- self を返します。
a1 = "foo".freeze a1 = "bar" p a1 #=> "bar" a2 = "foo".freeze a2.replace("bar")# can't modify frozen string (TypeError)
凍結を解除することはできませんが、Object#dup を使えばほぼ同じ内容の凍結されていない オブジェクトを得ることはできます。
a = [1].freeze p a.frozen? #=> true a[0] = "foo" p a # can't modify frozen array (TypeError) b = a.dup p b #=> [1] p b.frozen? #=> false b[0] = "foo" p b #=> ["foo"]
[SEE_ALSO] Object#frozen?,Object#dup,Kernel.#trace_var
frozen? -> bool
-
オブジェクトが凍結(内容の変更を禁止)されているときに真を返します。
obj = "someone" p obj.frozen? #=> false obj.freeze p obj.frozen? #=> true
[SEE_ALSO] Object#freeze
getgm -> Time
getutc -> Time
-
タイムゾーンを協定世界時に設定した Time オブジェクトを新しく 生成して返します。
t = Time.local(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 CST 2000 t.gmt? #=> false y = t.getgm #=> Sun Jan 02 02:15:01 UTC 2000 y.gmt? #=> true t == y #=> true
getlocal -> Time
-
タイムゾーンを地方時に設定した Time オブジェクトを新しく生成 して返します。
t = Time.gm(2000,1,1,20,15,1) #=> Sat Jan 01 20:15:01 UTC 2000 t.gmt? #=> true l = t.getlocal #=> Sat Jan 01 14:15:01 CST 2000 l.gmt? #=> false t == l #=> true
gmt? -> bool
utc? -> bool
-
self のタイムゾーンが協定世界時に設定されていれば真を返します。
utc_offset -> Integer
gmt_offset -> Integer
gmtoff -> Integer
-
協定世界時との時差を秒を単位とする数値として返します。
地方時が協定世界時よりも進んでいる場合(アジア、オーストラリアなど) には正の値、遅れている場合(アメリカなど)には負の値になります。
p Time.now.zone # => "JST" p Time.now.utc_offset # => 32400
タイムゾーンが協定世界時に設定されている場合は 0 を返します。
p Time.now.zone # => "JST" p Time.now.getgm.utc_offset # => 0
gmtime -> self
utc -> self
-
タイムゾーンを協定世界時に設定します。
このメソッドを呼び出した後は時刻変換を協定世界時として行ないます。
Time#localtime, Time#gmtime の挙動はシステムの localtime(3) の挙動に依存します。Time クラ スでは時刻を起算時からの経過秒数として保持していますが、ある特定の 時刻までの経過秒は、システムがうるう秒を勘定するかどうかによって異 なる場合があります。システムを越えて Time オブジェクトを受け 渡す場合には注意する必要があります。
t = Time.now #=> Wed Apr 09 08:56:03 CDT 2003 t.gmt? #=> false t.gmtime #=> Wed Apr 09 13:56:03 UTC 2003 t.gmt? #=> true
hash -> Fixnum
-
オブジェクトのハッシュ値を返します。Hash クラスでオブジェク トを格納するのに用いられています。
メソッド hash は Object#eql? と組み合わせて Hash クラスで利用されます。その際
A.eql?(B) ならば A.hash == B.hash
の関係を必ず満たしていなければいけません。eql? を再定義した時には必ずこちらも合わせ て再定義してください。
デフォルトでは、Object#object_id と同じ値を返します。 ただし、Fixnum, Symbol, String だけは組込みのハッ シュ関数が使用されます(これを変えることはできません)。
hash を再定義する場合は、一様に分布する任意の整数を返すようにします。
- [RETURN]
- ハッシュ値を返します。Fixnumに収まらない場合は切り捨てられます。
p self.hash #=> 21658870 p 0.hash #=> 1 p 0.0.hash #=> 0 p nil.hash #=> 4 p "ruby".hash #=> -241670986 p "ruby".hash #=> -241670986 p :ruby.hash #=> 103538 p :ruby.hash #=> 103538
[SEE_ALSO] Object#eql?,Object#__id__
hour -> Integer
-
時を整数で返します。
inspect -> String
-
オブジェクトを人間が読める形式に変換した文字列を返します。
組み込み関数 Kernel.#p は、このメソッドの結果を使用して オブジェクトを表示します。
puts Class.new.inspect #=> #<Class:0xbafd88> puts Time.now.inspect #=> 2007-10-15 21:01:37 +0900
[SEE_ALSO] Kernel.#p
instance_eval(expr, filename = "(eval)", lineno = 1) -> object
instance_eval {|obj| ... } -> object
-
オブジェクトのコンテキストで文字列 expr またはオブジェクト自身をブロックパラメータとするブロックを 評価してその結果を返します。
オブジェクトのコンテキストで評価するとは評価中の self をそのオブジェクトにして実行するということです。 また、文字列 expr やブロック中でメソッドを定義すればそのオブジェクトの特異メソッドが定義されます。
ただし、ローカル変数だけは、文字列 expr の評価では instance_eval の外側のスコープと、ブロックの評価ではそのブロックの外側のスコープと、共有します。
メソッド定義の中で instance_eval でメソッドを定義した場合は、囲むメソッドが実行されたときに 初めて instance_eval 内のメソッドが定義されます。これはメソッド定義のネストと同じです。 クラス/メソッドの定義/メソッド定義のネスト を参照してください。
- [PARAM] expr:
- 評価する文字列です。
- [PARAM] filename:
- 文字列を指定します。ファイル filename に文字列 expr が 書かれているかのように実行されます。スタックトレースの 表示などを差し替えることができます。
- [PARAM] lineno:
- 文字列を指定します。行番号 lineno から文字列 expr が書かれているかのように実行されます。 スタックトレースの表示などを差し替えることができます。
例:
class Foo def initialize data @key = data end private def do_fuga p 'secret' end end some = Foo.new 'XXX' some.instance_eval{p @key} #=> "XXX" some.instance_eval{do_fuga } #=> "secret" # private メソッドも呼び出せる some.instance_eval 'raise' # ..:10: (eval):1: (RuntimeError) messg = 'unknown' some.instance_eval 'raise messg','file.rb',999 # file.rb:999: unknown (RuntimeError)
[SEE_ALSO] Module#module_eval, Kernel.#eval
instance_exec(*args) {|*vars| ... } -> object
-
与えられたブロックをレシーバのコンテキストで実行します。
ブロック実行中は、 self がレシーバのコンテキストになるので レシーバの持つインスタンス変数にアクセスすることができます。
- [PARAM] args:
- ブロックパラメータに渡す値です。
class KlassWithSecret def initialize @secret = 99 end end k = KlassWithSecret.new # 以下で x には 5 が渡される k.instance_exec(5) {|x| @secret + x } #=> 104
[SEE_ALSO] Module#class_exec, Module#module_exec, Object#instance_eval
instance_of?(klass) -> bool
-
オブジェクトがクラス klass の直接のインスタンスである時真を返します。
obj.instance_of?(c) が成立する時には、常に obj.kind_of?(c) も成立します。
- [PARAM] klass:
- Classかそのサブクラスのインスタンスです。
class C < Object end class S < C end obj = S.new p obj.instance_of?(S) # true p obj.instance_of?(C) # false
[SEE_ALSO] Object#kind_of?,Object#class
instance_variable_defined?(var) -> bool
-
インスタンス変数 var が定義されていたら真を返します。
- [PARAM] var:
- インスタンス変数名を文字列か Symbol で指定します。
class Fred def initialize(p1, p2) @a, @b = p1, p2 end end fred = Fred.new('cat', 99) p fred.instance_variable_defined?(:@a) #=> true p fred.instance_variable_defined?("@b") #=> true p fred.instance_variable_defined?("@c") #=> false
[SEE_ALSO] Object#instance_variable_get,Object#instance_variable_set,Object#instance_variables
instance_variable_get(var) -> object|nil
-
オブジェクトのインスタンス変数の値を取得して返します。
インスタンス変数が定義されていなければ nil を返します。
- [PARAM] var:
- インスタンス変数名を文字列か Symbol で指定します。
class Foo def initialize @foo = 1 end end obj = Foo.new p obj.instance_variable_get("@foo") #=> 1 p obj.instance_variable_get(:@foo) #=> 1 p obj.instance_variable_get(:@bar) #=> nil
[SEE_ALSO] Object#instance_variable_set,Object#instance_variables,Object#instance_variable_defined?
instance_variable_set(var, value) -> object
-
オブジェクトのインスタンス変数 var に値 value を設定します。
インスタンス変数が定義されていなければ新たに定義されます。
- [PARAM] var:
- インスタンス変数名を文字列か Symbol で指定します。
- [PARAM] value:
- 設定する値です。
- [RETURN]
- value を返します。
obj = Object.new p obj.instance_variable_set("@foo", 1) #=> 1 p obj.instance_variable_set(:@foo, 2) #=> 2 p obj.instance_variable_get(:@foo) #=> 2
[SEE_ALSO] Object#instance_variable_get,Object#instance_variables,Object#instance_variable_defined?
instance_variables -> [String]
-
オブジェクトのインスタンス変数名を文字列の配列として返します。
obj = Object.new obj.instance_eval { @foo, @bar = nil } p obj.instance_variables #=> ["@foo", "@bar"]
[SEE_ALSO] Object#instance_variable_get,Kernel.#local_variables,Kernel.#global_variables,Module.constants,Module#constants,Module#class_variables
is_a?(mod) -> bool
kind_of?(mod) -> bool
-
オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。
また、オブジェクトがモジュール mod をインクルードしたクラスかそのサブクラス のインスタンスである場合にも真を返します。 上記のいずれでもない場合に false を返します。
- [PARAM] mod:
- クラスやモジュールなど、Moduleかそのサブクラスのインスタンスです。
module M end class C < Object include M end class S < C end obj = S.new p obj.is_a?(S) # true p obj.is_a?(C) # true p obj.is_a?(Object) # true p obj.is_a?(M) # true p obj.is_a?(Hash) # false
[SEE_ALSO] Object#instance_of?,Module#===,Object#class
localtime -> self
-
タイムゾーンを地方時に設定します。
このメソッドを呼び出した後は時刻変換を協定地方時として行ないます。
Time#localtime, Time#gmtime の挙動はシステムの localtime(3) の挙動に依存します。Time クラ スでは時刻を起算時からの経過秒数として保持していますが、ある特定の 時刻までの経過秒は、システムがうるう秒を勘定するかどうかによって異 なる場合があります。システムを越えて Time オブジェクトを受け 渡す場合には注意する必要があります。
t = Time.gm(2000, "jan", 1, 20, 15, 1) t.gmt? #=> true t.localtime #=> Sat Jan 01 14:15:01 CST 2000 t.gmt? #=> false
marshal_dump -> object
-
Marshal.#dump を制御するメソッドです。
Marshal.dump(some) において、出力するオブジェクト some がメソッド marshal_dump を 持つ場合には、その返り値がダンプされたものが Marshal.dump(some) の返り値となります。
marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。 これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。
- [RETURN]
- 任意のオブジェクトで marshal_load の引数に利用できます。
class Foo def initialize(arg) @foo = arg end def marshal_dump @foo end def marshal_load(obj) p obj @foo = obj end end foo = Foo.new(['foo', 'bar']) p foo #=> #<Foo:0xbaf3b0 @foo=["foo", "bar"]> dms = Marshal.dump(foo) p dms #=> "\004\bU:\bFoo[\a\"\bfoo\"\bbar" result = Marshal.load(dms) #=> ["foo", "bar"] # marshal_load の引数 p result #=> #<Foo:0xbaf2ac @foo=["foo", "bar"]>
インスタンス変数の情報は普通マーシャルデータに含まれるので、 上例のように marshal_dump を定義する必要はありません (ただし marshal_dump を定義するとインスタンス変数の情報は ダンプされなくなるので、marshal_dump/marshal_load で扱う必要があります)。 marshal_dump/marshal_load はより高度な制御を行いたい場合や 拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外 に情報を保持する場合に利用します。
特に、marshal_dump/marshal_load を定義したオブジェクトは 特異メソッドが定義されていてもマーシャルできるようになります (特異メソッドの情報が自動的に dump されるようになるわけではなく、 marshal_dump/marshal_load によりそれを実現する余地があるということです)。
[SEE_ALSO] Object#marshal_load, Marshal
marshal_load(obj) -> object
-
Marshal.#load を制御するメソッドです。
some のダンプ結果(Marshal.dump(some)) をロードする(Marshal.load(Marshal.dump(some)))に は some がメソッド marshal_load を持っていなければなりません。 このとき、marshal_dump の返り値が marshal_load の引数に利用されます。 marshal_load 時の self は、生成されたばかり(Class#allocate されたばかり) の状態です。
marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。 これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。
- [PARAM] obj:
- marshal_dump の返り値のコピーです。
- [RETURN]
- 返り値は無視されます。
[SEE_ALSO] Object#marshal_dump, Marshal
method(name) -> Method
-
オブジェクトのメソッド name をオブジェクト化した Method オブジェクトを返します。
me = -365.method(:abs) p me #=> #<Method: Fixnum#abs> p me.call #=> 365
[SEE_ALSO] Module#instance_method,Method,Object#__send__,Kernel.#eval
method_missing(name, *args) -> object
-
呼びだされたメソッドが定義されていなかった時、Rubyインタプリタがこのメソッド を呼び出します。
呼び出しに失敗したメソッドの名前 (Symbol) が name に その時の引数が第二引数以降に渡されます。
デフォルトではこのメソッドは例外 NameError を発生させます。
- [PARAM] name:
- 未定義メソッドの名前(シンボル)です。
- [PARAM] args:
- 未定義メソッドに渡された引数です。
- [RETURN]
- ユーザー定義の method_missing メソッドの返り値が未定義メソッドの返り値で あるかのように見えます。
class Foo def initialize(data) @data = data end def method_missing(name, lang) if name.to_s =~ /\Afind_(\d+)_in\z/ if @data[lang] p @data[lang][$1.to_i] else raise "#{lang} unknown" end else super end end end dic = Foo.new({:English => %w(zero one two), :Esperanto => %w(nulo unu du)}) dic.find_2_in :Esperanto #=> "du"
methods(include_inherited = true) -> [String]
-
そのオブジェクトに対して呼び出せるメソッド名の一覧を返します。 このメソッドは public メソッドおよび protected メソッドの名前を返します。
ただし特別に、引数が偽の時は Object#singleton_methods(false) と同じになっています。
- [PARAM] include_inherited:
- 引数が偽の時は Object#singleton_methods(false) と同じになります。
#例1: class Parent private; def private_parent() end protected; def protected_parent() end public; def public_parent() end end class Foo < Parent private; def private_foo() end protected; def protected_foo() end public; def public_foo() end end obj = Foo.new class <<obj private; def private_singleton() end protected; def protected_singleton() end public; def public_singleton() end end # あるオブジェクトの応答できるメソッドの一覧を得る。 p obj.methods(false) p obj.public_methods(false) p obj.private_methods(false) p obj.protected_methods(false) #実行結果 ["public_singleton", "protected_singleton"] ["public_foo", "public_singleton"] ["private_foo", "private_singleton"] ["protected_foo", "protected_singleton"] #例2: # あるオブジェクトの応答できるメソッドの一覧を得る。 # 自身のクラスの親クラスのインスタンスメソッドも含めるために true を指定して # いるが、Object のインスタンスメソッドは一覧から排除している。 p obj.methods(true) - Object.instance_methods(true) p obj.public_methods(true) - Object.public_instance_methods(true) p obj.private_methods(true) - Object.private_instance_methods(true) p obj.protected_methods(true) - Object.protected_instance_methods(true) #実行結果 ["public_foo", "public_parent", "protected_singleton", "public_singleton", "protected_foo", "protected_parent"] ["public_foo", "public_parent", "public_singleton"] ["private_singleton", "private_foo", "private_parent"] ["protected_singleton", "protected_foo", "protected_parent"]
[SEE_ALSO] Module#instance_methods,Object#singleton_methods
min -> Integer
-
分を整数で返します。
mon -> Integer
month -> Integer
-
月を整数で返します。
p Time.local(2000, 1, 1).month #=> 1
nil? -> bool
-
レシーバが nil であれば真を返します。
p false.nil? #=> false p nil.nil? #=> true
[SEE_ALSO] NilClass
private_methods(include_inherited = true) -> [String]
-
そのオブジェクトが理解できる private メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#private_instance_methods,Object#methods,Object#singleton_methods
protected_methods(include_inherited = true) -> [String]
-
そのオブジェクトが理解できる protected メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#protected_instance_methods,Object#methods,Object#singleton_methods
public_methods(include_inherited = true) -> [String]
-
そのオブジェクトが理解できる public メソッド名の一覧を返します。
- [PARAM] include_inherited:
- 偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。
[SEE_ALSO] Module#public_instance_methods,Object#methods,Object#singleton_methods
respond_to?(name, include_private = false) -> bool
-
オブジェクトがメソッド name を持つとき真を返します。
オブジェクトが メソッド name を持つというのは、 オブジェクトが メソッド name に応答することができることをいいます。
- [PARAM] name:
- Symbol または文字列で指定するメソッド名です。
- [PARAM] include_private:
- private メソッドを確認の対象に含めるかを true か false で指定します。省略した場合は false(含めな い) を指定した事になります。
class F def hello "Bonjour" end end class D private def hello "Guten Tag" end end list = [F.new,D.new] list.each{|it| puts it.hello if it.respond_to?(:hello)} #=> Bonjour list.each{|it| it.instance_eval("puts hello if it.respond_to?(:hello, true)")} #=> Bonjour # Guten Tag
[SEE_ALSO] Module#method_defined?
sec -> Integer
-
秒を整数で返します。
Time.mktime(2000, 1, 1).sec #=> 0
通常は0から59を返しますが、うるう秒の場合は60を返します。
ENV['TZ'] = 'right/UTC' Time.mktime(2005, 12, 31, 23, 59, 60).sec #=> 60
singleton_methods(inherited_too = true) -> [String]
-
そのオブジェクトに対して定義されている特異メソッド名 (public あるいは protected メソッド) の一覧を返します。
クラスメソッド(Classのインスタンスの特異メソッド)に関しては 引数が真のとき、スーパークラスのクラスメソッドも対象になります。
singleton_methods(false) は、Object#methods(false) と同じです。
- [PARAM] inherited_too:
- 引数が真のとき、スーパークラスのクラスメソッドも対象になります。これが意味を持つのは self がクラスオブジェクトであるときだけです。
#例1: Parent = Class.new class <<Parent private; def private_class_parent() end protected; def protected_class_parent() end public; def public_class_parent() end end Foo = Class.new(Parent) class <<Foo private; def private_class_foo() end protected; def protected_class_foo() end public; def public_class_foo() end end module Bar private; def private_bar() end protected; def protected_bar() end public; def public_bar() end end obj = Foo.new class <<obj include Bar private; def private_self() end protected; def protected_self() end public; def public_self() end end # あるオブジェクトの特異メソッドの一覧を得る。 p obj.singleton_methods(false) p obj.methods(false) p Foo.singleton_methods(false) #実行結果 ["public_self", "protected_self"] ["public_self", "protected_self"] ["public_class_foo", "protected_class_foo"] #例2: # あるオブジェクトの特異メソッドの一覧を得る。 # 親クラスのクラスメソッドも含まれるよう true を指定したが、 # Object のクラスメソッドは一覧から排除している。 p obj.singleton_methods(true) p Foo.singleton_methods(true) - Object.singleton_methods(true) #実行結果 ["public_bar", "public_self", "protected_bar", "protected_self"] ["public_class_foo", "public_class_parent", "protected_class_foo", "protected_class_parent"]
[SEE_ALSO] Object#methods,Object#extend
strftime(format) -> String
-
時刻を format 文字列に従って文字列に変換した結果を返します。
- [PARAM] format:
- フォーマット文字列を指定します。使用できるものは 以下の通りです。
- %A: 曜日の名称(Sunday, Monday ... )
- %a: 曜日の省略名(Sun, Mon ... )
- %B: 月の名称(January, February ... )
- %b: 月の省略名(Jan, Feb ... )
- %c: 日付と時刻
- %d: 日(01-31)
- %H: 24時間制の時(00-23)
- %I: 12時間制の時(01-12)
- %j: 年中の通算日(001-366)
- %M: 分(00-59)
- %m: 月を表す数字(01-12)
- %p: 午前または午後(AM,PM)
- %S: 秒(00-60) (60はうるう秒)
- %U: 週を表す数。最初の日曜日が第1週の始まり(00-53)
- %W: 週を表す数。最初の月曜日が第1週の始まり(00-53)
- %w: 曜日を表す数。日曜日が0(0-6)
- %X: 時刻
- %x: 日付
- %Y: 西暦を表す数
- %y: 西暦の下2桁(00-99)
- %Z: タイムゾーン
- %%: %自身
現在の実装では、このメソッドは、システムの strftime(3) をそのまま使用しています。そのためここにあげた指示子以外のものが使 用できる場合があります。ただし、上記以外の指示子を使用した場合、移 植性をそこなう可能性がある点に注意してください。
t = Time.now t.strftime("Printed on %m/%d/%Y") #=> "Printed on 04/09/2003" t.strftime("at %I:%M%p") #=> "at 08:56AM"
succ -> Time
-
self に 1 秒足した Time オブジェクトを生成して返します。
t = Time.now p t p t.succ # => Sun Jul 18 01:41:22 JST 2004 Sun Jul 18 01:41:23 JST 2004
taint -> self
-
オブジェクトの「汚染マーク」をセットします。
環境変数(ENVで得られる文字列)など一部のオブジェクトは最初から汚染されています。 オブジェクトの汚染に関してはセキュリティモデルを参照してください。
$SAFE = 1 some = "puts '@&%&(#!'" p some.tainted? #=> false eval(some) #=> @&%&(#! some.taint p some.tainted? #=> true eval(some) # Insecure operation - eval (SecurityError) some.untaint p some.tainted? #=> false eval(some) #=> @&%&(#! p ENV['OS'].tainted? #=> true
[SEE_ALSO] Object#tainted?,Object#untaint,Object#freeze
tainted? -> bool
-
オブジェクトの「汚染マーク」がセットされている時真を返します。
オブジェクトの汚染に関してはセキュリティモデルを参照してください。
p String.new.tainted? #=> false p ENV['OS'].tainted? #=> true
[SEE_ALSO] Object#taint,Object#untaint
tap {|x| ... } -> self
-
self を引数としてブロックを評価し、self を返します。
メソッドチェインの途中で直ちに操作結果を表示するために メソッドチェインに "入り込む" ことが、このメソッドの主目的です。
(1..10) .tap {|x| puts "original: #{x.inspect}"}. to_a .tap {|x| puts "array: #{x.inspect}"}. select {|x| x % 2 == 0} .tap {|x| puts "evens: #{x.inspect}"}. map { |x| x * x } .tap {|x| puts "squares: #{x.inspect}"}
to_a -> Array
-
時刻を10要素の配列で返します。
その要素は順序も含めて以下の通りです。
- sec: 秒 (整数 0-60) (60はうるう秒)
- min: 分 (整数 0-59)
- hour: 時 (整数 1-24)
- mday: 日 (整数)
- mon: 月 (整数 1-12)
- year: 年 (整数 2000年=2000)
- wday: 曜日 (整数 0-6)
- yday: 年内通算日 (整数 1-366)
- isdst: 夏時間であるかどうか (true/false)
- zone: タイムゾーン (文字列)
p Time.now # => Mon Oct 20 06:02:10 JST 2003 p Time.now.to_a # => [10, 2, 6, 20, 10, 2003, 1, 293, false, "JST"]
要素の順序は C 言語の tm 構造体に合わせています。ただし、 tm 構造体に zone はありません。
注意: C 言語の tm 構造体とは異なり、month は 1 月に対 して 1 を返し、year は 1998 年に対して 1998 を返します。また、 yday は 1 から数えます。
to_a -> Array
-
オブジェクトを配列に変換した結果を返します。
配列に変換できない(to_ary を持たない)オブジェクトは、自身のみを含む長さ 1 の配 列に変換されます。 このメソッドは、将来 Object のメソッドからは取り除かれます。 なので to_a を使用する場合、
- すべてのオブジェクトに to_a が定義されているという期待はしない。
- ユーザー定義のクラスには必要に応じて自分で定義する
などということが必要です。
p( {'a'=>1}.to_a ) # [["a", 1]] p ['array'].to_a # ["array"] p 1.to_a # [1] (warning: default `to_a' will be obsolete) p nil.to_a # []
[SEE_ALSO] Object#to_ary,Kernel.#Array
to_ary -> Array
-
オブジェクトの Array への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 配列が使われるすべての場面で代置可能であるような、
- 配列そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_ary [3,4] end end it = Foo.new p([1,2] + it) #=> [1, 2, 3, 4]
[SEE_ALSO] Object#to_a,Kernel.#Array
to_f -> Float
-
起算時からの経過秒数を浮動小数点数で返します。1 秒に満たない経過も 表現されます。
t = Time.now "%10.5f" % t.to_f #=> "1049896564.13654" t.to_i #=> 1049896564
to_hash -> Hash
-
オブジェクトの Hash への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- ハッシュが使われるすべての場面で代置可能であるような、
- ハッシュそのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_hash {'as' => 24} end end it = Foo.new p({:as => 12}.merge(it)) #=> {"as"=>24, :as=>12}
to_i -> Integer
tv_sec -> Integer
-
起算時からの経過秒数を整数で返します。
to_int -> Integer
-
オブジェクトの Integer への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 整数が使われるすべての場面で代置可能であるような、
- 整数そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_int 666 end end it = Foo.new p(9**9 & it) #=> 8
[SEE_ALSO] Kernel.#Integer
to_io -> IO
-
オブジェクトの IO への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- IOオブジェクトが使われるすべての場面で代置可能であるような、
- IOオブジェクトそのものとみなせるようなもの
という厳しいものになっています。
to_proc -> Proc
-
オブジェクトの Proc への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
def doing yield end class Foo def to_proc Proc.new{p 'ok'} end end it = Foo.new doing(&it) #=> "ok"
to_regexp -> Regexp
-
オブジェクトの Regexp への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 正規表現が使われるすべての場面で代置可能であるような、
- 正規表現そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_regexp /[\d]+/ end end it = Foo.new p Regexp.union(/^at/, it) #=> /(?-mix:^at)|(?-mix:[\d]+)/
to_s -> String
-
時刻を date(1) のような形式の文字列に変換します。
self.strftime("%a %b %d %H:%M:%S %Z %Y")
と同じです。
p Time.now.to_s # => "Mon Oct 20 06:02:10 JST 2003"
to_s -> String
-
オブジェクトの文字列表現を返します。
Kernel.#print や Kernel.#sprintf は文字列以外の オブジェクトが引数に渡された場合このメソッドを使って文字列に変換し ます。
class Foo def initialize num @num = num end end it = Foo.new(40) puts it #=> #<Foo:0x2b69110> class Foo def to_s "Class:Foo Number:#{@num}" end end puts it #=> Class:Foo Number:40
[SEE_ALSO] Object#to_str,Kernel.#String
to_str -> String
-
オブジェクトの String への暗黙の変換が必要なときに内部で呼ばれます。 デフォルトでは定義されていません。
説明のためここに記載してありますが、 このメソッドは実際には Object クラスには定義されていません。 必要に応じてサブクラスで定義すべきものです。
このメソッドを定義する条件は、
- 文字列が使われるすべての場面で代置可能であるような、
- 文字列そのものとみなせるようなもの
という厳しいものになっています。
class Foo def to_str 'Edition' end end it = Foo.new p('Second' + it) #=> "SecondEdition"
[SEE_ALSO] Object#to_s,Kernel.#String
usec -> Integer
tv_usec -> Integer
-
時刻のマイクロ秒の部分を整数で返します。
untaint -> self
-
オブジェクトの「汚染マーク」を取り除きます。
汚染マークを取り除くことによる危険性はプログラマが責任を負う必要が あります。
オブジェクトの汚染に関してはセキュリティモデルを参照してください。
- [EXCEPTION] SecurityError:
- セキュリティレベルが3以上の時にこのメソッドを使用すると発生します。
[SEE_ALSO] Object#taint,Object#tainted?
wday -> Integer
-
曜日を0(日曜日)から6(土曜日)の整数で返します。
yday -> Integer
-
1月1日を1とした通算日(1から366まで)を整数で返します。
Time.mktime(2000, 1, 1).yday #=> 1
うるう年の場合は、2月29日も含めた通算日を返します。
# うるう年でない場合 Time.mktime(2003, 1, 1).yday #=> 1 Time.mktime(2003, 3, 1).yday #=> 60 Time.mktime(2003, 12, 31).yday #=> 365 # うるう年の場合 Time.mktime(2004, 1, 1).yday #=> 1 Time.mktime(2004, 2, 29).yday #=> 60 Time.mktime(2004, 12, 31).yday #=> 366
year -> Integer
-
年を整数で返します。
p Time.local(2000, 1, 1).year #=> 2000
zone -> String
-
タイムゾーンを表す文字列を返します。
p Time.now.zone #=> "JST"
privateメソッド
initialize(*args, &block) -> object
-
ユーザ定義クラスのオブジェクト初期化メソッド。
このメソッドは Class#new から新しく生成されたオブ ジェクトの初期化のために呼び出されます。他の言語のコンストラクタに相当します。 デフォルトの動作ではなにもしません。
initialize には Class#new に与えられた引数がそのまま渡されます。
サブクラスではこのメソッドを必要に応じて再定義されること が期待されています。
initialize という名前のメソッドは自動的に private に設定され ます。
- [PARAM] args:
- 初期化時の引数です。
- [PARAM] block:
- 初期化時のブロック引数です。必須ではありません。
class Foo def initialize name puts "initialize Foo" @name = name end end class Bar < Foo def initialize name, pass puts "initialize Bar" super name @pass = pass end end it = Bar.new('myname','0500') p it #=> initialize Bar # initialize Foo # #<Bar:0x2b68f08 @name="myname", @pass="0500">
[SEE_ALSO] Class#new
initialize_copy(obj) -> object
-
(拡張ライブラリによる) ユーザ定義クラスのオブジェクトコピーの初期化メソッド。
このメソッドは self を obj の内容で置き換えます。ただ し、self のインスタンス変数や特異メソッドは変化しません。 Object#clone, Object#dupの内部で使われています。
initialize_copy は、Ruby インタプリタが知り得ない情報をコピーするた めに使用(定義)されます。例えば C 言語でクラスを実装する場合、情報 をインスタンス変数に保持させない場合がありますが、そういった内部情 報を initialize_copy でコピーするよう定義しておくことで、dup や clone を再定義する必要がなくなります。
デフォルトの Object#initialize_copy は、 freeze チェックおよび型のチェックを行い self を返すだけのメソッドです。
initialize_copy という名前のメソッドは 自動的に private に設定されます。
- [EXCEPTION] TypeError:
- レシーバが freeze されているか、obj のクラスがレシーバ のクラスと異なる場合に発生します。
[SEE_ALSO] Object#clone,Object#dup
以下に例として、dup や clone がこのメソッドをどのように利用しているかを示します。
obj.dup は、新たに生成したオブジェクトに対して initialize_copy を呼び
obj2 = obj.class.allocate obj2.initialize_copy(obj)
obj2 に対してさらに obj の汚染状態、インスタンス変数、ファイナライ ザをコピーすることで複製を作ります。 obj.clone は、さらに 特異メソッドのコピーも行います。
obj = Object.new class <<obj attr_accessor :foo def bar :bar end end def check(obj) puts "instance variables: #{obj.inspect}" puts "tainted?: #{obj.tainted?}" print "singleton methods: " begin p obj.bar rescue NameError p $! end end obj.foo = 1 obj.taint check Object.new.send(:initialize_copy, obj) #=> instance variables: #<Object:0x4019c9d4> # tainted?: false # singleton methods: #<NoMethodError: ...> check obj.dup #=> instance variables: #<Object:0x4019c9c0 @foo=1> # tainted?: true # singleton methods: #<NoMethodError: ...> check obj.clone #=> instance variables: #<Object:0x4019c880 @foo=1> # tainted?: true # singleton methods: :bar
remove_instance_variable(name) -> object
-
オブジェクトからインスタンス変数 name を取り除き、そのインス タンス変数に設定されていた値を返します。
- [PARAM] name:
- 削除するインスタンス変数の名前をシンボルか文字列で指定します。
- [EXCEPTION] NameError:
- オブジェクトがインスタンス変数 name を持たない場合に発生します。
class Foo def foo @foo = 1 p remove_instance_variable(:@foo) #=> 1 p remove_instance_variable(:@foo) # instance variable @foo not defined (NameError) end end Foo.new.foo
[SEE_ALSO] Module#remove_class_variable,Module#remove_const
singleton_method_added(name) -> object
-
特異メソッドが追加された時にインタプリタから呼び出されます。
通常のメソッドの追加に対するフックには Module#method_addedを使います。
- [PARAM] name:
- 追加されたメソッド名が Symbol で渡されます。
class Foo def singleton_method_added(name) puts "singleton method \"#{name}\" was added" end end obj = Foo.new def obj.foo end #=> singleton method "foo" was added
[SEE_ALSO] Module#method_added,Object#singleton_method_removed,Object#singleton_method_undefined
singleton_method_removed(name) -> object
-
特異メソッドが Module#remove_method に より削除された時にインタプリタから呼び出されます。
通常のメソッドの削除に対するフックには Module#method_removedを使います。
- [PARAM] name:
- 削除されたメソッド名が Symbol で渡されます。
class Foo def singleton_method_removed(name) puts "singleton method \"#{name}\" was removed" end end obj = Foo.new def obj.foo end class << obj remove_method :foo end #=> singleton method "foo" was removed
[SEE_ALSO] Module#method_removed,Object#singleton_method_added,Object#singleton_method_undefined
singleton_method_undefined(name) -> object
-
特異メソッドが Module#undef_method または undef により未定義にされた時にインタプリタから呼び出されます。
通常のメソッドの未定義に対するフックには Module#method_undefined を使います。
- [PARAM] name:
- 未定義にされたメソッド名が Symbol で渡されます。
class Foo def singleton_method_undefined(name) puts "singleton method \"#{name}\" was undefined" end end obj = Foo.new def obj.foo end def obj.bar end class << obj undef_method :foo end obj.instance_eval {undef bar} #=> singleton method "foo" was undefined # singleton method "bar" was undefined
[SEE_ALSO] Module#method_undefined,Object#singleton_method_added,Object#singleton_method_removed , クラス/メソッドの定義/undef
- Ruby 1.8.7 リファレンスマニュアル
- はじめに
- コマンド
- Rubyの起動
- 環境変数
- Ruby言語仕様
- 組み込みライブラリ
- クラス
- Array
- BasicObject
- Bignum
- Binding
- Class
- Complex
- Data
- Dir
- Encoding
- Encoding::
Converter - Enumerator
- FalseClass
- Fiber
- File
- File::Stat
- Fixnum
- Float
- Hash
- IO
- Integer
- MatchData
- Method
- Module
- Mutex
- NilClass
- Numeric
- Object
- Proc
- Process::Status
- Random
- Range
- Rational
- Regexp
- String
- Struct
- Struct::Tms
- Symbol
- Thread
- ThreadGroup
- Time
- TrueClass
- UnboundMethod
- モジュール
- オブジェクト
- 例外クラス
- 組み込み関数
(Kernelモジュール関数) - 組み込み定数
(Kernel定数) - 組み込み特殊変数
- クラス
- 標準添付ライブラリ
- pack テンプレート文字列
- sprintf フォーマット
- Ruby用語集
- Rubyで使われる記号の意味
- 疑似BNFによるRubyの文法
- バージョン情報 / このリファレンスについて