Ruby 2.2.0 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Enumerableモジュール
クラスの継承リスト: Enumerable
繰り返しを行なうクラスのための Mix-in。このモジュールの メソッドは全て each を用いて定義されているので、インクルード するクラスには each が定義されていなければなりません。
all? -> bool[permalink][rdoc]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
p [].all? {|v| v > 0 } # => true
any? -> bool[permalink][rdoc]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
p [].any? {|v| v > 0 } # => false
chunk {|elt| ... } -> Enumerator[permalink][rdoc]chunk(initial_state) {|elt, state| ... } -> Enumerator要素を前から順にブロックで評価し、その結果によって 要素をチャンクに分けた(グループ化した)要素を持つ Enumerator を返します。
ブロックの評価値が同じ値が続くものを一つのチャンクとして 取り扱います。すなわち、ブロックの評価値が一つ前と 異なる所でチャンクが区切られます。
返り値の Enumerator は各チャンクのブロック評価値と 各チャンクの要素を持つ配列のペアを各要素とします。 そのため、eachだと以下のようになります。
enum.chunk {|elt| key }.each {|key, ary| ... }
enum.chunk(initial_state) {|elt, state| key }.each {|key, ary| ... }
例として、整数列を連続する奇数/偶数に分ける例を見てみます。 「n.even?」の値が切り替わるところで区切られているのがわかるでしょう。
[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5].chunk {|n|
n.even?
}.each {|even, ary|
p [even, ary]
}
#=> [false, [3, 1]]
# [true, [4]]
# [false, [1, 5, 9]]
# [true, [2, 6]]
# [false, [5, 3, 5]]
このメソッドは各要素が既にソートされている場合に便利です。 以下の例では、テキスト辞書ファイル(中身がソートされている) に含まれる単語を先頭の文字ごとに数えています。
# line.ord は先頭の文字のコードポイントを返す
open("/usr/share/dict/words", "r:iso-8859-1") {|f|
f.chunk {|line| line.ord }.each {|ch, lines| p [ch.chr, lines.length] }
}
#=> ["\n", 1]
# ["A", 1327]
# ["B", 1372]
# ["C", 1507]
# ["D", 791]
# ...
さらにこのメソッドは以下の値を特別扱いします。
それ以外のアンダースコアで始まるシンボルを指定した場合は例外が発生します。
items.chunk { |item| :_underscore }
# => RuntimeError: symbols beginning with an underscore are reserved
nil、 :_separator はある要素を無視したい場合に用います。 例として svn log の出力のハイフンの所で区切りたい場合を考えます。
sep = "-"*72 + "\n" # ハイフンが72個の行
IO.popen("svn log README") {|f|
f.chunk {|line|
line != sep || nil
}.each {|_, lines|
pp lines
}
}
#=> ["r20018 | knu | 2008-10-29 13:20:42 +0900 (Wed, 29 Oct 2008) | 2 lines\n",
# "\n",
# "* README, README.ja: Update the portability section.\n",
# "\n"]
# ["r16725 | knu | 2008-05-31 23:34:23 +0900 (Sat, 31 May 2008) | 2 lines\n",
# "\n",
# "* README, README.ja: Add a note about default C flags.\n",
# "\n"]
# ...
テキストを空行で区切られた段落に分けたい場合にも nil が使えます。
File.foreach("README").chunk {|line|
/\A\s*\z/ !~ line || nil
}.each {|_, lines|
pp lines
}
「:_alone」は要素を素通ししたい場合に用います。 以下の例では「Foo#bar」という形式の行が連続している場合のみ チャンク化し、それ以外は素通しします。
pat = /\A[A-Z][A-Za-z0-9_]+\#/
open(filename) {|f|
f.chunk {|line| pat =~ line ? $& : :_alone }.each {|key, lines|
if key != :_alone
print lines.sort.join('')
else
print lines.join('')
end
}
}
チャンク化に状態遷移が必要な場合は、 オプション引数 initial_state に状態を保持するオブジェクトを渡します。 この場合、ブロックの第2引数にはこのオブジェクトが dup で複製 されて渡されます。
collect -> Enumerator[permalink][rdoc]map -> Enumeratorcollect {|item| ... } -> [object]map {|item| ... } -> [object]各要素に対してブロックを評価した結果を全て含む配列を返します。
ブロックを省略した場合、上で説明した繰り返しを実行し、その結果として 得られる配列を返すような Enumerator オブジェクトを返します。
例:
# すべて 3 倍にする
p [1, 2, 3].map {|n| n * 3 } # => [3, 6, 9]
flat_map -> Enumerator[permalink][rdoc]collect_concat -> Enumeratorflat_map {| obj | block } -> Arraycollect_concat {| obj | block } -> Array各要素をブロックに渡し、その返り値を連結した配列を返します。
ブロックの返り値は基本的に配列を返すべきです。
ブロックを省略した場合は、ブロックを受けとり 上で説明した評価をし、その結果の配列を返す Enumerator オブジェクトを返します。
[[1,2], [3,4]].flat_map{|i| i.map{|j| j*2}} # => [2,4,6,8]
count -> Integer[permalink][rdoc]count(item) -> Integercount {|obj| ... } -> Integerレシーバの要素数を返します。
引数を指定しない場合は、レシーバの要素数を返します。 このとき、 要素数を一つずつカウントします。
引数を一つ指定した場合は、レシーバの要素のうち引数に一致するものの 個数をカウントして返します(一致は == で判定します)。
ブロックを指定した場合は、ブロックを評価して真になった要素の個数を カウントして返します。
例:
ary = [1, 2, 4, 2]
ary.count # => 4
ary.count(2) # => 2
ary.count{|x|x%2==0} # => 3
cycle(n=nil) -> Enumerator[permalink][rdoc]cycle(n=nil) {|obj| ... } -> object | nilEnumerable オブジェクトの各要素を 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.
ブロックを省略した場合は、n 回 or 無限回 enum の各要素を 繰り返す Enumerator を返します。
find(ifnone = nil) -> Enumerator[permalink][rdoc]detect(ifnone = nil) -> Enumeratorfind(ifnone = nil) {|item| ... } -> objectdetect(ifnone = nil) {|item| ... } -> object要素に対してブロックを評価した値が真になった最初の要素を返します。
真になる要素が見つからず、ifnone も指定されていないときは nil を返します。 真になる要素が見つからず、ifnone が指定されているときは ifnone を call した結果を返します。
ブロックを省略した場合は、各要素に対しブロックを真になるまで評価し、最初に 真になった値を返すような Enumerator を返します。
例:
# 最初の 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
drop(n) -> Array[permalink][rdoc]Enumerable オブジェクトの先頭の n 要素を捨てて、 残りの要素を配列として返します。
a = [1, 2, 3, 4, 5, 0] a.drop(3) # => [4, 5, 0]
drop_while -> Enumerator[permalink][rdoc]drop_while {|element| ... } -> Arrayブロックを評価して最初に偽となった要素の手前の要素まで捨て、 残りの要素を配列として返します。
ブロックを指定しなかった場合は、Enumerator を返します。
a = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 } # => [3, 4, 5, 0]
each_cons(n) -> Enumerator[permalink][rdoc]each_cons(n) {|list| ... } -> nil要素を重複ありで n 要素ずつに区切り、 ブロックに渡して繰り返します。
ブロックを省略した場合は重複ありで n 要素ずつ繰り返す Enumerator を返します。
例:
(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_entry -> Enumerator[permalink][rdoc]each_entry {|obj| block} -> selfブロックを各要素に一度ずつ適用します。
一要素として複数の値が渡された場合はブロックには配列として渡されます。
class Foo
include Enumerable
def each
yield 1
yield 1,2
end
end
Foo.new.each_entry{|o| print o, " -- "}
# => 1 -- [1, 2] --
ブロックを省略した場合は Enumerator が返されます。
[SEE_ALSO] Enumerable#slice_before
each_slice(n) -> Enumerator[permalink][rdoc]each_slice(n) {|list| ... } -> niln 要素ずつブロックに渡して繰り返します。
要素数が n で割り切れないときは、最後の回だけ要素数が減ります。
ブロックを省略した場合は n 要素ずつ繰り返す Enumerator を返します。
例:
(1..10).each_slice(3) {|a| p a}
# => [1, 2, 3]
# [4, 5, 6]
# [7, 8, 9]
# [10]
[SEE_ALSO] Enumerable#each_cons
each_with_index -> Enumerator[permalink][rdoc]each_with_index {|item, index| ... } -> self要素とそのインデックスをブロックに渡して繰り返します。
self を返します。
ブロックを省略した場合は、 要素とそのインデックスを繰り返すような Enumerator を返します。
例:
[5, 10, 15].each_with_index do |n, idx|
p [n, idx]
end
# => [5, 0]
# [10, 1]
# [15, 2]
each_with_object(obj) -> Enumerator[permalink][rdoc]each_with_object(obj) {|(*args), memo_obj| ... } -> object与えられた任意のオブジェクトと要素をブロックに渡し繰り返し、最初に与えられたオブジェクトを返します。
ブロックを省略した場合は、上の繰り返しをして、最初に与えたオブジェクトを 最後に返す Enumerator を返します。
evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[SEE_ALSO] Enumerator#with_object
to_a(*args) -> [object][permalink][rdoc]entries(*args) -> [object]全ての要素を含む配列を返します。
例:
(1..7).to_a #=> [1, 2, 3, 4, 5, 6, 7]
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a #=> [["a", 1], ["b", 2], ["c", 3]]
require 'prime'
Prime.entries 10 #=> [2, 3, 5, 7]
find_all -> Enumerator[permalink][rdoc]select -> Enumeratorfind_all {|item| ... } -> [object]select {|item| ... } -> [object]各要素に対してブロックを評価した値が真であった要素を全て含む配列を 返します。真になる要素がひとつもなかった場合は空の配列を返します。
ブロックを省略した場合は、各要素に対しブロックを評価し 真になった値の配列を返すような Enumerator を返します。
例:
(1..10).find_all # => #<Enumerator: 1..10:find_all>
(1..10).find_all { |i| i % 3 == 0 } # => [3, 6, 9]
[1,2,3,4,5].select # => #<Enumerator: [1, 2, 3, 4, 5]:select>
[1,2,3,4,5].select { |num| num.even? } # => [2, 4]
[SEE_ALSO] Enumerable#reject
[SEE_ALSO] Enumerable#grep
find_index(val) -> Integer | nil[permalink][rdoc]find_index {|obj| ... } -> Integer | nilfind_index -> Enumerator条件に一致する最初の要素の位置を返します。
指定された val と == で等しい最初の要素の位置を返します。 等しい要素がひとつもなかった場合は nil を返します。
(1..10).find_index(11) #=> nil (1..10).find_index(2) #=> 1
ブロックが与えられた場合には、各要素を引数として先頭から順にブロックを実行し、 ブロックが真を返した最初の要素の位置を返します。 一つも真にならなかった場合は 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
引数、ブロックのどちらも与えられなかった場合は、 Enumerator のインスタンスを返します。
first -> object | nil[permalink][rdoc]first(n) -> ArrayEnumerable オブジェクトの最初の要素、もしくは最初の n 要素を返します。
Enumerable オブジェクトが空の場合、引数を指定しない形式では nil を返します。 引数を指定する形式では、空の配列を返します。
e = "abcd".each_byte e.first #=> 97 e.first(2) #=> [97,98] e = "".each_byte e.first #=> nil e.first(2) #=> []
grep(pattern) -> [object][permalink][rdoc]grep(pattern) {|item| ... } -> [object]pattern === item が成立する要素を全て含んだ配列を返します。
ブロックとともに呼び出された時には条件の成立した要素に対して それぞれブロックを評価し、その結果の配列を返します。 マッチする要素がひとつもなかった場合は空の配列を返します。
例:
['aa', 'bb', 'cc', 'dd', 'ee'].grep(/[bc]/) # => ["bb", "cc"] Array.instance_methods.grep(/gr/) # => [:grep, :group_by]
[SEE_ALSO] Enumerable#select
group_by -> Enumerator[permalink][rdoc]group_by {|obj| ... } -> Hashブロックを評価した結果をキー、対応する要素の配列を値とするハッシュを返します。
(1..6).group_by {|i| i%3} #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
ブロックを省略した場合は、最後に Hash を返す Enumerator オブジェクトを返します。
member?(val) -> bool[permalink][rdoc]include?(val) -> boolval と == の関係にある要素を含むとき真を返します。
例:
IO.constants.include? :SEEK_SET #=> true IO.constants.include? :SEEK_NO_FURTHER #=> false IO.constants.member? :SEEK_SET #=> true IO.constants.member? :SEEK_NO_FURTHER #=> false
inject(init = self.first) {|result, item| ... } -> object[permalink][rdoc]inject(sym) -> objectinject(init, sym) -> objectreduce(init = self.first) {|result, item| ... } -> objectreduce(sym) -> objectreduce(init, sym) -> objectリストのたたみこみ演算を行います。
最初に初期値 init と self の最初の要素を引数にブロックを実行します。 2 回目以降のループでは、前のブロックの実行結果と self の次の要素を引数に順次ブロックを実行します。 そうして最後の要素まで繰り返し、最後のブロックの実行結果を返します。
要素が存在しない場合は init を返します。
初期値 init を省略した場合は、 最初に先頭の要素と 2 番目の要素をブロックに渡します。 また要素が 1 つしかなければブロックを実行せずに最初の要素を返します。 要素がなければブロックを実行せずに nil を返します。
例:
# 合計を計算する。
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"
lazy -> Enumerator::Lazy[permalink][rdoc]自身を lazy な Enumerator に変換したものを返します。
この Enumerator は、以下のメソッドが遅延評価を行う (つまり、配列ではな くEnumeratorを返す) ように再定義されています。
以下はピタゴラス数 (a**2 + b**2 = c**2 を満たす自然数 a, b, c の組) を 列挙するプログラムです。
def pythagorean_triples
(1..Float::INFINITY).lazy.flat_map {|z|
(1..z).flat_map {|x|
(x..z).select {|y|
x**2 + y**2 == z**2
}.map {|y|
[x, y, z]
}
}
}
end
# 最初の10個のピタゴラス数を表示する
p pythagorean_triples.take(10).force # takeはlazyなので、forceが必要です
p pythagorean_triples.first(10) # firstはeagerです
# 100より小さいピタゴラス数を表示する
p pythagorean_triples.take_while { |*, z| z < 100 }.force
[SEE_ALSO] Enumerator::Lazy
max -> object | nil[permalink][rdoc]max(n) -> Array最大の要素、もしくは最大の n 要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。
引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。
例:
a = %w(albatross dog horse) a.max # => "horse" a.max(2) # => ["horse", "dog"]
max {|a, b| ... } -> object | nil[permalink][rdoc]max(n) {|a, b| ... } -> Arrayブロックの評価結果で各要素の大小判定を行い、最大の要素、もしくは最小の n 要素を返します。 引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。
ブロックの値は、a > b のとき正、 a == b のとき 0、a < b のとき負の整数を、期待しています。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
例:
class Person
attr_reader :name, :age
def initialize(name, age)
@name = name
@age = age
end
end
people = [
Person.new("sato", 55),
Person.new("sato", 33),
Person.new("sato", 11),
Person.new("suzuki", 55),
Person.new("suzuki", 33),
Person.new("suzuki", 11),
Person.new("tanaka", 55),
Person.new("tanaka", 33),
Person.new("tanaka", 11)
]
# 年齢が最大、名前が最小
people.max { |x, y| (x.age <=> y.age).nonzero? || y.name <=> x.name }
# => #<Person:0x007fc54b0240a0 @name="sato", @age=55>
people.max(2) { |x, y| (x.age <=> y.age).nonzero? || y.name <=> x.name }
# => [#<Person:0x007fc54b0240a0 @name="sato", @age=55>, #<Person:0x007fc54c033ea0 @name="suzuki", @age=55>]
max_by -> Enumerator[permalink][rdoc]max_by(n) -> Enumeratormax_by {|item| ... } -> object | nilmax_by(n) {|item| ... } -> Array各要素を順番にブロックに渡して実行し、 その評価結果を <=> で比較して、 最大であった値に対応する元の要素、もしくは最大の n 要素を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。
Enumerable#max と Enumerable#max_by の 違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。
ブロックを省略した場合は Enumerator を返します。
例:
a = %w(albatross dog horse)
a.max_by # => #<Enumerator: ["albatross", "dog", "horse"]:max_by>
a.max_by { |x| x.length } # => "albatross"
例:
a = %w[albatross dog horse]
a.max_by(2) # => #<Enumerator: ["albatross", "dog", "horse"]:max_by(2)>
a.max_by(2) {|x| x.length } # => ["albatross", "horse"]
例: enum.max_by（n）は、重み付きランダムサンプリングを実装するために使用できます。次の実装例は、Enumerable#wsampleを使用します。
module Enumerable
# weighted random sampling.
#
# Pavlos S. Efraimidis, Paul G. Spirakis
# Weighted random sampling with a reservoir
# Information Processing Letters
# Volume 97, Issue 5 (16 March 2006)
def wsample(n)
self.max_by(n) {|v| rand ** (1.0/yield(v)) }
end
end
e = (-20..20).to_a*10000
a = e.wsample(20000) {|x|
Math.exp(-(x/5.0)**2) # normal distribution
}
# a is 20000 samples from e.
p a.length #=> 20000
h = a.group_by {|x| x }
-10.upto(10) {|x| puts "*" * (h[x].length/30.0).to_i if h[x] }
#=> *
# ***
# ******
# ***********
# ******************
# *****************************
# *****************************************
# ****************************************************
# ***************************************************************
# ********************************************************************
# ***********************************************************************
# ***********************************************************************
# **************************************************************
# ****************************************************
# ***************************************
# ***************************
# ******************
# ***********
# *******
# ***
# *
[SEE_ALSO] Enumerable#sort_by
min -> object | nil[permalink][rdoc]min(n) -> Array最小の要素、もしくは最小の n 要素を返します。 全要素が互いに <=> メソッドで比較できることを仮定しています。
引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。 該当する要素が複数存在する場合、どの要素を返すかは不定です。
例:
a = %w(albatross dog horse) a.min # => "albatross" a.min(2) # => ["albatross", "dog"]
min {|a, b| ... } -> object | nil[permalink][rdoc]min(n) {|a, b| ... } -> Arrayブロックの評価結果で各要素の大小判定を行い、最小の要素、もしくは最小の n 要素を返します。 引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。
ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
例:
class Person
attr_reader :name, :age
def initialize(name, age)
@name = name
@age = age
end
end
people = [
Person.new("sato", 55),
Person.new("sato", 33),
Person.new("sato", 11),
Person.new("suzuki", 55),
Person.new("suzuki", 33),
Person.new("suzuki", 11),
Person.new("tanaka", 55),
Person.new("tanaka", 33),
Person.new("tanaka", 11)
]
# 年齢が最小、名前が最大
people.min { |x, y| (x.age <=> y.age).nonzero? || y.name <=> x.name }
# => #<Person:0x007fd6f0824190 @name="tanaka", @age=11>
people.min(2) { |x, y| (x.age <=> y.age).nonzero? || y.name <=> x.name }
# => [#<Person:0x007fb5899ef4a8 @name="tanaka", @age=11>, #<Person:0x007fb5899ef728 @name="suzuki", @age=11>]
min_by -> Enumerator[permalink][rdoc]min_by(n) -> Enumeratormin_by {|item| ... } -> object | nilmin_by(n) {|item| ... } -> Array各要素を順番にブロックに渡して評価し、 その評価結果を <=> で比較して、 最小であった値に対応する元の要素、もしくは最小の n 要素を返します。
引数を指定しない形式では要素が存在しなければ nil を返します。 引数を指定する形式では、空の配列を返します。
該当する要素が複数存在する場合、どの要素を返すかは不定です。
ブロックを省略した場合は Enumerator を返します。
Enumerable#min と Enumerable#min_by の 違いは Enumerable#sort と Enumerable#sort_by の違いと同じです。
例:
a = %w(albatross dog horse)
a.min_by # => #<Enumerator: ["albatross", "dog", "horse"]:min_by>
a.min_by { |x| x.length } # => "dog"
a.min_by(2) # => #<Enumerator: ["albatross", "dog", "horse"]:min_by(2)>
a.min_by(2) {|x| x.length } # => ["dog", "horse"]
[SEE_ALSO] Enumerable#sort_by
minmax -> [object, object][permalink][rdoc]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 -> Enumerator[permalink][rdoc]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]
ブロックを省略した場合は、Enumerator オブジェクトを 返します。
[SEE_ALSO] Enumerable#sort_by
none? -> bool[permalink][rdoc]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
[nil, false, true].none? # => false
one? -> bool[permalink][rdoc]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
[].one? # => false
partition -> Enumerator[permalink][rdoc]partition {|item| ... } -> [[object], [object]]各要素を、ブロックの条件を満たす要素と満たさない要素に分割します。 各要素に対してブロックを評価して、その値が真であった要素の配列と、 偽であった要素の配列の 2 つを配列に入れて返します。
ブロックを省略した場合は、各要素に対しブロックを評価し、 上のようにその値が真であった要素の配列と、 偽であった要素の配列のペアを返すような Enumerator を 返します。
例:
[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]]
reject -> Enumerator[permalink][rdoc]reject {|item| ... } -> [object]各要素に対してブロックを評価し、 その値が偽であった要素を集めた新しい配列を返します。 条件を反転させた select です。
ブロックを省略した場合は、各要素に対しブロックを評価し 偽になった値の配列を返すような Enumerator を返します。
例:
# 偶数を除外する (奇数を集める)
[1, 2, 3, 4, 5, 6].reject {|i| i % 2 == 0 } # => [1, 3, 5]
[SEE_ALSO] Enumerable#select
reverse_each -> Enumerator[permalink][rdoc]reverse_each {|element| ... } -> self逆順に各要素に対してブロックを評価します。
内部で各要素を保持した配列を作ります。
ブロックを省略した場合は、各要素を逆順に辿る Enumerator を返します。
例:
(1..3).reverse_each # => #<Enumerator: 1..3:reverse_each>
(1..3).reverse_each { |v| p v }
# => 3
# 2
# 1
slice_after(pattern) -> Enumerator[permalink][rdoc]slice_after {|elt| bool } -> Enumeratorパターンがマッチした要素、もしくはブロックが真を返した要素を末尾の要素 としてチャンク化(グループ化)したものを繰り返す Enumerator を 返し ます。
パターンを渡した場合は各要素に対し === が呼び出され、 それが真になった ところをチャンクの末尾と見なします。 ブロックを渡した場合は、各要素に対 しブロックを適用し 返り値が真であった要素をチャンクの末尾と見なします。
パターンもブロックも最初から最後の要素まで呼び出されます。
各チャンクは配列として表現されます。そのため、以下のような呼び出しを行 う事もできます。
enum.slice_after(pattern).each { |ary| ... }
enum.slice_after { |elt| bool }.each { |ary| ... }
例:
# 偶数要素をチャンクの末尾と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_after(&:even?).to_a
# => [[0], [2], [4], [1, 2], [4], [5, 3, 1, 4], [2]]
# 奇数要素をチャンクの末尾と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_after(&:odd?).to_a
# => [[0, 2, 4, 1], [2, 4, 5], [3], [1], [4, 2]]
# バックスラッシュで終わる行を継続
lines = ["foo\n", "bar\\\n", "baz\n", "\n", "qux\n"]
e = lines.slice_after(/(?<!\\)\n\z/)
p e.to_a
#=> [["foo\n"], ["bar\\\n", "baz\n"], ["\n"], ["qux\n"]]
p e.map {|ll| ll[0...-1].map {|l| l.sub(/\\\n\z/, "") }.join + ll.last }
#=>["foo\n", "barbaz\n", "\n", "qux\n"]
Enumerable#map のようなメソッドを使うこともできます。
[SEE_ALSO] Enumerable#chunk, Enumerable#slice_before
slice_before(pattern) -> Enumerator[permalink][rdoc]slice_before {|elt| bool } -> Enumeratorslice_before(initial_state) {|elt, state| bool } -> Enumeratorパターンがマッチした要素、もしくはブロックが真を返した要素から 次にマッチする手前までを チャンク化(グループ化)したものを繰り返す Enumerator を 返します。
パターンを渡した場合は各要素に対し === が呼び出され、 それが真になったところをチャンクの先頭と見なします。 ブロックを渡した場合は、各要素に対しブロックを適用し 返り値が真であった要素をチャンクの先頭と見なします。
より厳密にいうと、「先頭要素」の手前で分割していきます。 最初の要素の評価は無視されます。
各チャンクは配列として表現されます。
Enumerable#to_a や Enumerable#map のようなメソッドを使うこ ともできます。
# 偶数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_before(&:even?).to_a
# => [[0], [2], [4, 1], [2], [4, 5, 3, 1], [4], [2]]
# 奇数要素をチャンクの先頭と見なす
[0,2,4,1,2,4,5,3,1,4,2].slice_before(&:odd?).to_a
# => [[0, 2, 4], [1, 2, 4], [5], [3], [1, 4, 2]]
# ChangeLog のエントリーを順に取る
open("ChangeLog") {|f|
f.slice_before(/\A\S/).each {|e| pp e}
}
# 上と同じだが、パターンでなくブロックを使う
open("ChangeLog") {|f|
f.slice_before {|line| /\A\S/ === line }.each {|e| pp e}
}
# "svn proplist -R" の結果を分割する
# これは一要素が複数行にまたがっている
IO.popen([{"LC_ALL"=>"C"}, "svn", "proplist", "-R"]) {|f|
f.lines.slice_before(/\AProp/).each {|lines| p lines }
}
#=> ["Properties on '.':\n", " svn:ignore\n", " svk:merge\n"]
# ["Properties on 'goruby.c':\n", " svn:eol-style\n"]
# ["Properties on 'complex.c':\n", " svn:mime-type\n", " svn:eol-style\n"]
# ["Properties on 'regparse.c':\n", " svn:eol-style\n"]
# ...
複数要素にわたる状態遷移が必要な場合は、ローカル変数でこれを実現する ことができます。例えば、連続に増える数値が3つ以上ある場合、これを まとめる処理をするためには以下のようにします (Enumerable#chunk_while のより簡単な例も参照)。
a = [0,2,3,4,6,7,9]
prev = a[0]
p a.slice_before {|e|
prev, prev2 = e, prev
prev2 + 1 != e
}.map {|es|
es.length <= 2 ? es.join(",") : "#{es.first}-#{es.last}"
}.join(",")
#=> "0,2-4,6,7,9"
しかし、ローカル変数を使うのが不適切な場合もあります。 その場合、引数 initial_state に状態を保持するオブジェクトを 渡すと、そのオブジェクトを Object#dup したオブジェクトを 各要素ごとのブロック呼び出しの第2引数として渡します。
# word wrapping.
# this assumes all characters have same width.
def wordwrap(words, maxwidth)
# if cols is a local variable, 2nd "each" may start with non-zero cols.
words.slice_before(cols: 0) {|w, h|
h[:cols] += 1 if h[:cols] != 0
h[:cols] += w.length
if maxwidth < h[:cols]
h[:cols] = w.length
true
else
false
end
}
end
text = (1..20).to_a.join(" ")
enum = wordwrap(text.split(/\s+/), 10)
puts "-"*10
enum.each {|ws| puts ws.join(" ") }
puts "-"*10
#=> ----------
# 1 2 3 4 5
# 6 7 8 9 10
# 11 12 13
# 14 15 16
# 17 18 19
# 20
# ----------
以下は mbox を分割する例です。mbox 内の各メールは Unix From line で始まっています。そこで slice_before を用います。
# parse mbox
open("mbox") {|f|
f.slice_before {|line|
line.start_with? "From "
}.each {|mail|
unix_from = mail.shift
i = mail.index("\n")
header = mail[0...i]
body = mail[(i+1)..-1]
body.pop if body.last == "\n"
fields = header.slice_before {|line| !" \t".include?(line[0]) }.to_a
p unix_from
pp fields
pp body
}
}
# split mails in mbox (slice before Unix From line after an empty line)
open("mbox") {|f|
f.slice_before(emp: true) {|line,h|
prevemp = h[:emp]
h[:emp] = line == "\n"
prevemp && line.start_with?("From ")
}.each {|mail|
mail.pop if mail.last == "\n"
pp mail
}
}
[SEE_ALSO] Enumerable#chunk, Enumerable#slice_after
slice_when {|elt_before, elt_after| bool } -> Enumerator[permalink][rdoc]要素を前から順にブロックで評価し、その結果によって要素をチャンクに分け た(グループ化した)要素を持つEnumerator を返します。
隣り合う値をブロックパラメータ elt_before、elt_after に渡し、ブロックの 評価値が真になる所でチャンクを区切ります。
ブロックは self の長さ - 1 回呼び出されます。
enum.slice_when { |elt_before, elt_after| bool }.each { |ary| ... }
to_a や map などのその他の Enumerable モジュールのメソッ
ドも有用です。
例:
# 1ずつ増加する部分配列ごとに分ける。
a = [1,2,4,9,10,11,12,15,16,19,20,21]
b = a.slice_when {|i, j| i+1 != j }
p b.to_a # => [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]
c = b.map {|a| a.length < 3 ? a : "#{a.first}-#{a.last}" }
p c # => [[1, 2], [4], "9-12", [15, 16], "19-21"]
d = c.join(",")
p d # => "1,2,4,9-12,15,16,19-21"
# ソート済の配列を近い値(差が6以内)の部分配列ごとに分ける。
a = [3, 11, 14, 25, 28, 29, 29, 41, 55, 57]
p a.slice_when {|i, j| 6 < j - i }.to_a
# => [[3], [11, 14], [25, 28, 29, 29], [41], [55, 57]]
# 増加のみの部分配列ごとに分ける。
a = [0, 9, 2, 2, 3, 2, 7, 5, 9, 5]
p a.slice_when {|i, j| i > j }.to_a
# => [[0, 9], [2, 2, 3], [2, 7], [5, 9], [5]]
# 隣り合う偶数同士、奇数同士の部分配列ごとに分ける。
# (Enumerable#chunk を使って実現する事も可能)
a = [7, 5, 9, 2, 0, 7, 9, 4, 2, 0]
p a.slice_when {|i, j| i.even? != j.even? }.to_a
# => [[7, 5, 9], [2, 0], [7, 9], [4, 2, 0]]
# 段落(空行が後ろに続く非空行の文字列)ごとに分ける。
# (Enumerable#chunk で空行を無視して実現する事も可能)
lines = ["foo\n", "bar\n", "\n", "baz\n", "qux\n"]
p lines.slice_when {|l1, l2| /\A\s*\z/ =~ l1 && /\S/ =~ l2 }.to_a
# => [["foo\n", "bar\n", "\n"], ["baz\n", "qux\n"]]
Enumerable#chunk_while はブロックの戻り値が偽ではなく真の時に要 素を分ける事を除いて同じ処理を行います。
[SEE_ALSO] Enumerable#chunk
sort -> [object][permalink][rdoc]sort {|a, b| ... } -> [object]全ての要素を昇順にソートした配列を生成して返します。
ブロックなしのときは <=> メソッドを要素に対して呼び、 その結果をもとにソートします。
<=> 以外でソートしたい場合は、ブロックを指定します。 この場合、ブロックの評価結果を元にソートします。 ブロックの値は、a > b のとき正、a == b のとき 0、 a < b のとき負の整数を、期待しています。 ブロックが整数以外を返したときは例外 TypeError が発生します。
Enumerable#sort は安定ではありません (unstable sort)。 安定なソートが必要な場合は Enumerable#sort_by を使って工夫する必要があります。 詳しくは Enumerable#sort_by の項目を参照してください。
※ 比較結果が同じ要素は元の順序通りに並ぶソートを 「安定なソート (stable sort)」と言います。
例:
%w(rhea kea flea).sort # => ["flea", "kea", "rhea"]
(1..10).sort { |a, b| b <=> a } # => [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[SEE_ALSO] Enumerable#sort_by
sort_by -> Enumerator[permalink][rdoc]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)」と言います。
ブロックを省略した場合は、各要素をブロックで評価した値でソートした 配列を返すような Enumerator を返します。
[SEE_ALSO] Enumerable#sort
take(n) -> Array[permalink][rdoc]Enumerable オブジェクトの先頭から n 要素を配列として返します。
a = [1, 2, 3, 4, 5, 0] a.take(3) # => [1, 2, 3]
take_while -> Enumerator[permalink][rdoc]take_while {|element| ... } -> ArrayEnumerable オブジェクトの要素を順に偽になるまでブロックで評価します。 最初に偽になった要素の手前の要素までを配列として返します。
a = [1, 2, 3, 4, 5, 0]
a.take_while {|i| i < 3 } # => [1, 2]
ブロックを省略した場合は、Enumerator オブジェクトを 返します。
to_h(*args) -> Hash[permalink][rdoc]self を [key, value] のペアの配列として解析した結果を Hash にして 返します。
%i[hello world].each_with_index.to_h
# => {:hello => 0, :world => 1}
zip(*lists) -> [[object]][permalink][rdoc]zip(*lists) {|v1, v2, ...| ...} -> nilself と引数に渡した配列の各要素からなる配列の配列を生成して返します。 生成される配列の要素数は self の要素数と同じです。
ブロック付きで呼び出した場合は、 self と引数に渡した配列の各要素を順番にブロックに渡します。
例:
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