class SOAP::MIMEMessage::Headers + Hash + Enumerable + Object
クラスの継承リスト: SOAP::MIMEMessage::Headers < Hash < Enumerable < Object < Kernel
要約
特異メソッド
self[other] -> Hash
-
新しいハッシュを生成します。 引数otherと同一のキーと値を持つ新たなハッシュを生成して返します。
引数otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
デフォルト値はコピーしません。生成されたハッシュのデフォルト値は nil です。
引数otherと生成したハッシュは同じオブジェクトを参照することになるので、 一方でキーや値に破壊的操作を行うともう片方にも影響します。
- [PARAM] other:
- 生成元となるハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
h = {1 => "value"} h.default = "none" g = Hash[h] p g #=> {1=>"value"} p h[:no] #=> "none" p g[:no] #=> nil h[:add] = "some" p h #=> {1=>"value", :add=>"some"} p g #=> {1=>"value"} h[1] << 'plus' #破壊的操作 p h #=> {1=>"valueplus", :add=>"some"} p g #=> {1=>"valueplus"}
self[*key_and_value] -> Hash
-
新しいハッシュを生成します。 引数は必ず偶数個指定しなければなりません。奇数番目がキー、偶数番目が値になります。
このメソッドでは生成するハッシュにデフォルト値を指定することはできません。 Hash.newを使うか、Hash#default=で後から指定してください。
- [PARAM] key_and_value:
- 生成するハッシュのキーと値の組です。必ず偶数個(0を含む)指定しなければいけません。
- [EXCEPTION] ArgumentError:
- 奇数個の引数を与えたときに発生します。
以下は配列からハッシュを生成する方法の例です。
(1) [キー, 値, ...] の配列からハッシュへ
ary = [1,"a", 2,"b", 3,"c"] p Hash[*ary] # => {1=>"a", 2=>"b", 3=>"c"}
(2) キーと値のペアの配列からハッシュへ
alist = [[1,"a"], [2,"b"], [3,"c"]] p Hash[*alist.flatten] # => {1=>"a", 2=>"b", 3=>"c"}
(3) キーと値の配列のペアからハッシュへ
keys = [1, 2, 3] vals = ["a", "b", "c"] alist = keys.zip(vals) # あるいは alist = [keys,vals].transpose p Hash[*alist.flatten] # => {1=>"a", 2=>"b", 3=>"c"}
(4) キーや値が配列の場合
alist = [[1,["a"]], [2,["b"]], [3,["c"]], [[4,5], ["a", "b"]]] hash = Hash[alist] # => {1=>["a"], 2=>["b"], 3=>["c"], [4, 5]=>["a", "b"]}
new(ifnone = nil) -> Hash
-
空の新しいハッシュを生成します。ifnone はキーに対 応する値が存在しない時のデフォルト値です。設定したデフォルト値はHash#defaultで参照できます。
ifnoneを省略した Hash.new は {} と同じです。
デフォルト値として、毎回同一のオブジェクトifnoneを返します。 それにより、一箇所のデフォルト値の変更が他の値のデフォルト値にも影響します。
h = Hash.new([]) h[0] << 0 h[1] << 1 p h.default #=> [0, 1]
これを避けるには、破壊的でないメソッドで再代入する必要が有ります。 また、このようなミスを防ぐためにもifnoneは freeze して破壊的操作を禁止しておくのが無難です。
- [PARAM] ifnone:
- キーに対応する値が存在しない時のデフォルト値です。
h = Hash.new([]) p h[1] #=> [] p h[1].object_id #=> 6127150 p h[1] << "bar" #=> ["bar"] p h[1] #=> ["bar"] p h[2] #=> ["bar"] p h[2].object_id #=> 6127150 p h #=> {} h = Hash.new([].freeze) h[0] += [0] #破壊的でないメソッドはOK h[1] << 1 # エラー `<<': can't modify frozen array (TypeError)
new {|hash, key| ... } -> Hash
-
空の新しいハッシュを生成します。ブロックの評価結果がデフォルト値になりま す。設定したデフォルト値はHash#default_procで参照できます。
値が設定されていないハッシュ要素を参照するとその都度ブロックを 実行し、その結果を返します。 ブロックにはそのハッシュとハッシュを参照したときのキーが渡されます。
- [EXCEPTION] ArgumentError:
- ブロックと通常引数を同時に与えると発生します。
# ブロックではないデフォルト値は全部同一のオブジェクトなので、 # 破壊的変更によって他のキーに対応する値も変更されます。 h = Hash.new("foo") p h[1] #=> "foo" p h[1].object_id #=> 6127170 p h[1] << "bar" #=> "foobar" p h[1] #=> "foobar" p h[2] #=> "foobar" p h[2].object_id #=> 6127170 p h #=> {} # ブロックを与えると、対応する値がまだ無いキーが呼び出される度に # ブロックを評価するので、全て別のオブジェクトになります。 h = Hash.new {|hash, key| hash[key] = "foo"} p h[1] #=> "foo" p h[1].object_id #=> 6126900 p h[1] << "bar" #=> "foobar" p h[1] #=> "foobar" p h[2] #=> "foo" p h[2].object_id #=> 6126840 p h #=> {1=>"foobar", 2=>"foo"} # 値が設定されていないときに(fetchのように)例外をあげるようにもできる h = Hash.new {|hash, key| raise(IndexError, "hash[#{key}] has no value") } h[1] # エラー hash[1] has no value (IndexError)
[SEE_ALSO] Hash#default=,Hash#default,Hash#default_proc
new -> Object
-
Objectクラスのインスタンスを生成して返します。
some = Object.new p some #=> #<Object:0x2b696d8>
parse(str)
-
[TODO]
インスタンスメソッド
self == other -> bool
self === other -> bool
eql?(other) -> bool
-
自身と other が同じ数のキーを保持し、キーが eql? メソッドで比較して全て等しく、 値が == メソッドで比較して全て等しい場合に真を返します。
- [PARAM] other:
- 自身と比較したい Hash オブジェクトを指定します。
#(出力関数は省略) { 1 => :a } == { 1 => :a } #=> true { 1 => :a } == { 1 => :a, 2 => :b } #=> false { 1 => :a } == { 1.0 => :a } #=> false ( 1.eql?(1.0) は false なので) { :x => 1 } == { :x => 1.0 } #=> true ( 1 == 1.0 は true なので)
[SEE_ALSO] Hash#equal?
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[key] -> object | nil
-
key に関連づけられた値を返します。
該当するキーが登録されていない時には、デフォルト値を返します。
デフォルト値と値としての nil を区別する必要が ある場合は Hash#fetch または Hash#has_key? を使ってください。
- [PARAM] key:
- 探索するキーを指定します。
h = {:ab => "some" , :cd => "all"} p h[:ab] #=> "some" p h[:ef] #=> nil h1 = Hash.new("default value") p h1[:non] #=> "default value" h2 = Hash.new {|*arg| arg} p h2[:non] #=> [{}, :non]
[SEE_ALSO] Hash.new, Hash#fetch,Hash#values_at,Hash#has_key?, Hash#default, Hash#default_proc
self[key] = value
store(key, value) -> object
-
key に対して value を関連づけます。value を返し ます。
- [PARAM] key:
- キーを指定します。
- [PARAM] value:
- 値を指定します。
h = {} h[:key] = "value" p h #=>{:key => "value"}
[SEE_ALSO] Hash#[]
__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
add(key, value)
-
[TODO]
all? -> bool
all? {|item| ... } -> bool
-
すべての要素が真である場合に true を返します。 偽である要素があれば、ただちに false を返します。
ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果 が真である場合に true を返します。ブロックが偽を返した時点で、 ただちに false を返します。
例:
# すべて正の数か? p [5, 6, 7].all? {|v| v > 0 } # => true p [5, -1, 7].all? {|v| v > 0 } # => false
any? -> bool
any? {|item| ... } -> bool
-
すべての要素が偽である場合に false を返します。 真である要素があれば、ただちに true を返します。
ブロックを伴う場合は、各要素に対してブロックを評価し、すべての結果 が偽である場合に false を返します。ブロックが真を返した時点 で、ただちに true を返します。
例:
p [1, 2, 3].any? {|v| v > 3 } # => false p [1, 2, 3].any? {|v| v > 1 } # => true
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?
clear -> self
-
ハッシュの中身を空にします。
空にした後のselfを返します。 デフォルト値の設定はクリアされません。
h = Hash.new("default value") h[:some] = "some" p h #=> {:some=>"some"} h.clear p h #=> {} p h.default #=> "default value"
clone -> Hash
dup -> Hash
-
selfと同じ内容を持つ新しいハッシュを返します。
clone は frozen tainted singleton-class の情報も含めてコピーしますが、 dup は内容だけをコピーします。 またどちらのメソッドも要素それ自体のコピーはしません。つまり参照しているオブジェクトが 変わらない「浅い(shallow)」コピーを行います。
h1 = {"have" => "have a","as" => "as a" } h2 = h1.dup h2["have"] = "has" p h2 #=> {"have"=>"has", "as"=>"as a"} p h1 #=> {"have"=>"have a", "as"=>"as a"} h2["as"].upcase! p h2 #=> {"have"=>"has", "as"=>"AS A"} p h1 #=> {"have"=>"have a", "as"=>"AS A"}
[SEE_ALSO] Object#clone
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"]
collect {|item| ... } -> [object]
map {|item| ... } -> [object]
-
各要素に対してブロックを評価した結果を全て含む配列を返します。
ブロックを省略した場合、 obj.collect {|item| item } を実行します。 これは Enumerable#to_a と同じです。
例:
# すべて 3 倍にする p [1, 2, 3].map {|n| n * 3 } # => [3, 6, 9]
count -> Integer
count(item) -> Integer
count {|obj| ... } -> Integer
-
レシーバの要素数を返します。
引数を指定しない場合は、レシーバの要素数を返します。 このとき、レシーバが size メソッドを持っていればそちらを使用します。 レシーバが size メソッドを持っていない場合は、要素数を一つずつカウントします。
引数を一つ指定した場合は、レシーバの要素のうち引数に一致するものの 個数をカウントして返します(一致は == で判定します)。
ブロックを指定した場合は、ブロックを評価して真になった要素の個数を カウントして返します。
- [PARAM] item:
- カウント対象となる値。
例:
ary = [1, 2, 4, 2] ary.count # => 4 ary.count(2) # => 2 ary.count{|x|x%2==0} # => 3
cycle(n=nil) -> Enumerable::Enumerator
cycle(n=nil) {|obj| ... } -> object | nil
-
Enumerable オブジェクトの各要素を n 回 or 無限回(n=nil)繰り返し ブロックを呼びだします。
n に 0 もしくは負の値を渡した場合は何もしません。 繰り返しが最後まで終了した場合(つまりbreakなどで中断しなかった場合) は nil を返します。 このメソッドは内部の配列に各要素を保存しておくため、 一度 Enumerable の終端に到達した後に自分自身を変更しても このメソッドの動作に影響を与えません。
a = ["a", "b", "c"] a.cycle {|x| puts x } # print, a, b, c, a, b, c,.. forever. a.cycle(2) {|x| puts x } # print, a, b, c, a, b, c.
- [RETURN]
- ブロックを指定しなかった場合は、Enumerable::Enumerator を返します。 レシーバが空の場合は nil を返します。
default -> object | nil
default(key) -> object | nil
-
ハッシュのデフォルト値を返します。
ハッシュのデフォルト値がブロックで与えられている場合、 1 番目の形式だと 返り値が nil になることに注意してください。この場合、ハッシュのデフォルト値に ついて調べるには 2 番目の形式か Hash#default_proc を使ってください。
2 番目の形式はハッシュがデフォルト値としてブロックを持つ場合に、 self と引数 key をブロックに渡して評価し、その結果を返します。
- [PARAM] key:
- デフォルトのブロックにキーとして渡されます。
h = Hash.new("default") p h.default #=> "default" p h.default(:some) #=> "default" p h #=>{} h = Hash.new{|hash, key| hash[key] ="default" } p h.default #=> nil p h.default(:some) #=> "default" p h #=> {:some=>"default"} h = Hash.new p h.default #=> nil p h.default(:some) #=> nil p h #=> {}
[SEE_ALSO] Hash#default=, Hash#default_proc
default=(value)
-
ハッシュのデフォルト値を value に変更します。対応する値が存 在しないキーで検索した時にはこの値を返すようになります。
デフォルト値(ブロックを含む)が既に設定してあった場合も value で上書きします。
- [PARAM] value:
- 設定するデフォルト値です。
- [RETURN]
- value を返します。
h = {} p h.default #=>nil h.default = "default" p h.default #=>"default"
[SEE_ALSO] Hash#default
default_proc -> Proc | nil
-
ハッシュのデフォルト値を返す Proc オブジェクトを返します。 ハッシュがブロック形式のデフォルト値を持たない場合 nil を返します。
h = Hash.new {|hash, key| "The #{key} not exist in #{hash.inspect}"} p h.default #=> nil p block = h.default_proc #=> #<Proc:0x0x401a9ff4> p block.call({},:foo) #=> "The foo not exist in {}" h = Hash.new("default") p h.default #=> "default" p h.default_proc #=> nil
[SEE_ALSO] Hash#default
delete(key) -> object | nil
delete(key) {|key| ... } -> object
-
key に対応する要素を取り除きます。
- [PARAM] key:
- 取り除くキーを指定します。
- [RETURN]
- 取り除かれた要素の値を返します。 key に対応する要素が存在しない時には nil を返します。 与えられたブロックは key にマッチする要素がなかった時に評価され、その結果を返します。
h = {:ab => "some" , :cd => "all"} p h.delete(:ab) #=> "some" p h.delete(:ef) #=> nil p h.delete(:ef){|key|"#{key} Nothing"} #=> "ef Nothing" p h #=> {:cd=>"all"}
[SEE_ALSO] Hash#delete_if
delete_if -> Enumerable::Enumerator
reject! -> Enumerable::Enumerator
delete_if {|key, value| ... } -> self
reject! {|key, value| ... } -> self|nil
-
キーと値を引数としてブロックを評価した結果が真であ るような要素を self から削除します。
delete_if は常に self を返します。 reject! は、要素を削除しなかった場合には nil を返し、 そうでなければ self を返します。
ブロックを省略した場合は Enumerable::Enumerator を返します。
h = { 2 => "8" ,4 => "6" ,6 => "4" ,8 => "2" } p h.reject!{|key, value| key.to_i < value.to_i } #=> { 6 => "4", 8 => "2" } p h #=> { 6 => "4", 8 => "2" } p h.delete_if{|key, value| key.to_i < value.to_i } #=> { 6 => "4", 8 => "2" } p h.reject!{|key, value| key.to_i < value.to_i } #=> nil
[SEE_ALSO] Hash#reject,Hash#delete
find(ifnone = nil) -> Enumerable::Enumerator
detect(ifnone = nil) -> Enumerable::Enumerator
find(ifnone = nil) {|item| ... } -> object
detect(ifnone = nil) {|item| ... } -> object
-
要素に対してブロックを評価した値が真になった最初の要素を返します。
真になる要素が見つからず、ifnone も指定されていないときは nil を返します。 真になる要素が見つからず、ifnone が指定されているときは ifnone を call した結果を返します。
- [PARAM] ifnone:
- call メソッドを持つオブジェクト (例えば Proc) を指定します。
例:
# 最初の 3 の倍数を探す p [1, 2, 3, 4, 5].find {|i| i % 3 == 0 } # => 3 p [2, 2, 2, 2, 2].find {|i| i % 3 == 0 } # => nil # ifnone の使用例 ifnone = proc { raise ArgumentError, "item not found" } p [1, 2, 3, 4, 5].find(ifnone) {|i| i % 7 == 0 } # ArgumentError: item not found
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
drop(n) -> Array
-
Enumerable オブジェクトの先頭の n 要素を捨てて、 残りの要素を配列として返します。
- [PARAM] n:
- 捨てる要素数。
a = [1, 2, 3, 4, 5, 0] a.drop(3) # => [4, 5, 0]
drop_while -> Enumerable::Enumerator
drop_while {|element| ... } -> Array
-
ブロックを評価して最初に偽となった要素の手前の要素まで捨て、 残りの要素を配列として返します。
ブロックを指定しなかった場合は、Enumerable::Enumerator を返します。
a = [1, 2, 3, 4, 5, 0] a.drop_while {|i| i < 3 } # => [3, 4, 5, 0]
each {|key, value| ... } -> self
each_pair {|key, value| ... } -> self
each -> Enumerable::Enumerator
each_pair -> Enumerable::Enumerator
-
ハッシュのキーと値を引数としてブロックを評価します。
反復の際の評価順序は不定です。 ブロック付きの場合 self を、 無しで呼ばれた場合 Enumerable::Enumerator を返します。
each と each_pair ではブロック引数の受渡し方が異なります。 each は キーと値の配列を1引数で、each_pair は別々に2引数でブロックに値を渡します。 これによりブロック引数をひとつだけ指定した場合の挙動が異なります。 ブロック引数を2つ指定するようにすれば同じ挙動になります。
{:a=>1, :b=>2}.each {|a| p a} #=> [:a, 1] [:b, 2] {:a=>1, :b=>2}.each_pair {|*a| p a} #明示的に配列で受ける #=> [:a, 1] [:b, 2] {:a=>1, :b=>2}.each {|k, v| p [k, v]} #each_pairでも同じ結果 #=> [:a, 1] [:b, 2]
each_pair は each のエイリアスです。
{:a=>1, :b=>2}.each {|a| p a} #=> [:a, 1] [:b, 2] {:a=>1, :b=>2}.each_pair {|*a| p a} #=> [[:a, 1]] [[:b, 2]] {:a=>1, :b=>2}.each {|k, v| p [k, v]} #each_pairでも同じ結果 #=> [:a, 1] [:b, 2] p({:a=>1, :b=>2}.each_pair) # => #<Enumerable::Enumerator:0xbb19e4>
[SEE_ALSO] Hash#each_key,Hash#each_value
each_cons(n) -> Enumerable::Enumerator
enum_cons(n) -> Enumerable::Enumerator
each_cons(n) {|list| ... } -> nil
enum_cons(n) {|list| ... } -> nil
-
要素を重複ありで n 要素ずつに区切り、 ブロックに渡して繰り返します。
enum_cons は 1.9.1 以降ではなくなっています。 代わりに each_cons を使ってください。
- [PARAM] n:
- ブロックに渡す要素の数です。正の整数を与えます。 要素数より大きな数を与えると、ブロックは一度も実行されません。
例:
(1..10).each_cons(3){|v| p v } # => [1, 2, 3] # [2, 3, 4] # [3, 4, 5] # [4, 5, 6] # [5, 6, 7] # [6, 7, 8] # [7, 8, 9] # [8, 9, 10]
[SEE_ALSO] Enumerable#each_slice
each_key {|key| ... } -> self
each_key -> Enumerable::Enumerator
-
ハッシュのキーを引数としてブロックを評価します。
反復の際の評価順序は不定です。 ブロック付きの場合selfを、 無しで呼ばれた場合Enumerable::Enumeratorを返します。
{:a=>1, :b=>2}.each_key {|k| p k} #=> :a :b p({:a=>1, :b=>2}.each_key) #=> #<Enumerable::Enumerator:0xbb19e4>
[SEE_ALSO] Hash#each_pair,Hash#each_value
each_slice(n) -> Enumerable::Enumerator
enum_slice(n) -> Enumerable::Enumerator
each_slice(n) {|list| ... } -> nil
enum_slice(n) {|list| ... } -> nil
-
n 要素ずつブロックに渡して繰り返します。
要素数が n で割り切れないときは、最後の回だけ要素数が減ります。
enum_slice は 1.9.1 以降ではなくなっています。 代わりに each_slice を使ってください。
- [PARAM] n:
- 区切る要素数を示す整数です。
例:
(1..10).each_slice(3) {|a| p a} # => [1, 2, 3] # [4, 5, 6] # [7, 8, 9] # [10]
[SEE_ALSO] Enumerable#each_cons
each_value {|value| ... } -> self
each_value -> Enumerable::Enumerator
-
ハッシュの値を引数としてブロックを評価します。
反復の際の評価順序は不定です。 ブロック付きの場合selfを、 無しで呼ばれた場合 Enumerable::Enumerator を返します。
{:a=>1, :b=>2}.each_value {|v| p v} #=> 1 2 p({:a=>1, :b=>2}.each_value) #=> #<Enumerable::Enumerator:0xbb19e4>
[SEE_ALSO] Hash#each_pair,Hash#each_key
each_with_index -> Enumerable::Enumerator
enum_with_index -> Enumerable::Enumerator
each_with_index {|item, index| ... } -> self
-
要素とそのインデックスをブロックに渡して繰り返します。
self を返します。
例:
[5, 10, 15].each_with_index do |n, idx| p [n, idx] end # => [5, 0] # [10, 1] # [15, 2]
empty? -> bool
-
ハッシュが空の時真を返します。
puts({}.empty?) #=> true
to_a -> [object]
entries -> [object]
-
全ての要素を含む配列を返します。
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 が等しければ真を返します。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 自身である場合のみ真を返します。
- [PARAM] other:
- 自身と比較したい Hash オブジェクトを指定します。
p({}.equal?({})) #=> false a = {} p a.equal?(a) #=> true
[SEE_ALSO] Hash#==
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
fetch(key, default = nil) {|key| ... } -> object
-
key に関連づけられた値を返します。該当するキーが登録されてい ない時には、引数 default が与えられていればその値を、ブロッ クが与えられていればそのブロックを評価した値を返します。
fetchはハッシュ自身にデフォルト値が設定されていても単に無視します(挙動に変化がありません)。
- [PARAM] key:
- 探索するキーを指定します。
- [PARAM] default:
- 該当するキーが登録されていない時の返り値を指定します。
- [EXCEPTION] IndexError:
- 引数defaultもブロックも与えられてない時、キーの探索に失敗すると発生します。
h = {:one => nil} p h[:one],h[:two] #=> nil,nil これではキーが存在するのか判別できない。 p h.fetch(:one) #=> nil p h.fetch(:two) # エラー key not found (KeyError) p h.fetch(:two,"error") #=> "error" p h.fetch(:two){|key|"#{key} not exist"} #=> "two not exist" p h.fetch(:two, "error"){|key| #=> "two not exist" "#{key} not exit" # warning: block supersedes default value argument } # 警告が表示される。 h.default = "default" p h.fetch(:two) # エラー key not found (KeyError)
[SEE_ALSO] Hash#[]
find_all -> Enumerable::Enumerator
select -> Enumerable::Enumerator
find_all {|item| ... } -> [object]
select {|item| ... } -> [object]
-
各要素に対してブロックを評価した値が真であった要素を全て含む配列を 返します。真になる要素がひとつもなかった場合は空の配列を返します。
find_index -> Enumerable::Enumerator
find_index {|obj| ... } -> Integer | nil
-
要素を先頭から順にブロックに渡して評価し、最初に真になった要素のインデックスを返します。 一つも真にならなければ nil を返します。
(1..10).find_index {|i| i % 5 == 0 and i % 7 == 0 } #=> nil (1..100).find_index {|i| i % 5 == 0 and i % 7 == 0 } #=> 34
ブロックを指定しなかった場合は、Enumerable::Enumerator を返します。
first -> object | nil
first(n) -> Array
-
Enumerable オブジェクトの最初の要素、もしくは最初の n 要素を返します。
Enumerable オブジェクトが空の場合、引数を指定しない形式では nil を返します。 引数を指定する形式では、空の配列を返します。
- [PARAM] n:
- 取得する要素数。
e = "abcd".each_byte e.first #=> 97 e.first(2) #=> [97,98] e = "".each_byte e.first #=> nil e.first(2) #=> []
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
grep(pattern) -> [object]
grep(pattern) {|item| ... } -> [object]
-
pattern === item が成立する要素を全て含んだ配列を返します。
ブロックとともに呼び出された時には条件の成立した要素に対して それぞれブロックを評価し、その結果の配列を返します。 マッチする要素がひとつもなかった場合は空の配列を返します。
- [PARAM] pattern:
- 「===」メソッドを持つオブジェクトを指定します。
例:
['aa', 'bb', 'cc', 'dd', 'ee'].grep(/[bc]/) # => ["bb", "cc"] Array.instance_methods.grep(/gr/) # => ["group_by", "grep"]
group_by -> Enumerable::Enumerator
group_by {|obj| ... } -> Hash
-
ブロックを評価した結果をキー、対応する要素の配列を値とするハッシュを返します。
(1..6).group_by {|i| i%3} #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
has_key?(key) -> bool
include?(key) -> bool
key?(key) -> bool
member?(key) -> bool
-
ハッシュが key をキーとして持つ時真を返します。
- [PARAM] key:
- 探索するキーを指定します。
p({1 => "one"}.has_key?(1)) #=> true p({1 => "one"}.has_key?(2)) #=> false
[SEE_ALSO] Hash#has_value?
has_value?(value) -> bool
value?(value) -> bool
-
ハッシュが value を値として持つ時真を返します。 値の一致判定は == で行われます。
- [PARAM] value:
- 探索する値を指定します。
p({1 => "one"}.has_value?("one")) #=> true p({1 => "one"}.has_value?("two")) #=> false
[SEE_ALSO] Hash#has_key?
hash -> Integer
-
自身の Object#object_id を返します。これは Object クラスで定義されたデフォルトの動作です。 メソッド hash の返り値は自身が保持するキーや値に影響されません。
a = {} p a.hash #=> 538688380 a[1] = :a p a.hash #=> 538688380
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__
member?(val) -> bool
include?(val) -> bool
-
val と == の関係にある要素を含むとき真を返します。
- [PARAM] val:
- 任意のオブジェクト
index(val) -> object
-
値 val に対応するキーを返します。対応する要素が存在しない時には nil を返します。
該当するキーが複数存在する場合、どのキーを返すかは不定です。
Hash#index は 次バージョンの1.9では((<obsolete>)) です。 使用すると警告メッセージが表示されます。
- [PARAM] val:
- 探索に用いる値を指定します。
h = {:ab => "some" , :cd => "all" , :ef => "all"} p h.index("some") #=> :ab p h.index("all") #=> :cd p h.index("at") #=> nil
[SEE_ALSO] Hash#invert
indexes(*keys) -> [object]
indices(*keys) -> [object]
-
引数で指定されたキーに対応する値の配列を返します。
このメソッドは ((<obsolete>)) です。 使用すると警告メッセージが表示されます。 代わりに Hash#values_at を使用してください。
- [PARAM] keys:
- キーを任意個指定します。
[SEE_ALSO] Hash#values_at,Hash#[]
inject(init = self.first) {|result, item| ... } -> object
inject(sym) -> object
inject(init, sym) -> object
reduce(init = self.first) {|result, item| ... } -> object
reduce(sym) -> object
reduce(init, sym) -> object
-
リストのたたみこみ演算を行います。
最初に初期値 init と self の最初の要素を引数にブロックを実行します。 2 回目以降のループでは、前のブロックの実行結果と self の次の要素を引数に順次ブロックを実行します。 そうして最後の要素まで繰り返し、最後のブロックの実行結果を返します。
要素が存在しない場合は init を返します。
初期値 init を省略した場合は、 最初に先頭の要素と 2 番目の要素をブロックに渡します。 また要素が 1 つしかなければブロックを実行せずに最初の要素を返します。 要素がなければブロックを実行せずに nil を返します。
- [PARAM] init:
- 最初の result の値です。任意のオブジェクトが渡せます。
- [PARAM] sym:
- ブロックの代わりに使われるメソッド名を表す Symbol オブジェクトを指定します。 実行結果に対して sym という名前のメソッドが呼ばれます。
例:
# 合計を計算する。 p [2, 3, 4, 5].inject {|result, item| result + item } #=> 14 # 自乗和を計算する。初期値をセットする必要がある。 p [2, 3, 4, 5].inject(0) {|result, item| result + item**2 } #=> 54
この式は以下のように書いても同じ結果が得られます。
result = 0 [1, 2, 3, 4, 5].each {|v| result += v } p result # => 15 p [1, 2, 3, 4, 5].inject(:+) #=> 15 p ["b", "c", "d"].inject("abbccddde", :squeeze) #=> "abcde"
inspect -> String
-
ハッシュの内容を人間に読みやすい文字列にして返します。
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 } h.inspect # => "{\"a\"=>100, \"c\"=>300, \"d\"=>400}"
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
invert -> Hash
-
値からキーへのハッシュを作成して返します。
異なるキーに対して等しい値が登録されている場合の結果は不定であることに 注意してください、そのような場合にこのメソッドを利用することは意図され ていません。
h = { "a" => 0, "b" => 100, "c" => 200, "d" => 300, "e" => 300 } p h.invert #=> {0=>"a", 100=>"b", 200=>"c", 300=>"e"}
参考
値が重複していたときに備えて、変換後の値を配列として保持するには、次のようにします。
def safe_invert(orig_hash) result = Hash.new{|h,key| h[key] = [] } orig_hash.each{|key, value| result[value] << key } result end p safe_invert({"a"=>1, "b"=>1, "c"=>3}) #=> {1=>["a", "b"], 3=>["c"]} #転載:Rubyレシピブック No.120
[SEE_ALSO] Hash#index
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
keys -> [object]
-
全キーの配列を返します。
h1 = { "a" => 100, 2 => ["some"], :c => "c" } p h1.keys #=> ["a", 2, :c]
[SEE_ALSO] Hash#values,Hash#to_a
length -> Integer
size -> Integer
-
ハッシュの要素の数を返します。
puts({:ant => 9 ,:dog => 101 ,:cat => 3}.length) #=> 3
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
max -> object
-
最大の要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。
要素が存在しなければ nil を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。
max {|a, b| ... } -> object
-
ブロックの評価結果で各要素の大小判定を行い、最大の要素を返します。 要素が存在しなければ nil を返します。
ブロックの値は、a > b のとき正、 a == b のとき 0、a < b のとき負の整数を、期待しています。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
- [EXCEPTION] TypeError:
- ブロックが整数以外を返したときに発生します。
max_by -> Enumerable::Enumerator
max_by {|item| ... } -> object
-
各要素を順番にブロックに渡して実行し、 その評価結果を <=> で比較して、 最大であった値に対応する元の要素を返します。
要素が存在しないときは nil を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。
Enumerable#max と Enumerable#max_by の 違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。
[SEE_ALSO] Enumerable#sort_by
merge(other) -> Hash
merge(other) {|key, self_val, other_val| ... } -> Hash
merge!(other) -> self
merge!(other) {|key, self_val, other_val| ... } -> self
-
selfとotherのハッシュの内容をマージ(統合)した結果を返します。デフォルト値はselfの設定のままです。
self と other に同じキーがあった場合はブロック付きか否かで 判定方法が違います。ブロック付きのときはブロックを呼び出して その返す値を重複キーに対応する値にします。ブロック付きでない 場合は常に other の値を使います。
Hash#merge! は、マージの結果でselfを変更する破壊的メソッドで、Hash#update の別名です。
otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
- [PARAM] other:
- マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
- [RETURN]
- マージした結果を返します
foo = {1 => 'a', 2 => 'b', 3 => 'c'} bar = {2 => 'B', 3 => 'C', 4 => 'D'} p foo.merge(bar) #=> {1=>"a", 2=>"B", 3=>"C", 4=>"D"} p foo #=> {1=>"a", 2=>"b", 3=>"c"} p foo.merge!(bar) {|key, foo_val, bar_val| foo_val + bar_val } #=> {1=>"a", 2=>"bB", 3=>"cC", 4=>"D"} p foo #=> {1=>"a", 2=>"bB", 3=>"cC", 4=>"D"} class Foo def to_hash {:Australia => 'Sydney', :France => 'Paris' } end end h = {:Germany => 'Berlin', :Australia => 'Canberra', :France => 'Paris' } h.merge!(Foo.new) #暗黙の変換 p h #=> {:Germany=>"Berlin", :Australia=>"Sydney", :France=>"Paris"}
[SEE_ALSO] Hash#update,Hash#replace
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 -> object
-
最小の要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。
要素が存在しなければ nil を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。
min {|a, b| ... } -> object
-
ブロックの評価結果で各要素の大小判定を行い、最小の要素を返します。 要素が存在しなければ nil を返します。
ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
- [EXCEPTION] TypeError:
- ブロックが整数以外を返したときに発生します。
min_by -> Enumerable::Enumerator
min_by {|item| ... } -> object
-
各要素を順番にブロックに渡して評価し、 その評価結果を <=> で比較して、 最小であった値に対応する元の要素を返します。
要素が存在しないときは nil を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
Enumerable#min と Enumerable#min_by の 違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。
[SEE_ALSO] Enumerable#sort_by
minmax -> [object, object]
minmax {|a, b| ... } -> [object, object]
-
Enumerable オブジェクトの各要素のうち最小の要素と最大の要素を 要素とするサイズ 2 の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
一つ目の形式は、Enumerable オブジェクトのすべての要素が Comparable を 実装していることを仮定しています。二つ目の形式では、要素同士の比較を ブロックを用いて行います。
a = %w(albatross dog horse) a.minmax #=> ["albatross", "horse"] a.minmax{|a,b| a.length <=> b.length } #=> ["dog", "albatross"] [].minmax # => [nil, nil]
[SEE_ALSO] Enumerable#sort
minmax_by -> Enumerable::Enumerator
minmax_by {|obj| ... } -> [object, object]
-
Enumerable オブジェクトの各要素をブロックに渡して評価し、その結果を <=> で比較して 最小の要素と最大の要素を要素とするサイズ 2 の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
Enumerable#minmax と Enumerable#minmax_by の 違いは sort と sort_by の違いと同じです。 詳細は Enumerable#sort_by を参照してください。
a = %w(albatross dog horse) a.minmax_by {|x| x.length } #=> ["dog", "albatross"] [].minmax_by{} # => [nil, nil]
[SEE_ALSO] Enumerable#sort_by
nil? -> bool
-
レシーバが nil であれば真を返します。
p false.nil? #=> false p nil.nil? #=> true
[SEE_ALSO] NilClass
none? -> bool
none? {|obj| ... } -> bool
-
ブロックを指定しない場合は、 Enumerable オブジェクトのすべての 要素が偽であれば真を返します。そうでなければ偽を返します。
ブロックを指定した場合は、Enumerable オブジェクトのすべての要素を ブロックで評価した結果が、すべて偽であれば真を返します。 そうでなければ偽を返します。
%w{ant bear cat}.none? {|word| word.length == 5} #=> true %w{ant bear cat}.none? {|word| word.length >= 4} #=> false [].none? #=> true [nil].none? #=> true [nil,false].none? #=> true
one? -> bool
one? {|obj| ... } -> bool
-
ブロックを指定しない場合は、 Enumerable オブジェクトの要素のうち ちょうど一つだけが真であれば、真を返します。 そうでなければ偽を返します。
ブロックを指定した場合は、Enumerable オブジェクトの要素を ブロックで評価した結果、一つの要素だけが真であれば真を返します。 そうでなければ偽を返します。
%w{ant bear cat}.one? {|word| word.length == 4} #=> true %w{ant bear cat}.one? {|word| word.length >= 4} #=> false [ nil, true, 99 ].one? #=> false [ nil, true, false ].one? #=> true
parse(str)
-
[TODO]
parse_line(line)
-
[TODO]
parse_rhs(str)
-
[TODO]
partition -> Enumerable::Enumerator
partition {|item| ... } -> [[object], [object]]
-
各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。 各要素に対してブロックを評価して、その値が真であった要素の配列と、 偽であった要素の配列の 2 つを配列に入れて返します。
例:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0].partition {|i| i % 3 == 0 } #=> [[9, 6, 3, 0], [10, 8, 7, 5, 4, 2, 1]]
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
rehash -> self
-
キーのハッシュ値を再計算します。
キーになっているオブジェクトの内容が変化した時など、 ハッシュ値が変わってしまった場合はこのメソッドを使ってハッシュ値を再計算しない 限り、そのキーに対応する値を取り出すことができなくなります。
- [EXCEPTION] RuntimeError:
- Hash#eachなどのイテレータの評価途中でrehashすると発生します。
- [RETURN]
- selfを返します。
a = [ "a", "b" ] h = { a => 100 } p h[a] #=> 100 a[0] = "z" p h[a] #=> nil h.rehash p h[a] #=> 100
[SEE_ALSO] Object#hash
reject {|key, value| ... } -> Hash
reject -> Enumerable::Enumerator
-
self を複製して、ブロックを評価した値が真になる要 素を削除したハッシュを返します。
ハッシュを返すことを除けば Enumerable#reject とほぼ同じです。 selfを破壊的に変更したい場合はかわりにHash#delete_ifかHash#reject!を使います。
h = { 2 =>"8" ,4 =>"6" ,6 =>"4" ,8 =>"2" } p h.reject{|key, value| key.to_i < value.to_i} #=> {6=>"4", 8=>"2"}
[SEE_ALSO] Hash#delete_if,Hash#delete,Enumerable#reject
reject -> Enumerable::Enumerator
reject {|item| ... } -> [object]
-
各要素に対してブロックを評価し、 その値が偽であった要素を集めた新しい配列を返します。 条件を反転させた select です。
例:
# 偶数を除外する (奇数を集める) [1, 2, 3, 4, 5, 6].reject {|i| i % 2 == 0 } # => [1, 3, 5]
[SEE_ALSO] Enumerable#select
replace(other) -> self
-
ハッシュの内容を other の内容で置き換えます。
デフォルト値の設定もotherの内容になります。 otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
self = other.to_hash.dup と同じです。
- [PARAM] other:
- ハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
- [RETURN]
- self を返します。
foo = {1 => 'a', 2 => 'b'} bar = {2 => 'B', 3 => 'C'} foo.replace(bar) p foo #=> {2=>"B", 3=>"C"} zoo = {} zoo = bar.dup p zoo #=> {2=>"B", 3=>"C"} class Foo def to_hash {:japan => 'kyoto'} end end h = Hash.new h.replace(Foo.new) #暗黙の変換 p h #=> {:japan=>"kyoto"}
[SEE_ALSO] Hash#dup,Hash#merge,Object#to_hash
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?
reverse_each -> Enumerable::Enumerator
reverse_each {|element| ... } -> self
-
逆順に各要素に対してブロックを評価します。
内部で各要素を保持した配列を作ります。
select -> Enumerable::Enumerator
select {|key, value| ... } -> Array
-
key, value のペアについてブロックを評価し、真となるペアだけを含む 配列を生成して返します。
生成される配列は、[key, value] を要素とする配列です。
h = { "a" => 100, "b" => 200, "c" => 300 } h.select {|k,v| k > "a"} #=> [["b", 200], ["c", 300]] h.select {|k,v| v < 200} #=> [["a", 100]]
shift -> [object, object]
-
ハッシュから要素をひとつ取り除き、[key, value]という配列とし て返します。shiftがどの要素を返すかは不定です。
shiftは破壊的メソッドです。selfは要素を取り除かれた残りのハッシュに変更されます。
ハッシュが空の場合、デフォルト値(Hash#defaultまたはHash#default_procのブロックの値か、どちらもnilならばnil) を返します(このとき、[key,value] という形式の値を返すわけではないことに注意)。
h = {:ab => "some" , :cd => "all"} p h.shift #=> [:ab, "some"] p h.shift #=> [:cd, "all"] p h #=> {} p h.shift #=> nil h1 = Hash.new("default value") p h1 #=> {} p h1.shift #=> "default value" h2 = Hash.new {|*arg| arg} p h2 #=> {} p h2.shift #=> [{}, nil]
[SEE_ALSO] Array#shift
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
sort -> Array
sort {|a, b| ... } -> Array
-
ハッシュを [key, value] を要素とする配列の配列に変換して,それをソー トした配列を返します。
h = { "a" => 20, "b" => 30, "c" => 10 } h.sort #=> [["a", 20], ["b", 30], ["c", 10]] h.sort {|a,b| a[1]<=>b[1]} #=> [["c", 10], ["a", 20], ["b", 30]]
[SEE_ALSO] Array#sort
sort -> [object]
sort {|a, b| ... } -> [object]
-
全ての要素を昇順にソートした配列を生成して返します。
ブロックなしのときは <=> メソッドを要素に対して呼び、 その結果をもとにソートします。
<=> 以外でソートしたい場合は、ブロックを指定します。 この場合、ブロックの評価結果を元にソートします。 ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。 ブロックが整数以外を返したときは例外 TypeError が発生します。
Enumerable#sort は安定ではありません (unstable sort)。 安定なソートが必要な場合は Enumerable#sort_by を使って工夫する必要があります。 詳しくは Enumerable#sort_by の項目を参照してください。
※ 比較結果が同じ要素は元の順序通りに並ぶソートを 「安定なソート (stable sort)」と言います。
[SEE_ALSO] Enumerable#sort_by
sort_by -> Enumerable::Enumerator
sort_by {|item| ... } -> [object]
-
ブロックの評価結果を <=> メソッドで比較することで、self を昇 順にソートします。ソートされた配列を新たに生成して返します。
つまり、以下とほぼ同じ動作をします。
class Array def sort_by self.map {|i| [yield(i), i] }. sort {|a, b| a[0] <=> b[0] }. map {|i| i[1]} end end
Enumerable#sort と比較して sort_by が優れている点として、 比較条件が複雑な場合の速度が挙げられます。 sort_by を使わない以下の例では比較を行う度に downcase が実行されます。 従って downcase の実行速度が遅ければ sort の速度が致命的に低下します。
p ["BAR", "FOO", "bar", "foo"].sort {|a, b| a.downcase <=> b.downcase }
一方、次のように sort_by を使うと downcase の実行回数は要素数と同じです。 つまり、その部分の実行時間は O(n) のオーダーです。
p ["BAR", "FOO", "bar", "foo"].sort_by {|v| v.downcase }
以下の、実行回数の検証結果を参照してみてください。
class Integer def count $n += 1 self end end ary = [] 1.upto(1000) {|v| ary << rand(v) } $n = 0 ary.sort {|a,b| a.count <=> b.count } p $n # => 18200 $n = 0 ary.sort_by {|v| v.count } p $n # => 1000
Enumerable#sort_by は安定ではありません (unstable sort)。 ただし、sort_by を以下のように使うと安定なソートを実装できます。
i = 0 ary.sort_by {|v| [v, i += 1] }
※ 比較結果が同じ要素は元の順序通りに並ぶソートを 「安定なソート (stable sort)」と言います。
[SEE_ALSO] Enumerable#sort
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
take(n) -> Array
-
Enumerable オブジェクトの先頭から n 要素を配列として返します。
- [PARAM] n:
- 要素数を指定します。
a = [1, 2, 3, 4, 5, 0] a.take(3) # => [1, 2, 3]
take_while -> Enumerable::Enumerator
take_while {|element| ... } -> Array
-
Enumerable オブジェクトの要素を順に偽になるまでブロックで評価します。 最初に偽になった要素の手前の要素までを配列として返します。
a = [1, 2, 3, 4, 5, 0] a.take_while {|i| i < 3 } # => [1, 2]
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]
-
キーと値からなる 2 要素の配列を並べた配列を生成して返します。
h1 = { "a" => 100, 2 => ["some"], :c => "c" } p h1.to_a #=> [["a", 100], [2, ["some"]], [:c, "c"]]
[SEE_ALSO] Hash#keys,Hash#values
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_hash -> self
-
self を返します。
[SEE_ALSO] Object#to_hash
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_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
-
[TODO]
to_s -> String
-
ハッシュの内容を self.to_a.to_s で文字列化して返します。
h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 } h.to_s # => "a100c300d400"
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
untaint -> self
-
オブジェクトの「汚染マーク」を取り除きます。
汚染マークを取り除くことによる危険性はプログラマが責任を負う必要が あります。
オブジェクトの汚染に関してはセキュリティモデルを参照してください。
- [EXCEPTION] SecurityError:
- セキュリティレベルが3以上の時にこのメソッドを使用すると発生します。
[SEE_ALSO] Object#taint,Object#tainted?
update(other) -> self
update(other) {|key, self_val, other_val| ... } -> self
-
selfとotherのハッシュの内容をマージ(統合)します。Hash#merge!と同じです。
デフォルト値はselfの設定のままです。 otherがハッシュではない場合、otherのメソッドto_hashを使って暗黙の変換を試みます。
- [PARAM] other:
- マージ用のハッシュまたはメソッド to_hash でハッシュに変換できるオブジェクトです。
- [RETURN]
- マージ後のselfを返します。
foo = {1 => 'a', 2 => 'b', 3 => 'c'} bar = {2 => 'B', 3 => 'C', 4 => 'D'} p foo.update(bar) #=> {1=>"a", 2=>"B", 3=>"C", 4=>"D"} p foo #=> {1=>"a", 2=>"B", 3=>"C", 4=>"D"} p foo.update(bar) {|key, foo_val, bar_val| foo_val + bar_val } #=> {1=>"a", 2=>"BB", 3=>"CC", 4=>"DD"} p foo #=> {1=>"a", 2=>"BB", 3=>"CC", 4=>"DD"}
[SEE_ALSO] Hash#merge!
values -> [object]
-
ハッシュの全値の配列を返します。
h1 = { "a" => 100, 2 => ["some"], :c => "c" } p h1.values #=> [100, ["some"], "c"]
values_at(*keys) -> [object]
-
引数で指定されたキーに対応する値の配列を返します。
キーに対応する要素がなければデフォルト値が使用されます。
- [PARAM] keys:
- キーを 0 個以上指定します。
- [RETURN]
- 引数で指定されたキーに対応する値の配列を返します。 引数が指定されなかった場合は、空の配列を返します。
h = {1=>"a", 2=>"b", 3=>"c"} p h.values_at(1,3,4) #=> ["a", "c", nil] # [h[1], h[3] ,h[4]] と同じ
[SEE_ALSO] Hash#[], Hash.new, Hash#default, Hash#default_proc, Array#values_at
zip(*lists) -> [[object]]
zip(*lists) {|v1, v2, ...| ...} -> nil
-
self と引数に渡した配列の各要素からなる配列の配列を生成して返します。 生成される配列の要素数は self の要素数と同じです。
ブロック付きで呼び出した場合は、 self と引数に渡した配列の各要素を順番にブロックに渡します。
- [PARAM] lists:
- 配列を指定します。配列でない場合は to_a メソッドにより配列に変換します。
例:
p (1..3).zip([4,5,6], [7,8,9]) # => [[1, 4, 7], [2, 5, 8], [3, 6, 9]] p (1..2).zip([:a,:b,:c], [:A,:B,:C,:D]) # => [[1, :a, :A], [2, :b, :B]] p (1..5).zip([:a,:b,:c], [:A,:B,:C,:D]) # => [[1, :a, :A], [2, :b, :B], # [3, :c, :C], [4, nil, :D], [5, nil, nil]]
例:
p [1,2,3].zip([4,5,6], [7,8,9]) {|ary| p ary } # => [1, 4, 7] # [2, 5, 8] # [3, 6, 9] # nil
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